RELEASE: 0.0.341 (#13926)

<!-- Thank you for contributing to LangChain!

Replace this entire comment with:
  - **Description:** a description of the change, 
  - **Issue:** the issue # it fixes (if applicable),
  - **Dependencies:** any dependencies required for this change,
- **Tag maintainer:** for a quicker response, tag the relevant
maintainer (see below),
- **Twitter handle:** we announce bigger features on Twitter. If your PR
gets announced, and you'd like a mention, we'll gladly shout you out!

Please make sure your PR is passing linting and testing before
submitting. Run `make format`, `make lint` and `make test` to check this
locally.

See contribution guidelines for more information on how to write/run
tests, lint, etc:

https://github.com/langchain-ai/langchain/blob/master/.github/CONTRIBUTING.md

If you're adding a new integration, please include:
1. a test for the integration, preferably unit tests that do not rely on
network access,
2. an example notebook showing its use. It lives in `docs/extras`
directory.

If no one reviews your PR within a few days, please @-mention one of
@baskaryan, @eyurtsev, @hwchase17.
 -->

.devcontainer/README.md

@@ -17,13 +17,16 @@ For more info, check out the [GitHub documentation](https://docs.github.com/en/f
 ## VS Code Dev Containers
 [![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchain)
 
-Note: If you click this link you will open the main repo and not your local cloned repo, you can use this link and replace with your username and cloned repo name: 
+Note: If you click the link above you will open the main repo (langchain-ai/langchain) and not your local cloned repo. This is fine if you only want to run and test the library, but if you want to contribute you can use the  link below and replace with your username and cloned repo name: 
+```
 https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/<yourusername>/<yourclonedreponame>
 
+```
+Then you will have a local cloned repo where you can contribute and then create pull requests.
 
 If you already have VS Code and Docker installed, you can use the button above to get started. This will cause VS Code to automatically install the Dev Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use.
 
-You can also follow these steps to open this repo in a container using the VS Code Dev Containers extension:
+Alternatively you can also follow these steps to open this repo in a container using the VS Code Dev Containers extension:
 
 1. If this is your first time using a development container, please ensure your system meets the pre-reqs (i.e. have Docker installed) in the [getting started steps](https://aka.ms/vscode-remote/containers/getting-started).
 

.github/CONTRIBUTING.md

@@ -134,14 +134,21 @@ Run these locally before submitting a PR; the CI system will check also.
 
 #### Code Formatting
 
-Formatting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/) and [ruff](https://docs.astral.sh/ruff/rules/).
+Formatting for this project is done via [ruff](https://docs.astral.sh/ruff/rules/).
 
-To run formatting for this project:
+To run formatting for docs, cookbook and templates:
 
 ```bash
 make format
 ```
 
+To run formatting for a library, run the same command from the relevant library directory:
+
+```bash
+cd libs/{LIBRARY}
+make format
+```
+
 Additionally, you can run the formatter only on the files that have been modified in your current branch as compared to the master branch using the format_diff command:
 
 ```bash
@@ -152,14 +159,21 @@ This is especially useful when you have made changes to a subset of the project
 
 #### Linting
 
-Linting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/), [ruff](https://docs.astral.sh/ruff/rules/), and [mypy](http://mypy-lang.org/).
+Linting for this project is done via a combination of [ruff](https://docs.astral.sh/ruff/rules/) and [mypy](http://mypy-lang.org/).
 
-To run linting for this project:
+To run linting for docs, cookbook and templates:
 
 ```bash
 make lint
 ```
 
+To run linting for a library, run the same command from the relevant library directory:
+
+```bash
+cd libs/{LIBRARY}
+make lint
+```
+
 In addition, you can run the linter only on the files that have been modified in your current branch as compared to the master branch using the lint_diff command:
 
 ```bash
@@ -288,8 +302,8 @@ make api_docs_linkcheck
 
 ### Verify Documentation changes
 
-After pushing documentation changes to the repository, you can preview and verify that the changes are 
-what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page. 
+After pushing documentation changes to the repository, you can preview and verify that the changes are
+what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page.
 This will take you to a preview of the documentation changes.
 This preview is created by [Vercel](https://vercel.com/docs/getting-started-with-vercel).
 

.github/workflows/_compile_integration_test.yml

@@ -7,6 +7,10 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
+      langchain-core-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain core library folder"
 
 env:
   POETRY_VERSION: "1.6.1"
@@ -40,6 +44,14 @@ jobs:
         shell: bash
         run: poetry install --with=test_integration
 
+      - name: Install langchain core editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-core-location }}
+        env:
+          LANGCHAIN_CORE_LOCATION: ${{ inputs.langchain-core-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_CORE_LOCATION"
+
       - name: Check integration tests compile
         shell: bash
         run: poetry run pytest -m compile tests/integration_tests

.github/workflows/_lint.yml

@@ -7,20 +7,25 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
+      langchain-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain library folder"
+      langchain-core-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain core library folder"
 
 env:
   POETRY_VERSION: "1.6.1"
   WORKDIR: ${{ inputs.working-directory == '' && '.' || inputs.working-directory }}
 
+  # This env var allows us to get inline annotations when ruff has complaints.
+  RUFF_OUTPUT_FORMAT: github
+
 jobs:
   build:
     runs-on: ubuntu-latest
-    env:
-      # This number is set "by eye": we want it to be big enough
-      # so that it's bigger than the number of commits in any reasonable PR,
-      # and also as small as possible since increasing the number makes
-      # the initial `git fetch` slower.
-      FETCH_DEPTH: 50
     strategy:
       matrix:
         # Only lint on the min and max supported Python versions.
@@ -35,51 +40,6 @@ jobs:
           - "3.11"
     steps:
       - uses: actions/checkout@v4
-        with:
-          # Fetch the last FETCH_DEPTH commits, so the mtime-changing script
-          # can accurately set the mtimes of files modified in the last FETCH_DEPTH commits.
-          fetch-depth: ${{ env.FETCH_DEPTH }}
-      - name: Restore workdir file mtimes to last-edited commit date
-        id: restore-mtimes
-        # This is needed to make black caching work.
-        # Black's cache uses file (mtime, size) to check whether a lookup is a cache hit.
-        # Without this command, files in the repo would have the current time as the modified time,
-        # since the previous action step just created them.
-        # This command resets the mtime to the last time the files were modified in git instead,
-        # which is a high-quality and stable representation of the last modification date.
-        run: |
-          # Important considerations:
-          # - These commands run at base of the repo, since we never `cd` to the `WORKDIR`.
-          # - We only want to alter mtimes for Python files, since that's all black checks.
-          # - We don't need to alter mtimes for directories, since black doesn't look at those.
-          # - We also only alter mtimes inside the `WORKDIR` since that's all we'll lint.
-          # - This should run before `poetry install`, because poetry's venv also contains
-          #   Python files, and we don't want to alter their mtimes since they aren't linted.
-
-          # Ensure we fail on non-zero exits and on undefined variables.
-          # Also print executed commands, for easier debugging.
-          set -eux
-
-          # Restore the mtimes of Python files in the workdir based on git history.
-          .github/tools/git-restore-mtime --no-directories "$WORKDIR/**/*.py"
-
-          # Since CI only does a partial fetch (to `FETCH_DEPTH`) for efficiency,
-          # the local git repo doesn't have full history. There are probably files
-          # that were last modified in a commit *older than* the oldest fetched commit.
-          # After `git-restore-mtime`, such files have a mtime set to the oldest fetched commit.
-          #
-          # As new commits get added, that timestamp will keep moving forward.
-          # If left unchanged, this will make `black` think that the files were edited
-          # more recently than its cache suggests. Instead, we can set their mtime
-          # to a fixed date in the far past that won't change and won't cause cache misses in black.
-          #
-          # For all workdir Python files modified in or before the oldest few fetched commits,
-          # make their mtime be 2000-01-01 00:00:00.
-          OLDEST_COMMIT="$(git log --reverse '--pretty=format:%H' | head -1)"
-          OLDEST_COMMIT_TIME="$(git show -s '--format=%ai' "$OLDEST_COMMIT")"
-          find "$WORKDIR" -name '*.py' -type f -not -newermt "$OLDEST_COMMIT_TIME" -exec touch -c -m -t '200001010000' '{}' '+'
-
-          echo "oldest-commit=$OLDEST_COMMIT" >> "$GITHUB_OUTPUT"
 
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
         uses: "./.github/actions/poetry_setup"
@@ -116,22 +76,19 @@ jobs:
 
       - name: Install langchain editable
         working-directory: ${{ inputs.working-directory }}
-        if: ${{ inputs.working-directory != 'libs/langchain' }}
-        run: |
-          pip install -e ../langchain
-
-      - name: Restore black cache
-        uses: actions/cache@v3
+        if: ${{ inputs.langchain-location }}
         env:
-          CACHE_BASE: black-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', env.WORKDIR)) }}
-          SEGMENT_DOWNLOAD_TIMEOUT_MIN: "1"
-        with:
-          path: |
-            ${{ env.WORKDIR }}/.black_cache
-          key: ${{ env.CACHE_BASE }}-${{ steps.restore-mtimes.outputs.oldest-commit }}
-          restore-keys:
-            # If we can't find an exact match for our cache key, accept any with this prefix.
-            ${{ env.CACHE_BASE }}-
+          LANGCHAIN_LOCATION: ${{ inputs.langchain-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_LOCATION"
+
+      - name: Install langchain core editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-core-location }}
+        env:
+          LANGCHAIN_CORE_LOCATION: ${{ inputs.langchain-core-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_CORE_LOCATION"
 
       - name: Get .mypy_cache to speed up mypy
         uses: actions/cache@v3
@@ -144,7 +101,5 @@ jobs:
 
       - name: Analysing the code with our lint
         working-directory: ${{ inputs.working-directory }}
-        env:
-          BLACK_CACHE_DIR: .black_cache
         run: |
           make lint

.github/workflows/_pydantic_compatibility.yml

@@ -7,6 +7,14 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
+      langchain-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain library folder"
+      langchain-core-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain core library folder"
 
 env:
   POETRY_VERSION: "1.6.1"
@@ -40,6 +48,22 @@ jobs:
         shell: bash
         run: poetry install
 
+      - name: Install langchain editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-location }}
+        env:
+          LANGCHAIN_LOCATION: ${{ inputs.langchain-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_LOCATION"
+
+      - name: Install langchain core editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-core-location }}
+        env:
+          LANGCHAIN_CORE_LOCATION: ${{ inputs.langchain-core-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_CORE_LOCATION"
+
       - name: Install the opposite major version of pydantic
         # If normal tests use pydantic v1, here we'll use v2, and vice versa.
         shell: bash

.github/workflows/_release.yml

@@ -9,13 +9,120 @@ on:
         description: "From which folder this pipeline executes"
 
 env:
+  PYTHON_VERSION: "3.10"
   POETRY_VERSION: "1.6.1"
 
 jobs:
-  if_release:
-    # Disallow publishing from branches that aren't `master`.
+  build:
     if: github.ref == 'refs/heads/master'
     runs-on: ubuntu-latest
+
+    outputs:
+      pkg-name: ${{ steps.check-version.outputs.pkg-name }}
+      version: ${{ steps.check-version.outputs.version }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
+          cache-key: release
+
+      # We want to keep this build stage *separate* from the release stage,
+      # so that there's no sharing of permissions between them.
+      # The release stage has trusted publishing and GitHub repo contents write access,
+      # and we want to keep the scope of that access limited just to the release job.
+      # Otherwise, a malicious `build` step (e.g. via a compromised dependency)
+      # could get access to our GitHub or PyPI credentials.
+      #
+      # Per the trusted publishing GitHub Action:
+      # > It is strongly advised to separate jobs for building [...]
+      # > from the publish job.
+      # https://github.com/pypa/gh-action-pypi-publish#non-goals
+      - name: Build project for distribution
+        run: poetry build
+        working-directory: ${{ inputs.working-directory }}
+
+      - name: Upload build
+        uses: actions/upload-artifact@v3
+        with:
+          name: dist
+          path: ${{ inputs.working-directory }}/dist/
+
+      - name: Check Version
+        id: check-version
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: |
+          echo pkg-name="$(poetry version | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+          echo version="$(poetry version --short)" >> $GITHUB_OUTPUT
+
+  test-pypi-publish:
+    needs:
+      - build
+    uses:
+      ./.github/workflows/_test_release.yml
+    with:
+      working-directory: ${{ inputs.working-directory }}
+    secrets: inherit
+
+  pre-release-checks:
+    needs:
+      - build
+      - test-pypi-publish
+    runs-on: ubuntu-latest
+    steps:
+      # We explicitly *don't* set up caching here. This ensures our tests are
+      # maximally sensitive to catching breakage.
+      #
+      # For example, here's a way that caching can cause a falsely-passing test:
+      # - Make the langchain package manifest no longer list a dependency package
+      #   as a requirement. This means it won't be installed by `pip install`,
+      #   and attempting to use it would cause a crash.
+      # - That dependency used to be required, so it may have been cached.
+      #   When restoring the venv packages from cache, that dependency gets included.
+      # - Tests pass, because the dependency is present even though it wasn't specified.
+      # - The package is published, and it breaks on the missing dependency when
+      #   used in the real world.
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Test published package
+        shell: bash
+        env:
+          PKG_NAME: ${{ needs.build.outputs.pkg-name }}
+          VERSION: ${{ needs.build.outputs.version }}
+        # Here we use:
+        # - The default regular PyPI index as the *primary* index, meaning 
+        #   that it takes priority (https://pypi.org/simple)
+        # - The test PyPI index as an extra index, so that any dependencies that
+        #   are not found on test PyPI can be resolved and installed anyway.
+        #   (https://test.pypi.org/simple). This will include the PKG_NAME==VERSION
+        #   package because VERSION will not have been uploaded to regular PyPI yet.
+        #
+        # TODO: add more in-depth pre-publish tests after testing that importing works
+        run: |
+          pip install \
+            --extra-index-url https://test.pypi.org/simple/ \
+            "$PKG_NAME==$VERSION"
+
+          # Replace all dashes in the package name with underscores,
+          # since that's how Python imports packages with dashes in the name.
+          IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
+
+          python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
+
+  publish:
+    needs:
+      - build
+      - test-pypi-publish
+      - pre-release-checks
+    runs-on: ubuntu-latest
     permissions:
       # This permission is used for trusted publishing:
       # https://blog.pypi.org/posts/2023-04-20-introducing-trusted-publishers/
@@ -24,28 +131,65 @@ jobs:
       # https://docs.pypi.org/trusted-publishers/adding-a-publisher/
       id-token: write
 
-      # This permission is needed by `ncipollo/release-action` to create the GitHub release.
-      contents: write
     defaults:
       run:
         working-directory: ${{ inputs.working-directory }}
+
     steps:
       - uses: actions/checkout@v4
 
       - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
         uses: "./.github/actions/poetry_setup"
         with:
-          python-version: "3.10"
+          python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
           working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
-      - name: Build project for distribution
-        run: poetry build
-      - name: Check Version
-        id: check-version
-        run: |
-          echo version=$(poetry version --short) >> $GITHUB_OUTPUT
+      - uses: actions/download-artifact@v3
+        with:
+          name: dist
+          path: ${{ inputs.working-directory }}/dist/
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: ${{ inputs.working-directory }}/dist/
+          verbose: true
+          print-hash: true
+
+  mark-release:
+    needs:
+      - build
+      - test-pypi-publish
+      - pre-release-checks
+      - publish
+    runs-on: ubuntu-latest
+    permissions:
+      # This permission is needed by `ncipollo/release-action` to
+      # create the GitHub release.
+      contents: write
+
+    defaults:
+      run:
+        working-directory: ${{ inputs.working-directory }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
+          cache-key: release
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: dist
+          path: ${{ inputs.working-directory }}/dist/
+
       - name: Create Release
         uses: ncipollo/release-action@v1
         if: ${{ inputs.working-directory == 'libs/langchain' }}
@@ -54,11 +198,5 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           draft: false
           generateReleaseNotes: true
-          tag: v${{ steps.check-version.outputs.version }}
+          tag: v${{ needs.build.outputs.version }}
           commit: master
-      - name: Publish package distributions to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          packages-dir: ${{ inputs.working-directory }}/dist/
-          verbose: true
-          print-hash: true

.github/workflows/_test.yml

@@ -7,6 +7,14 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
+      langchain-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain library folder"
+      langchain-core-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain core library folder"
 
 env:
   POETRY_VERSION: "1.6.1"
@@ -40,17 +48,26 @@ jobs:
         shell: bash
         run: poetry install
 
+      - name: Install langchain editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-location }}
+        env:
+          LANGCHAIN_LOCATION: ${{ inputs.langchain-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_LOCATION"
+
+      - name: Install langchain core editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-core-location }}
+        env:
+          LANGCHAIN_CORE_LOCATION: ${{ inputs.langchain-core-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_CORE_LOCATION"
+
       - name: Run core tests
         shell: bash
-        run: make test
-
-      - name: Install integration dependencies
-        shell: bash
-        run: poetry install --with=test_integration
-
-      - name: Check integration tests compile
-        shell: bash
-        run: poetry run pytest -m compile tests/integration_tests
+        run: |
+          make test
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/_test_release.yml

@@ -10,9 +10,60 @@ on:
 
 env:
   POETRY_VERSION: "1.6.1"
+  PYTHON_VERSION: "3.10"
 
 jobs:
-  publish_to_test_pypi:
+  build:
+    if: github.ref == 'refs/heads/master'
+    runs-on: ubuntu-latest
+
+    outputs:
+      pkg-name: ${{ steps.check-version.outputs.pkg-name }}
+      version: ${{ steps.check-version.outputs.version }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
+          cache-key: release
+
+      # We want to keep this build stage *separate* from the release stage,
+      # so that there's no sharing of permissions between them.
+      # The release stage has trusted publishing and GitHub repo contents write access,
+      # and we want to keep the scope of that access limited just to the release job.
+      # Otherwise, a malicious `build` step (e.g. via a compromised dependency)
+      # could get access to our GitHub or PyPI credentials.
+      #
+      # Per the trusted publishing GitHub Action:
+      # > It is strongly advised to separate jobs for building [...]
+      # > from the publish job.
+      # https://github.com/pypa/gh-action-pypi-publish#non-goals
+      - name: Build project for distribution
+        run: poetry build
+        working-directory: ${{ inputs.working-directory }}
+
+      - name: Upload build
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-dist
+          path: ${{ inputs.working-directory }}/dist/
+
+      - name: Check Version
+        id: check-version
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: |
+          echo pkg-name="$(poetry version | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+          echo version="$(poetry version --short)" >> $GITHUB_OUTPUT
+
+  publish:
+    needs:
+      - build
     runs-on: ubuntu-latest
     permissions:
       # This permission is used for trusted publishing:
@@ -21,30 +72,24 @@ jobs:
       # Trusted publishing has to also be configured on PyPI for each package:
       # https://docs.pypi.org/trusted-publishers/adding-a-publisher/
       id-token: write
-    defaults:
-      run:
-        working-directory: ${{ inputs.working-directory }}
+
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - uses: actions/download-artifact@v3
         with:
-          python-version: "3.10"
-          poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
-          cache-key: release
+          name: test-dist
+          path: ${{ inputs.working-directory }}/dist/
 
-      - name: Build project for distribution
-        run: poetry build
-      - name: Check Version
-        id: check-version
-        run: |
-          echo version=$(poetry version --short) >> $GITHUB_OUTPUT
-      - name: Publish package to TestPyPI
+      - name: Publish to test PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          repository-url: https://test.pypi.org/legacy/
           packages-dir: ${{ inputs.working-directory }}/dist/
           verbose: true
           print-hash: true
+          repository-url: https://test.pypi.org/legacy/
+
+          # We overwrite any existing distributions with the same name and version.
+          # This is *only for CI use* and is *extremely dangerous* otherwise!
+          # https://github.com/pypa/gh-action-pypi-publish#tolerating-release-package-file-duplicates
+          skip-existing: true

.github/workflows/doc_lint.yml

@@ -1,11 +1,17 @@
 ---
-name: Documentation Lint
+name: Docs, templates, cookbook lint
 
 on:
   push:
-    branches: [master]
+    branches: [ master ]
   pull_request:
-    branches: [master]
+    paths:
+      - 'docs/**'
+      - 'templates/**'
+      - 'cookbook/**'
+      - '.github/workflows/_lint.yml'
+      - '.github/workflows/doc_lint.yml'
+  workflow_dispatch:
 
 jobs:
   check:
@@ -13,10 +19,17 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     - name: Run import check
       run: |
         # We should not encourage imports directly from main init file
         # Expect for hub
-        git grep 'from langchain import' docs/{docs,snippets} | grep -vE 'from langchain import (hub)' && exit 1 || exit 0
+        git grep 'from langchain import' {docs/docs,templates,cookbook} | grep -vE 'from langchain import (hub)' && exit 1 || exit 0
+
+  lint:
+      uses:
+        ./.github/workflows/_lint.yml
+      with:
+        working-directory: "."
+      secrets: inherit

.github/workflows/extract_ignored_words_list.py

@@ -3,6 +3,8 @@ import toml
 pyproject_toml = toml.load("pyproject.toml")
 
 # Extract the ignore words list (adjust the key as per your TOML structure)
-ignore_words_list = pyproject_toml.get("tool", {}).get("codespell", {}).get("ignore-words-list")
+ignore_words_list = (
+    pyproject_toml.get("tool", {}).get("codespell", {}).get("ignore-words-list")
+)
 
-print(f"::set-output name=ignore_words_list::{ignore_words_list}")
+print(f"::set-output name=ignore_words_list::{ignore_words_list}")

.github/workflows/langchain_ci.yml

@@ -12,7 +12,9 @@ on:
       - '.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,
@@ -35,6 +37,7 @@ jobs:
       ./.github/workflows/_lint.yml
     with:
       working-directory: libs/langchain
+      langchain-core-location: ../core
     secrets: inherit
 
   test:
@@ -42,6 +45,7 @@ jobs:
       ./.github/workflows/_test.yml
     with:
       working-directory: libs/langchain
+      langchain-core-location: ../core
     secrets: inherit
 
   compile-integration-tests:
@@ -49,6 +53,7 @@ jobs:
       ./.github/workflows/_compile_integration_test.yml
     with:
       working-directory: libs/langchain
+      langchain-core-location: ../core
     secrets: inherit
 
   pydantic-compatibility:
@@ -56,8 +61,49 @@ jobs:
       ./.github/workflows/_pydantic_compatibility.yml
     with:
       working-directory: libs/langchain
+      langchain-core-location: ../core
     secrets: inherit
 
+  # It's possible that langchain works fine with the latest *published* langchain-core,
+  # but is broken with the langchain-core on `master`.
+  #
+  # We want to catch situations like that *before* releasing a new langchain-core, hence this test.
+  test-with-latest-langchain-core:
+    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-core - 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-core
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          echo "Running tests with unpublished langchain, installing dependencies with poetry..."
+          poetry install
+
+          echo "Editably installing langchain-core outside of poetry, to avoid messing up lockfile..."
+          poetry run pip install -e ../core
+
+      - name: Run tests
+        run: make test
+
   extended-tests:
     runs-on: ubuntu-latest
     defaults:
@@ -88,6 +134,11 @@ jobs:
           echo "Running extended tests, installing dependencies with poetry..."
           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_cli_release.yml

@@ -0,0 +1,13 @@
+---
+name: libs/cli Release
+
+on:
+  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
+
+jobs:
+  release:
+    uses:
+      ./.github/workflows/_release.yml
+    with:
+      working-directory: libs/cli
+    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_core_release.yml

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

.github/workflows/langchain_experimental_ci.yml

@@ -11,8 +11,10 @@ on:
       - '.github/workflows/_lint.yml'
       - '.github/workflows/_test.yml'
       - '.github/workflows/langchain_experimental_ci.yml'
-      - 'libs/langchain/**'
+      - '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,
@@ -35,6 +37,8 @@ jobs:
       ./.github/workflows/_lint.yml
     with:
       working-directory: libs/experimental
+      langchain-location: ../langchain
+      langchain-core-location: ../core
     secrets: inherit
 
   test:
@@ -42,6 +46,8 @@ jobs:
       ./.github/workflows/_test.yml
     with:
       working-directory: libs/experimental
+      langchain-location: ../langchain
+      langchain-core-location: ../core
     secrets: inherit
 
   compile-integration-tests:
@@ -87,6 +93,7 @@ jobs:
 
           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

.github/workflows/scheduled_test.yml

@@ -55,6 +55,10 @@ jobs:
           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
@@ -64,7 +68,8 @@ jobs:
           AZURE_OPENAI_API_VERSION: ${{ secrets.AZURE_OPENAI_API_VERSION }}
           AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}
           AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}
-          AZURE_OPENAI_DEPLOYMENT_NAME:  ${{ secrets.AZURE_OPENAI_DEPLOYMENT_NAME }}
+          AZURE_OPENAI_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_DEPLOYMENT_NAME }}
+          FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
         run: |
           make scheduled_tests
 

.github/workflows/templates_ci.yml

@@ -0,0 +1,37 @@
+---
+name: templates CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    paths:
+      - '.github/actions/poetry_setup/action.yml'
+      - '.github/tools/**'
+      - '.github/workflows/_lint.yml'
+      - '.github/workflows/templates_ci.yml'
+      - 'templates/**'
+  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: "templates"
+
+jobs:
+  lint:
+    uses:
+      ./.github/workflows/_lint.yml
+    with:
+      working-directory: templates
+      langchain-location: ../libs/langchain
+    secrets: inherit

.gitignore

@@ -178,3 +178,4 @@ docs/docs/build
 docs/docs/node_modules
 docs/docs/yarn.lock
 _dist
+docs/docs/templates

MIGRATE.md

@@ -1,9 +1,18 @@
-# Migrating to `langchain_experimental`
+# Migrating
+
+## 🚨Breaking Changes for select chains (SQLDatabase) on 7/28/23
+
+In an effort to make `langchain` leaner and safer, we are moving select chains to `langchain_experimental`.
+This migration has already started, but we are remaining backwards compatible until 7/28.
+On that date, we will remove functionality from `langchain`.
+Read more about the motivation and the progress [here](https://github.com/langchain-ai/langchain/discussions/8043).
+
+### Migrating to `langchain_experimental`
 
 We are moving any experimental components of LangChain, or components with vulnerability issues, into `langchain_experimental`.
 This guide covers how to migrate.
 
-## Installation
+### Installation
 
 Previously:
 
@@ -13,7 +22,7 @@ Now (only if you want to access things in experimental):
 
 `pip install -U langchain langchain_experimental`
 
-## Things in `langchain.experimental`
+### Things in `langchain.experimental`
 
 Previously:
 
@@ -23,7 +32,7 @@ Now:
 
 `from langchain_experimental import ...`
 
-## PALChain
+### PALChain
 
 Previously:
 
@@ -33,7 +42,7 @@ Now:
 
 `from langchain_experimental.pal_chain import PALChain`
 
-## SQLDatabaseChain
+### SQLDatabaseChain
 
 Previously:
 
@@ -47,7 +56,7 @@ Alternatively, if you are just interested in using the query generation part of
 
 `from langchain.chains import create_sql_query_chain`
 
-## `load_prompt` for Python files
+### `load_prompt` for Python files
 
 Note: this only applies if you want to load Python files as prompts.
 If you want to load json/yaml files, no change is needed.

Makefile

@@ -37,6 +37,18 @@ spell_check:
 spell_fix:
 	poetry run codespell --toml pyproject.toml -w
 
+######################
+# LINTING AND FORMATTING
+######################
+
+lint:
+	poetry run ruff docs templates cookbook
+	poetry run ruff format docs templates cookbook --diff
+
+format format_diff:
+	poetry run ruff format docs templates cookbook
+	poetry run ruff --select I --fix docs templates cookbook
+
 ######################
 # HELP
 ######################

README.md

@@ -15,71 +15,72 @@
 [![Dependency Status](https://img.shields.io/librariesio/github/langchain-ai/langchain)](https://libraries.io/github/langchain-ai/langchain)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/issues)
 
-
-Looking for the JS/TS version? Check out [LangChain.js](https://github.com/langchain-ai/langchainjs).
+Looking for the JS/TS library? Check out [LangChain.js](https://github.com/langchain-ai/langchainjs).
 
 To help you ship LangChain apps to production faster, check out [LangSmith](https://smith.langchain.com). 
 [LangSmith](https://smith.langchain.com) is a unified developer platform for building, testing, and monitoring LLM applications. 
-Fill out [this form](https://airtable.com/appwQzlErAS2qiP0L/shrGtGaVBVAz7NcV2) to get off the waitlist or speak with our sales team
-
-## 🚨Breaking Changes for select chains (SQLDatabase) on 7/28/23
-
-In an effort to make `langchain` leaner and safer, we are moving select chains to `langchain_experimental`.
-This migration has already started, but we are remaining backwards compatible until 7/28.
-On that date, we will remove functionality from `langchain`.
-Read more about the motivation and the progress [here](https://github.com/langchain-ai/langchain/discussions/8043).
-Read how to migrate your code [here](MIGRATE.md).
+Fill out [this form](https://airtable.com/appwQzlErAS2qiP0L/shrGtGaVBVAz7NcV2) to get off the waitlist or speak with our sales team.
 
 ## Quick Install
 
-`pip install langchain`
-or
-`pip install langsmith && conda install langchain -c conda-forge`
+With pip:
+```bash
+pip install langchain
+```
 
-## 🤔 What is this?
+With conda:
+```bash
+pip install langsmith && conda install langchain -c conda-forge
+```
 
-Large language models (LLMs) are emerging as a transformative technology, enabling developers to build applications that they previously could not. However, using these LLMs in isolation is often insufficient for creating a truly powerful app - the real power comes when you can combine them with other sources of computation or knowledge.
+## 🤔 What is LangChain?
 
-This library aims to assist in the development of those types of applications. Common examples of these applications include:
+**LangChain** is a framework for developing applications powered by language models. It enables applications that:
+- **Are context-aware**: connect a language model to sources of context (prompt instructions, few shot examples, content to ground its response in, etc.)
+- **Reason**: rely on a language model to reason (about how to answer based on provided context, what actions to take, etc.)
 
-**❓ Question Answering over specific documents**
+This framework consists of several parts.
+- **LangChain Libraries**: The Python and JavaScript libraries. Contains interfaces and integrations for a myriad of components, a basic run time for combining these components into chains and agents, and off-the-shelf implementations of chains and agents.
+- **[LangChain Templates](templates)**: A collection of easily deployable reference architectures for a wide variety of tasks.
+- **[LangServe](https://github.com/langchain-ai/langserve)**: A library for deploying LangChain chains as a REST API.
+- **[LangSmith](https://smith.langchain.com)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
+
+**This repo contains the `langchain` ([here](libs/langchain)), `langchain-experimental` ([here](libs/experimental)), and `langchain-cli` ([here](libs/cli)) Python packages, as well as [LangChain Templates](templates).**
+
+![LangChain Stack](docs/static/img/langchain_stack.png)
+
+## 🧱 What can you build with LangChain?
+**❓ Retrieval augmented generation**
 
 - [Documentation](https://python.langchain.com/docs/use_cases/question_answering/)
-- End-to-end Example: [Question Answering over Notion Database](https://github.com/hwchase17/notion-qa)
+- End-to-end Example: [Chat LangChain](https://chat.langchain.com) and [repo](https://github.com/langchain-ai/chat-langchain)
 
-**💬 Chatbots**
+**💬 Analyzing structured data**
 
-- [Documentation](https://python.langchain.com/docs/use_cases/chatbots/)
-- End-to-end Example: [Chat-LangChain](https://github.com/langchain-ai/chat-langchain)
+- [Documentation](https://python.langchain.com/docs/use_cases/qa_structured/sql)
+- End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain/tree/master/templates/sql-llama2)
 
-**🤖 Agents**
+**🤖 Chatbots**
 
-- [Documentation](https://python.langchain.com/docs/modules/agents/)
-- End-to-end Example: [GPT+WolframAlpha](https://huggingface.co/spaces/JavaFXpert/Chat-GPT-LangChain)
+- [Documentation](https://python.langchain.com/docs/use_cases/chatbots)
+- End-to-end Example: [Web LangChain (web researcher chatbot)](https://weblangchain.vercel.app) and [repo](https://github.com/langchain-ai/weblangchain)
 
-## 📖 Documentation
+And much more! Head to the [Use cases](https://python.langchain.com/docs/use_cases/) section of the docs for more.
 
-Please see [here](https://python.langchain.com) for full documentation on:
+## 🚀 How does LangChain help?
+The main value props of the LangChain libraries are:
+1. **Components**: composable tools and integrations for working with language models. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
+2. **Off-the-shelf chains**: built-in assemblages of components for accomplishing higher-level tasks
 
-- Getting started (installation, setting up the environment, simple examples)
-- How-To examples (demos, integrations, helper functions)
-- Reference (full API docs)
-- Resources (high-level explanation of core concepts)
+Off-the-shelf chains make it easy to get started. Components make it easy to customize existing chains and build new ones. 
 
-## 🚀 What can this help with?
+Components fall into the following **modules**:
 
-There are six main areas that LangChain is designed to help with.
-These are, in increasing order of complexity:
-
-**📃 LLMs and Prompts:**
+**📃 Model I/O:**
 
 This includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with LLMs.
 
-**🔗 Chains:**
-
-Chains go beyond a single LLM call and involve sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.
-
-**📚 Data Augmented Generation:**
+**📚 Retrieval:**
 
 Data Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.
 
@@ -87,15 +88,16 @@ Data Augmented Generation involves specific types of chains that first interact
 
 Agents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end-to-end agents.
 
-**🧠 Memory:**
+## 📖 Documentation
 
-Memory refers to persisting state between calls of a chain/agent. LangChain provides a standard interface for memory, a collection of memory implementations, and examples of chains/agents that use memory.
+Please see [here](https://python.langchain.com) for full documentation, which includes:
 
-**🧐 Evaluation:**
+- [Getting started](https://python.langchain.com/docs/get_started/introduction): installation, setting up the environment, simple examples
+- Overview of the [interfaces](https://python.langchain.com/docs/expression_language/), [modules](https://python.langchain.com/docs/modules/) and [integrations](https://python.langchain.com/docs/integrations/providers)
+- [Use case](https://python.langchain.com/docs/use_cases/qa_structured/sql) walkthroughs and best practice [guides](https://python.langchain.com/docs/guides/adapters/openai)
+- [LangSmith](https://python.langchain.com/docs/langsmith/), [LangServe](https://python.langchain.com/docs/langserve), and [LangChain Template](https://python.langchain.com/docs/templates/) overviews
+- [Reference](https://api.python.langchain.com): full API docs
 
-[BETA] Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is by using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.
-
-For more information on these concepts, please see our [full documentation](https://python.langchain.com).
 
 ## 💁 Contributing
 

cookbook/LLaMA2_sql_chat.ipynb

@@ -47,7 +47,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 1,
    "id": "6a75a5c6-34ee-4ab9-a664-d9b432d812ee",
    "metadata": {},
    "outputs": [
@@ -60,28 +60,26 @@
     }
    ],
    "source": [
-    "# Local \n",
+    "# Local\n",
     "from langchain.chat_models import ChatOllama\n",
+    "\n",
     "llama2_chat = ChatOllama(model=\"llama2:13b-chat\")\n",
     "llama2_code = ChatOllama(model=\"codellama:7b-instruct\")\n",
     "\n",
     "# API\n",
-    "from getpass import getpass\n",
     "from langchain.llms import Replicate\n",
+    "\n",
     "# REPLICATE_API_TOKEN = getpass()\n",
     "# os.environ[\"REPLICATE_API_TOKEN\"] = REPLICATE_API_TOKEN\n",
     "replicate_id = \"meta/llama-2-13b-chat:f4e2de70d66816a838a89eeeb621910adffb0dd0baba3976c96980970978018d\"\n",
     "llama2_chat_replicate = Replicate(\n",
-    "    model=replicate_id,\n",
-    "    input={\"temperature\": 0.01, \n",
-    "           \"max_length\": 500, \n",
-    "           \"top_p\": 1}\n",
+    "    model=replicate_id, input={\"temperature\": 0.01, \"max_length\": 500, \"top_p\": 1}\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 2,
    "id": "ce96f7ea-b3d5-44e1-9fa5-a79e04a9e1fb",
    "metadata": {},
    "outputs": [],
@@ -104,17 +102,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 3,
    "id": "025bdd82-3bb1-4948-bc7c-c3ccd94fd05c",
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain.utilities import SQLDatabase\n",
-    "db = SQLDatabase.from_uri(\"sqlite:///nba_roster.db\", sample_rows_in_table_info= 0)\n",
+    "\n",
+    "db = SQLDatabase.from_uri(\"sqlite:///nba_roster.db\", sample_rows_in_table_info=0)\n",
+    "\n",
     "\n",
     "def get_schema(_):\n",
     "    return db.get_table_info()\n",
     "\n",
+    "\n",
     "def run_query(query):\n",
     "    return db.run(query)"
    ]
@@ -131,7 +132,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 4,
    "id": "5a4933ea-d9c0-4b0a-8177-ba4490c6532b",
    "metadata": {},
    "outputs": [
@@ -141,7 +142,7 @@
        "' SELECT \"Team\" FROM nba_roster WHERE \"NAME\" = \\'Klay Thompson\\';'"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -149,26 +150,29 @@
    "source": [
     "# Prompt\n",
     "from langchain.prompts import ChatPromptTemplate\n",
+    "\n",
     "template = \"\"\"Based on the table schema below, write a SQL query that would answer the user's question:\n",
     "{schema}\n",
     "\n",
     "Question: {question}\n",
     "SQL Query:\"\"\"\n",
-    "prompt = ChatPromptTemplate.from_messages([\n",
-    "    (\"system\", \"Given an input question, convert it to a SQL query. No pre-amble.\"),\n",
-    "    (\"human\", template)\n",
-    "])\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"Given an input question, convert it to a SQL query. No pre-amble.\"),\n",
+    "        (\"human\", template),\n",
+    "    ]\n",
+    ")\n",
     "\n",
     "# Chain to query\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",
-    "        | prompt\n",
-    "        | llm.bind(stop=[\"\\nSQLResult:\"])\n",
-    "        | StrOutputParser()\n",
-    "    )\n",
+    "    RunnablePassthrough.assign(schema=get_schema)\n",
+    "    | prompt\n",
+    "    | llm.bind(stop=[\"\\nSQLResult:\"])\n",
+    "    | StrOutputParser()\n",
+    ")\n",
     "\n",
     "sql_response.invoke({\"question\": \"What team is Klay Thompson on?\"})"
    ]
@@ -209,18 +213,23 @@
     "Question: {question}\n",
     "SQL Query: {query}\n",
     "SQL Response: {response}\"\"\"\n",
-    "prompt_response = ChatPromptTemplate.from_messages([\n",
-    "    (\"system\", \"Given an input question and SQL response, convert it to a natural langugae answer. No pre-amble.\"),\n",
-    "    (\"human\", template)\n",
-    "])\n",
+    "prompt_response = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\n",
+    "            \"system\",\n",
+    "            \"Given an input question and SQL response, convert it to a natural langugae answer. No pre-amble.\",\n",
+    "        ),\n",
+    "        (\"human\", template),\n",
+    "    ]\n",
+    ")\n",
     "\n",
     "full_chain = (\n",
-    "    RunnablePassthrough.assign(query=sql_response) \n",
+    "    RunnablePassthrough.assign(query=sql_response)\n",
     "    | RunnablePassthrough.assign(\n",
     "        schema=get_schema,\n",
     "        response=lambda x: db.run(x[\"query\"]),\n",
     "    )\n",
-    "    | prompt_response \n",
+    "    | prompt_response\n",
     "    | llm\n",
     ")\n",
     "\n",
@@ -250,8 +259,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "id": "1985aa1c-eb8f-4fb1-a54f-c8aa10744687",
+   "execution_count": 7,
+   "id": "022868f2-128e-42f5-8d90-d3bb2f11d994",
    "metadata": {},
    "outputs": [
     {
@@ -260,7 +269,7 @@
        "' SELECT \"Team\" FROM nba_roster WHERE \"NAME\" = \\'Klay Thompson\\';'"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -269,61 +278,44 @@
     "# Prompt\n",
     "from langchain.memory import ConversationBufferMemory\n",
     "from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
-    "template = \"\"\"Based on the table schema below, write a SQL query that would answer the user's question:\n",
-    "{schema}\n",
     "\n",
-    "Question: {question}\n",
-    "SQL Query:\"\"\"\n",
-    "prompt = ChatPromptTemplate.from_messages([\n",
-    "    (\"system\", \"Given an input question, convert it to a SQL query. No pre-amble.\"),\n",
-    "    MessagesPlaceholder(variable_name=\"history\"),\n",
-    "    (\"human\", template)\n",
-    "])\n",
+    "template = \"\"\"Given an input question, convert it to a SQL query. No pre-amble. Based on the table schema below, write a SQL query that would answer the user's question:\n",
+    "{schema}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", template),\n",
+    "        MessagesPlaceholder(variable_name=\"history\"),\n",
+    "        (\"human\", \"{question}\"),\n",
+    "    ]\n",
+    ")\n",
     "\n",
     "memory = ConversationBufferMemory(return_messages=True)\n",
     "\n",
-    "# Chain to query with memory \n",
+    "# Chain to query with memory\n",
     "from langchain.schema.runnable import RunnableLambda\n",
     "\n",
     "sql_chain = (\n",
     "    RunnablePassthrough.assign(\n",
-    "       schema=get_schema,\n",
-    "       history=RunnableLambda(lambda x: memory.load_memory_variables(x)[\"history\"])\n",
-    "    )| prompt\n",
+    "        schema=get_schema,\n",
+    "        history=RunnableLambda(lambda x: memory.load_memory_variables(x)[\"history\"]),\n",
+    "    )\n",
+    "    | prompt\n",
     "    | llm.bind(stop=[\"\\nSQLResult:\"])\n",
     "    | StrOutputParser()\n",
     ")\n",
     "\n",
+    "\n",
     "def save(input_output):\n",
     "    output = {\"output\": input_output.pop(\"output\")}\n",
     "    memory.save_context(input_output, output)\n",
-    "    return output['output']\n",
-    "    \n",
+    "    return output[\"output\"]\n",
+    "\n",
+    "\n",
     "sql_response_memory = RunnablePassthrough.assign(output=sql_chain) | save\n",
     "sql_response_memory.invoke({\"question\": \"What team is Klay Thompson on?\"})"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "0b45818a-1498-441d-b82d-23c29428c2bb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "' SELECT \"SALARY\" FROM nba_roster WHERE \"NAME\" = \\'Klay Thompson\\';'"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sql_response_memory.invoke({\"question\": \"What is his salary?\"})"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 21,
@@ -349,18 +341,23 @@
     "Question: {question}\n",
     "SQL Query: {query}\n",
     "SQL Response: {response}\"\"\"\n",
-    "prompt_response = ChatPromptTemplate.from_messages([\n",
-    "    (\"system\", \"Given an input question and SQL response, convert it to a natural langugae answer. No pre-amble.\"),\n",
-    "    (\"human\", template)\n",
-    "])\n",
+    "prompt_response = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\n",
+    "            \"system\",\n",
+    "            \"Given an input question and SQL response, convert it to a natural langugae answer. No pre-amble.\",\n",
+    "        ),\n",
+    "        (\"human\", template),\n",
+    "    ]\n",
+    ")\n",
     "\n",
     "full_chain = (\n",
-    "    RunnablePassthrough.assign(query=sql_response_memory) \n",
+    "    RunnablePassthrough.assign(query=sql_response_memory)\n",
     "    | RunnablePassthrough.assign(\n",
     "        schema=get_schema,\n",
     "        response=lambda x: db.run(x[\"query\"]),\n",
     "    )\n",
-    "    | prompt_response \n",
+    "    | prompt_response\n",
     "    | llm\n",
     ")\n",
     "\n",

cookbook/README.md

@@ -8,6 +8,7 @@ Notebook | Description
 [Semi_Structured_RAG.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/Semi_Structured_RAG.ipynb) | Perform retrieval-augmented generation (rag) on documents with semi-structured data, including text and tables, using unstructured for parsing, multi-vector retriever for storing, and lcel for implementing chains.
 [Semi_structured_and_multi_moda...](https://github.com/langchain-ai/langchain/tree/master/cookbook/Semi_structured_and_multi_modal_RAG.ipynb) | Perform retrieval-augmented generation (rag) on documents with semi-structured data and images, using unstructured for parsing, multi-vector retriever for storage and retrieval, and lcel for implementing chains.
 [Semi_structured_multi_modal_RA...](https://github.com/langchain-ai/langchain/tree/master/cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb) | Perform retrieval-augmented generation (rag) on documents with semi-structured data and images, using various tools and methods such as unstructured for parsing, multi-vector retriever for storing, lcel for implementing chains, and open source language models like llama2, llava, and gpt4all.
+[analyze_document.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/analyze_document.ipynb) | Analyze a single long document.
 [autogpt/autogpt.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/autogpt/autogpt.ipynb) | Implement autogpt, a language model, with langchain primitives such as llms, prompttemplates, vectorstores, embeddings, and tools.
 [autogpt/marathon_times.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/autogpt/marathon_times.ipynb) | Implement autogpt for finding winning marathon times.
 [baby_agi.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/baby_agi.ipynb) | Implement babyagi, an ai agent that can generate and execute tasks based on a given objective, with the flexibility to swap out specific vectorstores/model providers.
@@ -20,6 +21,7 @@ Notebook | Description
 [databricks_sql_db.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/databricks_sql_db.ipynb) | Connect to databricks runtimes and databricks sql.
 [deeplake_semantic_search_over_...](https://github.com/langchain-ai/langchain/tree/master/cookbook/deeplake_semantic_search_over_chat.ipynb) | Perform semantic search and question-answering over a group chat using activeloop's deep lake with gpt4.
 [elasticsearch_db_qa.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/elasticsearch_db_qa.ipynb) | Interact with elasticsearch analytics databases in natural language and build search queries via the elasticsearch dsl API.
+[extraction_openai_tools.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/extraction_openai_tools.ipynb) | Structured Data Extraction with OpenAI Tools
 [forward_looking_retrieval_augm...](https://github.com/langchain-ai/langchain/tree/master/cookbook/forward_looking_retrieval_augmented_generation.ipynb) | Implement the forward-looking active retrieval augmented generation (flare) method, which generates answers to questions, identifies uncertain tokens, generates hypothetical questions based on these tokens, and retrieves relevant documents to continue generating the answer.
 [generative_agents_interactive_...](https://github.com/langchain-ai/langchain/tree/master/cookbook/generative_agents_interactive_simulacra_of_human_behavior.ipynb) | Implement a generative agent that simulates human behavior, based on a research paper, using a time-weighted memory object backed by a langchain retriever.
 [gymnasium_agent_simulation.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/gymnasium_agent_simulation.ipynb) | Create a simple agent-environment interaction loop in simulated environments like text-based games with gymnasium.
@@ -38,10 +40,13 @@ Notebook | Description
 [multiagent_bidding.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/multiagent_bidding.ipynb) | Implement a multi-agent simulation where agents bid to speak, with the highest bidder speaking next, demonstrated through a fictitious presidential debate example.
 [myscale_vector_sql.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/myscale_vector_sql.ipynb) | Access and interact with the myscale integrated vector database, which can enhance the performance of language model (llm) applications.
 [openai_functions_retrieval_qa....](https://github.com/langchain-ai/langchain/tree/master/cookbook/openai_functions_retrieval_qa.ipynb) | Structure response output in a question-answering system by incorporating openai functions into a retrieval pipeline.
+[openai_v1_cookbook.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/openai_v1_cookbook.ipynb) | Explore new functionality released alongside the V1 release of the OpenAI Python library.
 [petting_zoo.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/petting_zoo.ipynb) | Create multi-agent simulations with simulated environments using the petting zoo library.
 [plan_and_execute_agent.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/plan_and_execute_agent.ipynb) | Create plan-and-execute agents that accomplish objectives by planning tasks with a language model (llm) and executing them with a separate agent.
 [press_releases.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/press_releases.ipynb) | Retrieve and query company press release data powered by [Kay.ai](https://kay.ai).
 [program_aided_language_model.i...](https://github.com/langchain-ai/langchain/tree/master/cookbook/program_aided_language_model.ipynb) | Implement program-aided language models as described in the provided research paper.
+[qa_citations.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/qa_citations.ipynb) | Different ways to get a model to cite its sources.
+[retrieval_in_sql.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/retrieval_in_sql.ipynb) | Perform retrieval-augmented-generation (rag) on a PostgreSQL database using pgvector.
 [sales_agent_with_context.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/sales_agent_with_context.ipynb) | Implement a context-aware ai sales agent, salesgpt, that can have natural sales conversations, interact with other systems, and use a product knowledge base to discuss a company's offerings.
 [self_query_hotel_search.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/self_query_hotel_search.ipynb) | Build a hotel room search feature with self-querying retrieval, using a specific hotel recommendation dataset.
 [smart_llm.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/smart_llm.ipynb) | Implement a smartllmchain, a self-critique chain that generates multiple output proposals, critiques them to find the best one, and then improves upon it to produce a final output.

cookbook/Semi_Structured_RAG.ipynb

@@ -60,7 +60,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "! brew install tesseract \n",
+    "! brew install tesseract\n",
     "! brew install poppler"
    ]
   },
@@ -102,27 +102,29 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from lxml import html\n",
+    "from typing import Any\n",
+    "\n",
     "from pydantic import BaseModel\n",
-    "from typing import Any, Optional\n",
     "from unstructured.partition.pdf import partition_pdf\n",
     "\n",
     "# Get elements\n",
-    "raw_pdf_elements = partition_pdf(filename=path+\"LLaMA2.pdf\",\n",
-    "                                 # Unstructured first finds embedded image blocks\n",
-    "                                 extract_images_in_pdf=False,\n",
-    "                                 # Use layout model (YOLOX) to get bounding boxes (for tables) and find titles\n",
-    "                                 # Titles are any sub-section of the document \n",
-    "                                 infer_table_structure=True, \n",
-    "                                 # Post processing to aggregate text once we have the title \n",
-    "                                 chunking_strategy=\"by_title\",\n",
-    "                                 # Chunking params to aggregate text blocks\n",
-    "                                 # Attempt to create a new chunk 3800 chars\n",
-    "                                 # Attempt to keep chunks > 2000 chars \n",
-    "                                 max_characters=4000, \n",
-    "                                 new_after_n_chars=3800, \n",
-    "                                 combine_text_under_n_chars=2000,\n",
-    "                                 image_output_dir_path=path)"
+    "raw_pdf_elements = partition_pdf(\n",
+    "    filename=path + \"LLaMA2.pdf\",\n",
+    "    # Unstructured first finds embedded image blocks\n",
+    "    extract_images_in_pdf=False,\n",
+    "    # Use layout model (YOLOX) to get bounding boxes (for tables) and find titles\n",
+    "    # Titles are any sub-section of the document\n",
+    "    infer_table_structure=True,\n",
+    "    # Post processing to aggregate text once we have the title\n",
+    "    chunking_strategy=\"by_title\",\n",
+    "    # Chunking params to aggregate text blocks\n",
+    "    # Attempt to create a new chunk 3800 chars\n",
+    "    # Attempt to keep chunks > 2000 chars\n",
+    "    max_characters=4000,\n",
+    "    new_after_n_chars=3800,\n",
+    "    combine_text_under_n_chars=2000,\n",
+    "    image_output_dir_path=path,\n",
+    ")"
    ]
   },
   {
@@ -190,6 +192,7 @@
     "    type: str\n",
     "    text: Any\n",
     "\n",
+    "\n",
     "# Categorize by type\n",
     "categorized_elements = []\n",
     "for element in raw_pdf_elements:\n",
@@ -259,14 +262,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Prompt \n",
-    "prompt_text=\"\"\"You are an assistant tasked with summarizing tables and text. \\ \n",
+    "# Prompt\n",
+    "prompt_text = \"\"\"You are an assistant tasked with summarizing tables and text. \\ \n",
     "Give a concise summary of the table or text. Table or text chunk: {element} \"\"\"\n",
-    "prompt = ChatPromptTemplate.from_template(prompt_text) \n",
+    "prompt = ChatPromptTemplate.from_template(prompt_text)\n",
     "\n",
-    "# Summary chain \n",
-    "model = ChatOpenAI(temperature=0,model=\"gpt-4\")\n",
-    "summarize_chain = {\"element\": lambda x:x} | prompt | model | StrOutputParser()"
+    "# Summary chain\n",
+    "model = ChatOpenAI(temperature=0, model=\"gpt-4\")\n",
+    "summarize_chain = {\"element\": lambda x: x} | prompt | model | StrOutputParser()"
    ]
   },
   {
@@ -314,17 +317,15 @@
    "outputs": [],
    "source": [
     "import uuid\n",
-    "from langchain.vectorstores import Chroma\n",
-    "from langchain.storage import InMemoryStore\n",
-    "from langchain.schema.document import Document\n",
+    "\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",
     "\n",
     "# The vectorstore to use to index the child chunks\n",
-    "vectorstore = Chroma(\n",
-    "    collection_name=\"summaries\",\n",
-    "    embedding_function=OpenAIEmbeddings()\n",
-    ")\n",
+    "vectorstore = Chroma(collection_name=\"summaries\", embedding_function=OpenAIEmbeddings())\n",
     "\n",
     "# The storage layer for the parent documents\n",
     "store = InMemoryStore()\n",
@@ -332,20 +333,26 @@
     "\n",
     "# The retriever (empty to start)\n",
     "retriever = MultiVectorRetriever(\n",
-    "    vectorstore=vectorstore, \n",
-    "    docstore=store, \n",
+    "    vectorstore=vectorstore,\n",
+    "    docstore=store,\n",
     "    id_key=id_key,\n",
     ")\n",
     "\n",
     "# Add texts\n",
     "doc_ids = [str(uuid.uuid4()) for _ in texts]\n",
-    "summary_texts = [Document(page_content=s,metadata={id_key: doc_ids[i]}) for i, s in enumerate(text_summaries)]\n",
+    "summary_texts = [\n",
+    "    Document(page_content=s, metadata={id_key: doc_ids[i]})\n",
+    "    for i, s in enumerate(text_summaries)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_texts)\n",
     "retriever.docstore.mset(list(zip(doc_ids, texts)))\n",
     "\n",
     "# Add tables\n",
     "table_ids = [str(uuid.uuid4()) for _ in tables]\n",
-    "summary_tables = [Document(page_content=s,metadata={id_key: table_ids[i]}) for i, s in enumerate(table_summaries)]\n",
+    "summary_tables = [\n",
+    "    Document(page_content=s, metadata={id_key: table_ids[i]})\n",
+    "    for i, s in enumerate(table_summaries)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_tables)\n",
     "retriever.docstore.mset(list(zip(table_ids, tables)))"
    ]
@@ -367,7 +374,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from operator import itemgetter\n",
     "from langchain.schema.runnable import RunnablePassthrough\n",
     "\n",
     "# Prompt template\n",
@@ -378,13 +384,13 @@
     "prompt = ChatPromptTemplate.from_template(template)\n",
     "\n",
     "# LLM\n",
-    "model = ChatOpenAI(temperature=0,model=\"gpt-4\")\n",
+    "model = ChatOpenAI(temperature=0, model=\"gpt-4\")\n",
     "\n",
     "# RAG pipeline\n",
     "chain = (\n",
-    "    {\"context\": retriever, \"question\": RunnablePassthrough()} \n",
-    "    | prompt \n",
-    "    | model \n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    "    | prompt\n",
+    "    | model\n",
     "    | StrOutputParser()\n",
     ")"
    ]

cookbook/Semi_structured_and_multi_modal_RAG.ipynb

@@ -92,28 +92,30 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from lxml import html\n",
+    "from typing import Any\n",
+    "\n",
     "from pydantic import BaseModel\n",
-    "from typing import Any, Optional\n",
     "from unstructured.partition.pdf import partition_pdf\n",
     "\n",
     "# Get elements\n",
-    "raw_pdf_elements = partition_pdf(filename=path+\"LLaVA.pdf\",\n",
-    "                                 # Using pdf format to find embedded image blocks\n",
-    "                                 extract_images_in_pdf=True,\n",
-    "                                 # Use layout model (YOLOX) to get bounding boxes (for tables) and find titles\n",
-    "                                 # Titles are any sub-section of the document \n",
-    "                                 infer_table_structure=True, \n",
-    "                                 # Post processing to aggregate text once we have the title \n",
-    "                                 chunking_strategy=\"by_title\",\n",
-    "                                 # Chunking params to aggregate text blocks\n",
-    "                                 # Attempt to create a new chunk 3800 chars\n",
-    "                                 # Attempt to keep chunks > 2000 chars \n",
-    "                                 # Hard max on chunks\n",
-    "                                 max_characters=4000, \n",
-    "                                 new_after_n_chars=3800, \n",
-    "                                 combine_text_under_n_chars=2000,\n",
-    "                                 image_output_dir_path=path)"
+    "raw_pdf_elements = partition_pdf(\n",
+    "    filename=path + \"LLaVA.pdf\",\n",
+    "    # Using pdf format to find embedded image blocks\n",
+    "    extract_images_in_pdf=True,\n",
+    "    # Use layout model (YOLOX) to get bounding boxes (for tables) and find titles\n",
+    "    # Titles are any sub-section of the document\n",
+    "    infer_table_structure=True,\n",
+    "    # Post processing to aggregate text once we have the title\n",
+    "    chunking_strategy=\"by_title\",\n",
+    "    # Chunking params to aggregate text blocks\n",
+    "    # Attempt to create a new chunk 3800 chars\n",
+    "    # Attempt to keep chunks > 2000 chars\n",
+    "    # Hard max on chunks\n",
+    "    max_characters=4000,\n",
+    "    new_after_n_chars=3800,\n",
+    "    combine_text_under_n_chars=2000,\n",
+    "    image_output_dir_path=path,\n",
+    ")"
    ]
   },
   {
@@ -170,6 +172,7 @@
     "    type: str\n",
     "    text: Any\n",
     "\n",
+    "\n",
     "# Categorize by type\n",
     "categorized_elements = []\n",
     "for element in raw_pdf_elements:\n",
@@ -220,14 +223,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Prompt \n",
-    "prompt_text=\"\"\"You are an assistant tasked with summarizing tables and text. \\ \n",
+    "# Prompt\n",
+    "prompt_text = \"\"\"You are an assistant tasked with summarizing tables and text. \\\n",
     "Give a concise summary of the table or text. Table or text chunk: {element} \"\"\"\n",
-    "prompt = ChatPromptTemplate.from_template(prompt_text) \n",
+    "prompt = ChatPromptTemplate.from_template(prompt_text)\n",
     "\n",
-    "# Summary chain \n",
-    "model = ChatOpenAI(temperature=0,model=\"gpt-4\")\n",
-    "summarize_chain = {\"element\": lambda x:x} | prompt | model | StrOutputParser()"
+    "# Summary chain\n",
+    "model = ChatOpenAI(temperature=0, model=\"gpt-4\")\n",
+    "summarize_chain = {\"element\": lambda x: x} | prompt | model | StrOutputParser()"
    ]
   },
   {
@@ -310,7 +313,7 @@
     "    # Execute the command and save the output to the defined output file\n",
     "    /Users/rlm/Desktop/Code/llama.cpp/bin/llava -m ../models/llava-7b/ggml-model-q5_k.gguf --mmproj ../models/llava-7b/mmproj-model-f16.gguf --temp 0.1 -p \"Describe the image in detail. Be specific about graphs, such as bar plots.\" --image \"$img\" > \"$output_file\"\n",
     "\n",
-    "done"
+    "done\n"
    ]
   },
   {
@@ -334,7 +337,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os, glob\n",
+    "import glob\n",
+    "import os\n",
     "\n",
     "# Get all .txt file summaries\n",
     "file_paths = glob.glob(os.path.expanduser(os.path.join(path, \"*.txt\")))\n",
@@ -342,11 +346,11 @@
     "# Read each file and store its content in a list\n",
     "img_summaries = []\n",
     "for file_path in file_paths:\n",
-    "    with open(file_path, 'r') as file:\n",
+    "    with open(file_path, \"r\") as file:\n",
     "        img_summaries.append(file.read())\n",
     "\n",
     "# Remove any logging prior to summary\n",
-    "logging_header=\"clip_model_load: total allocated memory: 201.27 MB\\n\\n\"\n",
+    "logging_header = \"clip_model_load: total allocated memory: 201.27 MB\\n\\n\"\n",
     "cleaned_img_summary = [s.split(logging_header, 1)[1].strip() for s in img_summaries]"
    ]
   },
@@ -368,17 +372,15 @@
    "outputs": [],
    "source": [
     "import uuid\n",
-    "from langchain.vectorstores import Chroma\n",
-    "from langchain.storage import InMemoryStore\n",
-    "from langchain.schema.document import Document\n",
+    "\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",
     "\n",
     "# The vectorstore to use to index the child chunks\n",
-    "vectorstore = Chroma(\n",
-    "    collection_name=\"summaries\",\n",
-    "    embedding_function=OpenAIEmbeddings()\n",
-    ")\n",
+    "vectorstore = Chroma(collection_name=\"summaries\", embedding_function=OpenAIEmbeddings())\n",
     "\n",
     "# The storage layer for the parent documents\n",
     "store = InMemoryStore()\n",
@@ -386,20 +388,26 @@
     "\n",
     "# The retriever (empty to start)\n",
     "retriever = MultiVectorRetriever(\n",
-    "    vectorstore=vectorstore, \n",
-    "    docstore=store, \n",
+    "    vectorstore=vectorstore,\n",
+    "    docstore=store,\n",
     "    id_key=id_key,\n",
     ")\n",
     "\n",
     "# Add texts\n",
     "doc_ids = [str(uuid.uuid4()) for _ in texts]\n",
-    "summary_texts = [Document(page_content=s,metadata={id_key: doc_ids[i]}) for i, s in enumerate(text_summaries)]\n",
+    "summary_texts = [\n",
+    "    Document(page_content=s, metadata={id_key: doc_ids[i]})\n",
+    "    for i, s in enumerate(text_summaries)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_texts)\n",
     "retriever.docstore.mset(list(zip(doc_ids, texts)))\n",
     "\n",
     "# Add tables\n",
     "table_ids = [str(uuid.uuid4()) for _ in tables]\n",
-    "summary_tables = [Document(page_content=s,metadata={id_key: table_ids[i]}) for i, s in enumerate(table_summaries)]\n",
+    "summary_tables = [\n",
+    "    Document(page_content=s, metadata={id_key: table_ids[i]})\n",
+    "    for i, s in enumerate(table_summaries)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_tables)\n",
     "retriever.docstore.mset(list(zip(table_ids, tables)))"
    ]
@@ -423,9 +431,12 @@
    "source": [
     "# Add image summaries\n",
     "img_ids = [str(uuid.uuid4()) for _ in cleaned_img_summary]\n",
-    "summary_img = [Document(page_content=s,metadata={id_key: img_ids[i]}) for i, s in enumerate(cleaned_img_summary)]\n",
+    "summary_img = [\n",
+    "    Document(page_content=s, metadata={id_key: img_ids[i]})\n",
+    "    for i, s in enumerate(cleaned_img_summary)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_img)\n",
-    "retriever.docstore.mset(list(zip(img_ids, cleaned_img_summary))) "
+    "retriever.docstore.mset(list(zip(img_ids, cleaned_img_summary)))"
    ]
   },
   {
@@ -449,10 +460,19 @@
    "source": [
     "# Add images\n",
     "img_ids = [str(uuid.uuid4()) for _ in cleaned_img_summary]\n",
-    "summary_img = [Document(page_content=s,metadata={id_key: img_ids[i]}) for i, s in enumerate(cleaned_img_summary)]\n",
+    "summary_img = [\n",
+    "    Document(page_content=s, metadata={id_key: img_ids[i]})\n",
+    "    for i, s in enumerate(cleaned_img_summary)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_img)\n",
     "### Fetch images\n",
-    "retriever.docstore.mset(list(zip(img_ids, ### image ### ))) "
+    "retriever.docstore.mset(\n",
+    "    list(\n",
+    "        zip(\n",
+    "            img_ids,\n",
+    "        )\n",
+    "    )\n",
+    ")"
    ]
   },
   {
@@ -542,7 +562,9 @@
    ],
    "source": [
     "# We can retrieve this table\n",
-    "retriever.get_relevant_documents(\"What are results for LLaMA across across domains / subjects?\")[1]"
+    "retriever.get_relevant_documents(\n",
+    "    \"What are results for LLaMA across across domains / subjects?\"\n",
+    ")[1]"
    ]
   },
   {
@@ -592,7 +614,9 @@
     }
    ],
    "source": [
-    "retriever.get_relevant_documents(\"Images / figures with playful and creative examples\")[1]"
+    "retriever.get_relevant_documents(\"Images / figures with playful and creative examples\")[\n",
+    "    1\n",
+    "]"
    ]
   },
   {
@@ -622,7 +646,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from operator import itemgetter\n",
     "from langchain.schema.runnable import RunnablePassthrough\n",
     "\n",
     "# Prompt template\n",
@@ -633,15 +656,15 @@
     "prompt = ChatPromptTemplate.from_template(template)\n",
     "\n",
     "# Option 1: LLM\n",
-    "model = ChatOpenAI(temperature=0,model=\"gpt-4\")\n",
+    "model = ChatOpenAI(temperature=0, model=\"gpt-4\")\n",
     "# Option 2: Multi-modal LLM\n",
     "# model = GPT4-V or LLaVA\n",
     "\n",
     "# RAG pipeline\n",
     "chain = (\n",
-    "    {\"context\": retriever, \"question\": RunnablePassthrough()} \n",
-    "    | prompt \n",
-    "    | model \n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    "    | prompt\n",
+    "    | model\n",
     "    | StrOutputParser()\n",
     ")"
    ]
@@ -664,7 +687,9 @@
     }
    ],
    "source": [
-    "chain.invoke(\"What is the performance of LLaVa across across multiple image domains / subjects?\")"
+    "chain.invoke(\n",
+    "    \"What is the performance of LLaVa across across multiple image domains / subjects?\"\n",
+    ")"
    ]
   },
   {
@@ -713,7 +738,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb

@@ -82,32 +82,33 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import pandas as pd\n",
-    "from lxml import html\n",
+    "from typing import Any\n",
+    "\n",
     "from pydantic import BaseModel\n",
-    "from typing import Any, Optional\n",
     "from unstructured.partition.pdf import partition_pdf\n",
     "\n",
     "# Path to save images\n",
     "path = \"/Users/rlm/Desktop/Papers/LLaVA/\"\n",
     "\n",
     "# Get elements\n",
-    "raw_pdf_elements = partition_pdf(filename=path+\"LLaVA.pdf\",\n",
-    "                                 # Using pdf format to find embedded image blocks\n",
-    "                                 extract_images_in_pdf=True,\n",
-    "                                 # Use layout model (YOLOX) to get bounding boxes (for tables) and find titles\n",
-    "                                 # Titles are any sub-section of the document \n",
-    "                                 infer_table_structure=True, \n",
-    "                                 # Post processing to aggregate text once we have the title \n",
-    "                                 chunking_strategy=\"by_title\",\n",
-    "                                 # Chunking params to aggregate text blocks\n",
-    "                                 # Attempt to create a new chunk 3800 chars\n",
-    "                                 # Attempt to keep chunks > 2000 chars \n",
-    "                                 # Hard max on chunks\n",
-    "                                 max_characters=4000, \n",
-    "                                 new_after_n_chars=3800, \n",
-    "                                 combine_text_under_n_chars=2000,\n",
-    "                                 image_output_dir_path=path)"
+    "raw_pdf_elements = partition_pdf(\n",
+    "    filename=path + \"LLaVA.pdf\",\n",
+    "    # Using pdf format to find embedded image blocks\n",
+    "    extract_images_in_pdf=True,\n",
+    "    # Use layout model (YOLOX) to get bounding boxes (for tables) and find titles\n",
+    "    # Titles are any sub-section of the document\n",
+    "    infer_table_structure=True,\n",
+    "    # Post processing to aggregate text once we have the title\n",
+    "    chunking_strategy=\"by_title\",\n",
+    "    # Chunking params to aggregate text blocks\n",
+    "    # Attempt to create a new chunk 3800 chars\n",
+    "    # Attempt to keep chunks > 2000 chars\n",
+    "    # Hard max on chunks\n",
+    "    max_characters=4000,\n",
+    "    new_after_n_chars=3800,\n",
+    "    combine_text_under_n_chars=2000,\n",
+    "    image_output_dir_path=path,\n",
+    ")"
    ]
   },
   {
@@ -165,6 +166,7 @@
     "    type: str\n",
     "    text: Any\n",
     "\n",
+    "\n",
     "# Categorize by type\n",
     "categorized_elements = []\n",
     "for element in raw_pdf_elements:\n",
@@ -219,14 +221,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Prompt \n",
-    "prompt_text=\"\"\"You are an assistant tasked with summarizing tables and text. \\ \n",
+    "# Prompt\n",
+    "prompt_text = \"\"\"You are an assistant tasked with summarizing tables and text. \\\n",
     "Give a concise summary of the table or text. Table or text chunk: {element} \"\"\"\n",
-    "prompt = ChatPromptTemplate.from_template(prompt_text) \n",
+    "prompt = ChatPromptTemplate.from_template(prompt_text)\n",
     "\n",
-    "# Summary chain \n",
+    "# Summary chain\n",
     "model = ChatOllama(model=\"llama2:13b-chat\")\n",
-    "summarize_chain = {\"element\": lambda x:x} | prompt | model | StrOutputParser()"
+    "summarize_chain = {\"element\": lambda x: x} | prompt | model | StrOutputParser()"
    ]
   },
   {
@@ -309,7 +311,7 @@
     "    # Execute the command and save the output to the defined output file\n",
     "    /Users/rlm/Desktop/Code/llama.cpp/bin/llava -m ../models/llava-7b/ggml-model-q5_k.gguf --mmproj ../models/llava-7b/mmproj-model-f16.gguf --temp 0.1 -p \"Describe the image in detail. Be specific about graphs, such as bar plots.\" --image \"$img\" > \"$output_file\"\n",
     "\n",
-    "done"
+    "done\n"
    ]
   },
   {
@@ -319,7 +321,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os, glob\n",
+    "import glob\n",
+    "import os\n",
     "\n",
     "# Get all .txt files in the directory\n",
     "file_paths = glob.glob(os.path.expanduser(os.path.join(path, \"*.txt\")))\n",
@@ -327,11 +330,14 @@
     "# Read each file and store its content in a list\n",
     "img_summaries = []\n",
     "for file_path in file_paths:\n",
-    "    with open(file_path, 'r') as file:\n",
+    "    with open(file_path, \"r\") as file:\n",
     "        img_summaries.append(file.read())\n",
     "\n",
     "# Clean up residual logging\n",
-    "cleaned_img_summary = [s.split(\"clip_model_load: total allocated memory: 201.27 MB\\n\\n\", 1)[1].strip() for s in img_summaries]"
+    "cleaned_img_summary = [\n",
+    "    s.split(\"clip_model_load: total allocated memory: 201.27 MB\\n\\n\", 1)[1].strip()\n",
+    "    for s in img_summaries\n",
+    "]"
    ]
   },
   {
@@ -369,26 +375,26 @@
    ],
    "source": [
     "import uuid\n",
-    "from langchain.vectorstores import Chroma\n",
-    "from langchain.storage import InMemoryStore\n",
-    "from langchain.schema.document import Document\n",
+    "\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",
     "\n",
     "# The vectorstore to use to index the child chunks\n",
     "vectorstore = Chroma(\n",
-    "    collection_name=\"summaries\",\n",
-    "    embedding_function=GPT4AllEmbeddings()\n",
+    "    collection_name=\"summaries\", embedding_function=GPT4AllEmbeddings()\n",
     ")\n",
     "\n",
     "# The storage layer for the parent documents\n",
-    "store = InMemoryStore() # <- Can we extend this to images \n",
+    "store = InMemoryStore()  # <- Can we extend this to images\n",
     "id_key = \"doc_id\"\n",
     "\n",
     "# The retriever (empty to start)\n",
     "retriever = MultiVectorRetriever(\n",
-    "    vectorstore=vectorstore, \n",
-    "    docstore=store, \n",
+    "    vectorstore=vectorstore,\n",
+    "    docstore=store,\n",
     "    id_key=id_key,\n",
     ")"
    ]
@@ -412,21 +418,32 @@
    "source": [
     "# Add texts\n",
     "doc_ids = [str(uuid.uuid4()) for _ in texts]\n",
-    "summary_texts = [Document(page_content=s,metadata={id_key: doc_ids[i]}) for i, s in enumerate(text_summaries)]\n",
+    "summary_texts = [\n",
+    "    Document(page_content=s, metadata={id_key: doc_ids[i]})\n",
+    "    for i, s in enumerate(text_summaries)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_texts)\n",
     "retriever.docstore.mset(list(zip(doc_ids, texts)))\n",
     "\n",
     "# Add tables\n",
     "table_ids = [str(uuid.uuid4()) for _ in tables]\n",
-    "summary_tables = [Document(page_content=s,metadata={id_key: table_ids[i]}) for i, s in enumerate(table_summaries)]\n",
+    "summary_tables = [\n",
+    "    Document(page_content=s, metadata={id_key: table_ids[i]})\n",
+    "    for i, s in enumerate(table_summaries)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_tables)\n",
     "retriever.docstore.mset(list(zip(table_ids, tables)))\n",
     "\n",
     "# Add images\n",
     "img_ids = [str(uuid.uuid4()) for _ in cleaned_img_summary]\n",
-    "summary_img = [Document(page_content=s,metadata={id_key: img_ids[i]}) for i, s in enumerate(cleaned_img_summary)]\n",
+    "summary_img = [\n",
+    "    Document(page_content=s, metadata={id_key: img_ids[i]})\n",
+    "    for i, s in enumerate(cleaned_img_summary)\n",
+    "]\n",
     "retriever.vectorstore.add_documents(summary_img)\n",
-    "retriever.docstore.mset(list(zip(img_ids, cleaned_img_summary))) # Store the image summary as the raw document"
+    "retriever.docstore.mset(\n",
+    "    list(zip(img_ids, cleaned_img_summary))\n",
+    ")  # Store the image summary as the raw document"
    ]
   },
   {
@@ -484,7 +501,9 @@
     }
    ],
    "source": [
-    "retriever.get_relevant_documents(\"Images / figures with playful and creative examples\")[0]"
+    "retriever.get_relevant_documents(\"Images / figures with playful and creative examples\")[\n",
+    "    0\n",
+    "]"
    ]
   },
   {
@@ -513,7 +532,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from operator import itemgetter\n",
     "from langchain.schema.runnable import RunnablePassthrough\n",
     "\n",
     "# Prompt template\n",
@@ -530,9 +548,9 @@
     "\n",
     "# RAG pipeline\n",
     "chain = (\n",
-    "    {\"context\": retriever, \"question\": RunnablePassthrough()} \n",
-    "    | prompt \n",
-    "    | model \n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    "    | prompt\n",
+    "    | model\n",
     "    | StrOutputParser()\n",
     ")"
    ]
@@ -555,7 +573,9 @@
     }
    ],
    "source": [
-    "chain.invoke(\"What is the performance of LLaVa across across multiple image domains / subjects?\")"
+    "chain.invoke(\n",
+    "    \"What is the performance of LLaVa across across multiple image domains / subjects?\"\n",
+    ")"
    ]
   },
   {
@@ -584,7 +604,9 @@
     }
    ],
    "source": [
-    "chain.invoke(\"Explain any images / figures in the paper with playful and creative examples.\")"
+    "chain.invoke(\n",
+    "    \"Explain any images / figures in the paper with playful and creative examples.\"\n",
+    ")"
    ]
   },
   {

cookbook/analyze_document.ipynb

@@ -0,0 +1,105 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f69d4a4c-137d-47e9-bea1-786afce9c1c0",
+   "metadata": {},
+   "source": [
+    "# Analyze a single long document\n",
+    "\n",
+    "The AnalyzeDocumentChain takes in a single document, splits it up, and then runs it through a CombineDocumentsChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2a0707ce-6d2d-471b-bc33-64da32a7b3f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"../docs/docs/modules/state_of_the_union.txt\") as f:\n",
+    "    state_of_the_union = f.read()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "ca14d161-2d5b-4a6c-a296-77d8ce4b28cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import AnalyzeDocumentChain\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "\n",
+    "llm = ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "9f97406c-85a9-45fb-99ce-9138c0ba3731",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.question_answering import load_qa_chain\n",
+    "\n",
+    "qa_chain = load_qa_chain(llm, chain_type=\"map_reduce\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0871a753-f5bb-4b4f-a394-f87f2691f659",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qa_document_chain = AnalyzeDocumentChain(combine_docs_chain=qa_chain)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e6f86428-3c2c-46a0-a57c-e22826fdbf91",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The President said, \"Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.\"'"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qa_document_chain.run(\n",
+    "    input_document=state_of_the_union,\n",
+    "    question=\"what did the president say about justice breyer?\",\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cookbook/autogpt/autogpt.ipynb

@@ -27,10 +27,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.utilities import SerpAPIWrapper\n",
     "from langchain.agents import Tool\n",
-    "from langchain.tools.file_management.write import WriteFileTool\n",
     "from langchain.tools.file_management.read import ReadFileTool\n",
+    "from langchain.tools.file_management.write import WriteFileTool\n",
+    "from langchain.utilities import SerpAPIWrapper\n",
     "\n",
     "search = SerpAPIWrapper()\n",
     "tools = [\n",
@@ -61,9 +61,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.vectorstores import FAISS\n",
     "from langchain.docstore import InMemoryDocstore\n",
-    "from langchain.embeddings import OpenAIEmbeddings"
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import FAISS"
    ]
   },
   {
@@ -100,8 +100,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_experimental.autonomous_agents import AutoGPT\n",
-    "from langchain.chat_models import ChatOpenAI"
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain_experimental.autonomous_agents import AutoGPT"
    ]
   },
   {

cookbook/autogpt/marathon_times.ipynb

@@ -34,16 +34,15 @@
    "outputs": [],
    "source": [
     "# General\n",
-    "import os\n",
-    "import pandas as pd\n",
-    "from langchain_experimental.autonomous_agents import AutoGPT\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "\n",
-    "from langchain.agents.agent_toolkits.pandas.base import create_pandas_dataframe_agent\n",
-    "from langchain.docstore.document import Document\n",
     "import asyncio\n",
-    "import nest_asyncio\n",
+    "import os\n",
     "\n",
+    "import nest_asyncio\n",
+    "import pandas as pd\n",
+    "from langchain.agents.agent_toolkits.pandas.base import create_pandas_dataframe_agent\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.docstore.document import Document\n",
+    "from langchain_experimental.autonomous_agents import AutoGPT\n",
     "\n",
     "# Needed synce jupyter runs an async eventloop\n",
     "nest_asyncio.apply()"
@@ -92,6 +91,7 @@
     "import os\n",
     "from contextlib import contextmanager\n",
     "from typing import Optional\n",
+    "\n",
     "from langchain.agents import tool\n",
     "from langchain.tools.file_management.read import ReadFileTool\n",
     "from langchain.tools.file_management.write import WriteFileTool\n",
@@ -223,14 +223,13 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.tools import BaseTool, DuckDuckGoSearchRun\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
-    "\n",
-    "from pydantic import Field\n",
     "from langchain.chains.qa_with_sources.loading import (\n",
-    "    load_qa_with_sources_chain,\n",
     "    BaseCombineDocumentsChain,\n",
+    "    load_qa_with_sources_chain,\n",
     ")\n",
+    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "from langchain.tools import BaseTool, DuckDuckGoSearchRun\n",
+    "from pydantic import Field\n",
     "\n",
     "\n",
     "def _get_text_splitter():\n",
@@ -311,10 +310,9 @@
    "source": [
     "# Memory\n",
     "import faiss\n",
-    "from langchain.vectorstores import FAISS\n",
     "from langchain.docstore import InMemoryDocstore\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.tools.human.tool import HumanInputRun\n",
+    "from langchain.vectorstores import FAISS\n",
     "\n",
     "embeddings_model = OpenAIEmbeddings()\n",
     "embedding_size = 1536\n",

cookbook/baby_agi.ipynb

@@ -29,16 +29,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
-    "from collections import deque\n",
-    "from typing import Dict, List, Optional, Any\n",
+    "from typing import Optional\n",
     "\n",
-    "from langchain.chains import LLMChain\nfrom langchain.llms import OpenAI\nfrom langchain.prompts import PromptTemplate\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.llms import BaseLLM\n",
-    "from langchain.schema.vectorstore import VectorStore\n",
-    "from pydantic import BaseModel, Field\n",
-    "from langchain.chains.base import Chain\n",
+    "from langchain.llms import OpenAI\n",
     "from langchain_experimental.autonomous_agents import BabyAGI"
    ]
   },
@@ -59,8 +53,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.vectorstores import FAISS\n",
-    "from langchain.docstore import InMemoryDocstore"
+    "from langchain.docstore import InMemoryDocstore\n",
+    "from langchain.vectorstores import FAISS"
    ]
   },
   {

cookbook/baby_agi_with_agent.ipynb

@@ -25,16 +25,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
-    "from collections import deque\n",
-    "from typing import Dict, List, Optional, Any\n",
+    "from typing import Optional\n",
     "\n",
-    "from langchain.chains import LLMChain\nfrom langchain.llms import OpenAI\nfrom langchain.prompts import PromptTemplate\n",
+    "from langchain.chains import LLMChain\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.llms import BaseLLM\n",
-    "from langchain.schema.vectorstore import VectorStore\n",
-    "from pydantic import BaseModel, Field\n",
-    "from langchain.chains.base import Chain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.prompts import PromptTemplate\n",
     "from langchain_experimental.autonomous_agents import BabyAGI"
    ]
   },
@@ -66,8 +62,8 @@
    "source": [
     "%pip install faiss-cpu > /dev/null\n",
     "%pip install google-search-results > /dev/null\n",
-    "from langchain.vectorstores import FAISS\n",
-    "from langchain.docstore import InMemoryDocstore"
+    "from langchain.docstore import InMemoryDocstore\n",
+    "from langchain.vectorstores import FAISS"
    ]
   },
   {
@@ -110,8 +106,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n",
-    "from langchain.llms import OpenAI\nfrom langchain.utilities import SerpAPIWrapper\nfrom langchain.chains import LLMChain\n",
+    "from langchain.agents import AgentExecutor, Tool, ZeroShotAgent\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.utilities import SerpAPIWrapper\n",
     "\n",
     "todo_prompt = PromptTemplate.from_template(\n",
     "    \"You are a planner who is an expert at coming up with a todo list for a given objective. Come up with a todo list for this objective: {objective}\"\n",

cookbook/camel_role_playing.ipynb

@@ -35,16 +35,17 @@
    "outputs": [],
    "source": [
     "from typing import List\n",
+    "\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts.chat import (\n",
-    "    SystemMessagePromptTemplate,\n",
     "    HumanMessagePromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
     ")\n",
     "from langchain.schema import (\n",
     "    AIMessage,\n",
+    "    BaseMessage,\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
-    "    BaseMessage,\n",
     ")"
    ]
   },

cookbook/causal_program_aided_language_model.ipynb

@@ -47,10 +47,9 @@
    "outputs": [],
    "source": [
     "from IPython.display import SVG\n",
-    "\n",
+    "from langchain.llms import OpenAI\n",
     "from langchain_experimental.cpal.base import CPALChain\n",
     "from langchain_experimental.pal_chain import PALChain\n",
-    "from langchain.llms import OpenAI\n",
     "\n",
     "llm = OpenAI(temperature=0, max_tokens=512)\n",
     "cpal_chain = CPALChain.from_univariate_prompt(llm=llm, verbose=True)\n",

cookbook/code-analysis-deeplake.ipynb

@@ -177,7 +177,7 @@
     "            try:\n",
     "                loader = TextLoader(os.path.join(dirpath, file), encoding=\"utf-8\")\n",
     "                docs.extend(loader.load_and_split())\n",
-    "            except Exception as e:\n",
+    "            except Exception:\n",
     "                pass\n",
     "print(f\"{len(docs)}\")"
    ]
@@ -648,7 +648,7 @@
     {
      "data": {
       "text/plain": [
-       "OpenAIEmbeddings(client=<class 'openai.api_resources.embedding.Embedding'>, model='text-embedding-ada-002', deployment='text-embedding-ada-002', openai_api_version='', openai_api_base='', openai_api_type='', openai_proxy='', embedding_ctx_length=8191, openai_api_key='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', openai_organization='', allowed_special=set(), disallowed_special='all', chunk_size=1000, max_retries=6, request_timeout=None, headers=None, tiktoken_model_name=None, show_progress_bar=False, model_kwargs={})"
+       "OpenAIEmbeddings(client=<class 'openai.api_resources.embedding.Embedding'>, model='text-embedding-ada-002', deployment='text-embedding-ada-002', openai_api_version='', openai_api_base='', openai_api_type='', openai_proxy='', embedding_ctx_length=8191, openai_api_key='', openai_organization='', allowed_special=set(), disallowed_special='all', chunk_size=1000, max_retries=6, request_timeout=None, headers=None, tiktoken_model_name=None, show_progress_bar=False, model_kwargs={})"
       ]
      },
      "execution_count": 13,
@@ -717,7 +717,6 @@
    "source": [
     "from langchain.vectorstores import DeepLake\n",
     "\n",
-    "\n",
     "username = \"<USERNAME_OR_ORG>\"\n",
     "\n",
     "\n",
@@ -834,10 +833,12 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.chains import ConversationalRetrievalChain\n",
+    "from langchain.chat_models import ChatOpenAI\n",
     "\n",
-    "model = ChatOpenAI(model_name=\"gpt-3.5-turbo-0613\")  # 'ada' 'gpt-3.5-turbo-0613' 'gpt-4',\n",
+    "model = ChatOpenAI(\n",
+    "    model_name=\"gpt-3.5-turbo-0613\"\n",
+    ")  # 'ada' 'gpt-3.5-turbo-0613' 'gpt-4',\n",
     "qa = ConversationalRetrievalChain.from_llm(model, retriever=retriever)"
    ]
   },

cookbook/custom_agent_with_plugin_retrieval.ipynb

@@ -32,19 +32,20 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import re\n",
+    "from typing import Union\n",
+    "\n",
     "from langchain.agents import (\n",
-    "    Tool,\n",
     "    AgentExecutor,\n",
-    "    LLMSingleActionAgent,\n",
     "    AgentOutputParser,\n",
+    "    LLMSingleActionAgent,\n",
     ")\n",
-    "from langchain.prompts import StringPromptTemplate\n",
-    "from langchain.llms import OpenAI\nfrom langchain.utilities import SerpAPIWrapper\nfrom langchain.chains import LLMChain\n",
-    "from typing import List, Union\n",
-    "from langchain.schema import AgentAction, AgentFinish\n",
     "from langchain.agents.agent_toolkits import NLAToolkit\n",
-    "from langchain.tools.plugin import AIPlugin\n",
-    "import re"
+    "from langchain.chains import LLMChain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.prompts import StringPromptTemplate\n",
+    "from langchain.schema import AgentAction, AgentFinish\n",
+    "from langchain.tools.plugin import AIPlugin"
    ]
   },
   {
@@ -113,9 +114,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.vectorstores import FAISS\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.schema import Document"
+    "from langchain.schema import Document\n",
+    "from langchain.vectorstores import FAISS"
    ]
   },
   {

cookbook/custom_agent_with_plugin_retrieval_using_plugnplai.ipynb

@@ -56,20 +56,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import (\n",
-    "    Tool,\n",
-    "    AgentExecutor,\n",
-    "    LLMSingleActionAgent,\n",
-    "    AgentOutputParser,\n",
-    ")\n",
-    "from langchain.prompts import StringPromptTemplate\n",
-    "from langchain.llms import OpenAI\nfrom langchain.utilities import SerpAPIWrapper\nfrom langchain.chains import LLMChain\n",
-    "from typing import List, Union\n",
-    "from langchain.schema import AgentAction, AgentFinish\n",
-    "from langchain.agents.agent_toolkits import NLAToolkit\n",
-    "from langchain.tools.plugin import AIPlugin\n",
     "import re\n",
-    "import plugnplai"
+    "from typing import Union\n",
+    "\n",
+    "import plugnplai\n",
+    "from langchain.agents import (\n",
+    "    AgentExecutor,\n",
+    "    AgentOutputParser,\n",
+    "    LLMSingleActionAgent,\n",
+    ")\n",
+    "from langchain.agents.agent_toolkits import NLAToolkit\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.prompts import StringPromptTemplate\n",
+    "from langchain.schema import AgentAction, AgentFinish\n",
+    "from langchain.tools.plugin import AIPlugin"
    ]
   },
   {
@@ -137,9 +138,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.vectorstores import FAISS\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.schema import Document"
+    "from langchain.schema import Document\n",
+    "from langchain.vectorstores import FAISS"
    ]
   },
   {

cookbook/deeplake_semantic_search_over_chat.ipynb

@@ -48,18 +48,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
     "import getpass\n",
-    "from langchain.document_loaders import PyPDFLoader, TextLoader\n",
+    "import os\n",
+    "\n",
+    "from langchain.chains import RetrievalQA\n",
     "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.llms import OpenAI\n",
     "from langchain.text_splitter import (\n",
-    "    RecursiveCharacterTextSplitter,\n",
     "    CharacterTextSplitter,\n",
+    "    RecursiveCharacterTextSplitter,\n",
     ")\n",
     "from langchain.vectorstores import DeepLake\n",
-    "from langchain.chains import ConversationalRetrievalChain, RetrievalQA\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.llms import OpenAI\n",
     "\n",
     "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")\n",
     "activeloop_token = getpass.getpass(\"Activeloop Token:\")\n",

cookbook/elasticsearch_db_qa.ipynb

@@ -38,9 +38,8 @@
    "outputs": [],
    "source": [
     "from elasticsearch import Elasticsearch\n",
-    "\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.chains.elasticsearch_database import ElasticsearchDatabaseChain"
+    "from langchain.chains.elasticsearch_database import ElasticsearchDatabaseChain\n",
+    "from langchain.chat_models import ChatOpenAI"
    ]
   },
   {
@@ -112,7 +111,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains.elasticsearch_database.prompts import DEFAULT_DSL_TEMPLATE\n",
     "from langchain.prompts.prompt import PromptTemplate\n",
     "\n",
     "PROMPT_TEMPLATE = \"\"\"Given an input question, create a syntactically correct Elasticsearch query to run. Unless the user specifies in their question a specific number of examples they wish to obtain, always limit your query to at most {top_k} results. You can order the results by a relevant column to return the most interesting examples in the database.\n",

cookbook/extraction_openai_tools.ipynb

@@ -0,0 +1,214 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2def22ea",
+   "metadata": {},
+   "source": [
+    "# Extraction with OpenAI Tools\n",
+    "\n",
+    "Performing extraction has never been easier! OpenAI's tool calling ability is the perfect thing to use as it allows for extracting multiple different elements from text that are different types. \n",
+    "\n",
+    "Models after 1106 use tools and support \"parallel function calling\" which makes this super easy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "5c628496",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List, Optional\n",
+    "\n",
+    "from langchain.chains.openai_tools import create_extraction_chain_pydantic\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.pydantic_v1 import BaseModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "afe9657b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Make sure to use a recent model that supports tools\n",
+    "model = ChatOpenAI(model=\"gpt-3.5-turbo-1106\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "bc0ca3b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Pydantic is an easy way to define a schema\n",
+    "class Person(BaseModel):\n",
+    "    \"\"\"Information about people to extract.\"\"\"\n",
+    "\n",
+    "    name: str\n",
+    "    age: Optional[int] = None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "2036af68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = create_extraction_chain_pydantic(Person, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "1748ad21",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Person(name='jane', age=2), Person(name='bob', age=3)]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"input\": \"jane is 2 and bob is 3\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "c8262ce5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's define another element\n",
+    "class Class(BaseModel):\n",
+    "    \"\"\"Information about classes to extract.\"\"\"\n",
+    "\n",
+    "    teacher: str\n",
+    "    students: List[str]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "4973c104",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = create_extraction_chain_pydantic([Person, Class], model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e976a15e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Person(name='jane', age=2),\n",
+       " Person(name='bob', age=3),\n",
+       " Class(teacher='Mrs Sampson', students=['jane', 'bob'])]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"input\": \"jane is 2 and bob is 3 and they are in Mrs Sampson's class\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6575a7d6",
+   "metadata": {},
+   "source": [
+    "## Under the hood\n",
+    "\n",
+    "Under the hood, this is a simple chain:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8ba83e5",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "from typing import Union, List, Type, Optional\n",
+    "\n",
+    "from langchain.output_parsers.openai_tools import PydanticToolsParser\n",
+    "from langchain.utils.openai_functions import convert_pydantic_to_openai_tool\n",
+    "from langchain.schema.runnable import Runnable\n",
+    "from langchain.pydantic_v1 import BaseModel\n",
+    "from langchain.prompts import ChatPromptTemplate\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",
+    "\n",
+    "If a property is not present and is not required in the function parameters, do not include it in the output.\"\"\"  # noqa: E501\n",
+    "\n",
+    "\n",
+    "def create_extraction_chain_pydantic(\n",
+    "    pydantic_schemas: Union[List[Type[BaseModel]], Type[BaseModel]],\n",
+    "    llm: BaseLanguageModel,\n",
+    "    system_message: str = _EXTRACTION_TEMPLATE,\n",
+    ") -> Runnable:\n",
+    "    if not isinstance(pydantic_schemas, list):\n",
+    "        pydantic_schemas = [pydantic_schemas]\n",
+    "    prompt = ChatPromptTemplate.from_messages([\n",
+    "        (\"system\", system_message),\n",
+    "        (\"user\", \"{input}\")\n",
+    "    ])\n",
+    "    tools = [convert_pydantic_to_openai_tool(p) for p in pydantic_schemas]\n",
+    "    model = llm.bind(tools=tools)\n",
+    "    chain = prompt | model | PydanticToolsParser(tools=pydantic_schemas)\n",
+    "    return chain\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2eac6b68",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cookbook/fake_llm.ipynb

@@ -30,9 +30,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import load_tools\n",
-    "from langchain.agents import initialize_agent\n",
-    "from langchain.agents import AgentType"
+    "from langchain.agents import AgentType, initialize_agent, load_tools"
    ]
   },
   {

cookbook/forward_looking_retrieval_augmented_generation.ipynb

@@ -56,7 +56,8 @@
    "source": [
     "import os\n",
     "\n",
-    "os.environ[\"SERPER_API_KEY\"] = \"\"os.environ[\"OPENAI_API_KEY\"] = \"\""
+    "os.environ[\"SERPER_API_KEY\"] = \"\"\n",
+    "os.environ[\"OPENAI_API_KEY\"] = \"\""
    ]
   },
   {
@@ -66,21 +67,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import re\n",
+    "from typing import Any, List\n",
     "\n",
-    "import numpy as np\n",
-    "\n",
-    "from langchain.schema import BaseRetriever\n",
     "from langchain.callbacks.manager import (\n",
     "    AsyncCallbackManagerForRetrieverRun,\n",
     "    CallbackManagerForRetrieverRun,\n",
     ")\n",
-    "from langchain.utilities import GoogleSerperAPIWrapper\n",
-    "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.llms import OpenAI\n",
-    "from langchain.schema import Document\n",
-    "from typing import Any, List"
+    "from langchain.schema import BaseRetriever, Document\n",
+    "from langchain.utilities import GoogleSerperAPIWrapper"
    ]
   },
   {

cookbook/generative_agents_interactive_simulacra_of_human_behavior.ipynb

@@ -46,14 +46,13 @@
    "source": [
     "from datetime import datetime, timedelta\n",
     "from typing import List\n",
-    "from termcolor import colored\n",
-    "\n",
     "\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.docstore import InMemoryDocstore\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.retrievers import TimeWeightedVectorStoreRetriever\n",
-    "from langchain.vectorstores import FAISS"
+    "from langchain.vectorstores import FAISS\n",
+    "from termcolor import colored"
    ]
   },
   {
@@ -153,6 +152,7 @@
    "outputs": [],
    "source": [
     "import math\n",
+    "\n",
     "import faiss\n",
     "\n",
     "\n",

cookbook/gymnasium_agent_simulation.ipynb

@@ -27,18 +27,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import gymnasium as gym\n",
-    "import inspect\n",
     "import tenacity\n",
-    "\n",
-    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.output_parsers import RegexParser\n",
     "from langchain.schema import (\n",
-    "    AIMessage,\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
-    "    BaseMessage,\n",
-    ")\n",
-    "from langchain.output_parsers import RegexParser"
+    ")"
    ]
   },
   {
@@ -131,7 +125,7 @@
     "            ):\n",
     "                with attempt:\n",
     "                    action = self._act()\n",
-    "        except tenacity.RetryError as e:\n",
+    "        except tenacity.RetryError:\n",
     "            action = self.random_action()\n",
     "        return action"
    ]

cookbook/hugginggpt.ipynb

@@ -77,6 +77,7 @@
    "source": [
     "from langchain.llms import OpenAI\n",
     "from langchain_experimental.autonomous_agents import HuggingGPT\n",
+    "\n",
     "# %env OPENAI_API_BASE=http://localhost:8000/v1"
    ]
   },

cookbook/human_input_chat_model.ipynb

@@ -55,9 +55,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import load_tools\n",
-    "from langchain.agents import initialize_agent\n",
-    "from langchain.agents import AgentType"
+    "from langchain.agents import AgentType, initialize_agent, load_tools"
    ]
   },
   {

cookbook/human_input_llm.ipynb

@@ -28,9 +28,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import load_tools\n",
-    "from langchain.agents import initialize_agent\n",
-    "from langchain.agents import AgentType"
+    "from langchain.agents import AgentType, initialize_agent, load_tools"
    ]
   },
   {

cookbook/hypothetical_document_embeddings.ipynb

@@ -20,9 +20,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.llms import OpenAI\n",
+    "from langchain.chains import HypotheticalDocumentEmbedder, LLMChain\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.chains import LLMChain, HypotheticalDocumentEmbedder\n",
+    "from langchain.llms import OpenAI\n",
     "from langchain.prompts import PromptTemplate"
    ]
   },

cookbook/learned_prompt_optimization.ipynb

@@ -50,6 +50,7 @@
     "# pick and configure the LLM of your choice\n",
     "\n",
     "from langchain.llms import OpenAI\n",
+    "\n",
     "llm = OpenAI(model=\"text-davinci-003\")"
    ]
   },
@@ -85,8 +86,8 @@
     "\"\"\"\n",
     "\n",
     "PROMPT = PromptTemplate(\n",
-    "    input_variables=[\"meal\", \"text_to_personalize\", \"user\", \"preference\"], \n",
-    "    template=PROMPT_TEMPLATE\n",
+    "    input_variables=[\"meal\", \"text_to_personalize\", \"user\", \"preference\"],\n",
+    "    template=PROMPT_TEMPLATE,\n",
     ")"
    ]
   },
@@ -105,7 +106,7 @@
    "source": [
     "import langchain_experimental.rl_chain as rl_chain\n",
     "\n",
-    "chain = rl_chain.PickBest.from_llm(llm=llm, prompt=PROMPT)\n"
+    "chain = rl_chain.PickBest.from_llm(llm=llm, prompt=PROMPT)"
    ]
   },
   {
@@ -122,10 +123,10 @@
    "outputs": [],
    "source": [
     "response = chain.run(\n",
-    "    meal = rl_chain.ToSelectFrom(meals),\n",
-    "    user = rl_chain.BasedOn(\"Tom\"),\n",
-    "    preference = rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
-    "    text_to_personalize = \"This is the weeks specialty dish, our master chefs \\\n",
+    "    meal=rl_chain.ToSelectFrom(meals),\n",
+    "    user=rl_chain.BasedOn(\"Tom\"),\n",
+    "    preference=rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
+    "    text_to_personalize=\"This is the weeks specialty dish, our master chefs \\\n",
     "        believe you will love it!\",\n",
     ")"
    ]
@@ -193,10 +194,10 @@
     "for _ in range(5):\n",
     "    try:\n",
     "        response = chain.run(\n",
-    "            meal = rl_chain.ToSelectFrom(meals),\n",
-    "            user = rl_chain.BasedOn(\"Tom\"),\n",
-    "            preference = rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
-    "            text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "            meal=rl_chain.ToSelectFrom(meals),\n",
+    "            user=rl_chain.BasedOn(\"Tom\"),\n",
+    "            preference=rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
+    "            text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     "        )\n",
     "    except Exception as e:\n",
     "        print(e)\n",
@@ -223,12 +224,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "scoring_criteria_template = \"Given {preference} rank how good or bad this selection is {meal}\"\n",
+    "scoring_criteria_template = (\n",
+    "    \"Given {preference} rank how good or bad this selection is {meal}\"\n",
+    ")\n",
     "\n",
     "chain = rl_chain.PickBest.from_llm(\n",
     "    llm=llm,\n",
     "    prompt=PROMPT,\n",
-    "    selection_scorer=rl_chain.AutoSelectionScorer(llm=llm, scoring_criteria_template_str=scoring_criteria_template),\n",
+    "    selection_scorer=rl_chain.AutoSelectionScorer(\n",
+    "        llm=llm, scoring_criteria_template_str=scoring_criteria_template\n",
+    "    ),\n",
     ")"
    ]
   },
@@ -255,14 +260,16 @@
    ],
    "source": [
     "response = chain.run(\n",
-    "    meal = rl_chain.ToSelectFrom(meals),\n",
-    "    user = rl_chain.BasedOn(\"Tom\"),\n",
-    "    preference = rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
-    "    text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "    meal=rl_chain.ToSelectFrom(meals),\n",
+    "    user=rl_chain.BasedOn(\"Tom\"),\n",
+    "    preference=rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
+    "    text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     ")\n",
     "print(response[\"response\"])\n",
     "selection_metadata = response[\"selection_metadata\"]\n",
-    "print(f\"selected index: {selection_metadata.selected.index}, score: {selection_metadata.selected.score}\")"
+    "print(\n",
+    "    f\"selected index: {selection_metadata.selected.index}, score: {selection_metadata.selected.score}\"\n",
+    ")"
    ]
   },
   {
@@ -280,8 +287,8 @@
    "source": [
     "class CustomSelectionScorer(rl_chain.SelectionScorer):\n",
     "    def score_response(\n",
-    "        self, inputs, llm_response: str, event: rl_chain.PickBestEvent) -> float:\n",
-    "\n",
+    "        self, inputs, llm_response: str, event: rl_chain.PickBestEvent\n",
+    "    ) -> float:\n",
     "        print(event.based_on)\n",
     "        print(event.to_select_from)\n",
     "\n",
@@ -336,10 +343,10 @@
    ],
    "source": [
     "response = chain.run(\n",
-    "    meal = rl_chain.ToSelectFrom(meals),\n",
-    "    user = rl_chain.BasedOn(\"Tom\"),\n",
-    "    preference = rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
-    "    text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "    meal=rl_chain.ToSelectFrom(meals),\n",
+    "    user=rl_chain.BasedOn(\"Tom\"),\n",
+    "    preference=rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
+    "    text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     ")"
    ]
   },
@@ -370,9 +377,10 @@
     "                return 1.0\n",
     "            else:\n",
     "                return 0.0\n",
-    "    def score_response(\n",
-    "        self, inputs, llm_response: str, event: rl_chain.PickBestEvent) -> float:\n",
     "\n",
+    "    def score_response(\n",
+    "        self, inputs, llm_response: str, event: rl_chain.PickBestEvent\n",
+    "    ) -> float:\n",
     "        selected_meal = event.to_select_from[\"meal\"][event.selected.index]\n",
     "\n",
     "        if \"Tom\" in event.based_on[\"user\"]:\n",
@@ -394,7 +402,7 @@
     "    prompt=PROMPT,\n",
     "    selection_scorer=CustomSelectionScorer(),\n",
     "    metrics_step=5,\n",
-    "    metrics_window_size=5, # rolling window average\n",
+    "    metrics_window_size=5,  # rolling window average\n",
     ")\n",
     "\n",
     "random_chain = rl_chain.PickBest.from_llm(\n",
@@ -402,8 +410,8 @@
     "    prompt=PROMPT,\n",
     "    selection_scorer=CustomSelectionScorer(),\n",
     "    metrics_step=5,\n",
-    "    metrics_window_size=5, # rolling window average\n",
-    "    policy=rl_chain.PickBestRandomPolicy # set the random policy instead of default\n",
+    "    metrics_window_size=5,  # rolling window average\n",
+    "    policy=rl_chain.PickBestRandomPolicy,  # set the random policy instead of default\n",
     ")"
    ]
   },
@@ -416,29 +424,29 @@
     "for _ in range(20):\n",
     "    try:\n",
     "        chain.run(\n",
-    "            meal = rl_chain.ToSelectFrom(meals),\n",
-    "            user = rl_chain.BasedOn(\"Tom\"),\n",
-    "            preference = rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
-    "            text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "            meal=rl_chain.ToSelectFrom(meals),\n",
+    "            user=rl_chain.BasedOn(\"Tom\"),\n",
+    "            preference=rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
+    "            text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     "        )\n",
     "        random_chain.run(\n",
-    "            meal = rl_chain.ToSelectFrom(meals),\n",
-    "            user = rl_chain.BasedOn(\"Tom\"),\n",
-    "            preference = rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
-    "            text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "            meal=rl_chain.ToSelectFrom(meals),\n",
+    "            user=rl_chain.BasedOn(\"Tom\"),\n",
+    "            preference=rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
+    "            text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     "        )\n",
-    "    \n",
+    "\n",
     "        chain.run(\n",
-    "            meal = rl_chain.ToSelectFrom(meals),\n",
-    "            user = rl_chain.BasedOn(\"Anna\"),\n",
-    "            preference = rl_chain.BasedOn([\"Loves meat\", \"especially beef\"]),\n",
-    "            text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "            meal=rl_chain.ToSelectFrom(meals),\n",
+    "            user=rl_chain.BasedOn(\"Anna\"),\n",
+    "            preference=rl_chain.BasedOn([\"Loves meat\", \"especially beef\"]),\n",
+    "            text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     "        )\n",
     "        random_chain.run(\n",
-    "            meal = rl_chain.ToSelectFrom(meals),\n",
-    "            user = rl_chain.BasedOn(\"Anna\"),\n",
-    "            preference = rl_chain.BasedOn([\"Loves meat\", \"especially beef\"]),\n",
-    "            text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "            meal=rl_chain.ToSelectFrom(meals),\n",
+    "            user=rl_chain.BasedOn(\"Anna\"),\n",
+    "            preference=rl_chain.BasedOn([\"Loves meat\", \"especially beef\"]),\n",
+    "            text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     "        )\n",
     "    except Exception as e:\n",
     "        print(e)"
@@ -477,12 +485,17 @@
    ],
    "source": [
     "from matplotlib import pyplot as plt\n",
-    "chain.metrics.to_pandas()['score'].plot(label=\"default learning policy\")\n",
-    "random_chain.metrics.to_pandas()['score'].plot(label=\"random selection policy\")\n",
+    "\n",
+    "chain.metrics.to_pandas()[\"score\"].plot(label=\"default learning policy\")\n",
+    "random_chain.metrics.to_pandas()[\"score\"].plot(label=\"random selection policy\")\n",
     "plt.legend()\n",
     "\n",
-    "print(f\"The final average score for the default policy, calculated over a rolling window, is: {chain.metrics.to_pandas()['score'].iloc[-1]}\")\n",
-    "print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_chain.metrics.to_pandas()['score'].iloc[-1]}\")"
+    "print(\n",
+    "    f\"The final average score for the default policy, calculated over a rolling window, is: {chain.metrics.to_pandas()['score'].iloc[-1]}\"\n",
+    ")\n",
+    "print(\n",
+    "    f\"The final average score for the random policy, calculated over a rolling window, is: {random_chain.metrics.to_pandas()['score'].iloc[-1]}\"\n",
+    ")"
    ]
   },
   {
@@ -777,8 +790,8 @@
     }
    ],
    "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
     "from langchain.globals import set_debug\n",
+    "from langchain.prompts.prompt import PromptTemplate\n",
     "\n",
     "set_debug(True)\n",
     "\n",
@@ -803,10 +816,10 @@
     ")\n",
     "\n",
     "chain.run(\n",
-    "    meal = rl_chain.ToSelectFrom(meals),\n",
-    "    user = rl_chain.BasedOn(\"Tom\"),\n",
-    "    preference = rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
-    "    text_to_personalize = \"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
+    "    meal=rl_chain.ToSelectFrom(meals),\n",
+    "    user=rl_chain.BasedOn(\"Tom\"),\n",
+    "    preference=rl_chain.BasedOn([\"Vegetarian\", \"regular dairy is ok\"]),\n",
+    "    text_to_personalize=\"This is the weeks specialty dish, our master chefs believe you will love it!\",\n",
     ")"
    ]
   }

cookbook/llm_bash.ipynb

@@ -43,8 +43,8 @@
     }
    ],
    "source": [
-    "from langchain_experimental.llm_bash.base import LLMBashChain\n",
     "from langchain.llms import OpenAI\n",
+    "from langchain_experimental.llm_bash.base import LLMBashChain\n",
     "\n",
     "llm = OpenAI(temperature=0)\n",
     "\n",
@@ -70,7 +70,7 @@
    "outputs": [],
    "source": [
     "from langchain.prompts.prompt import PromptTemplate\n",
-    "from langchain.chains.llm_bash.prompt import BashOutputParser\n",
+    "from langchain_experimental.llm_bash.prompt import BashOutputParser\n",
     "\n",
     "_PROMPT_TEMPLATE = \"\"\"If someone asks you to perform a task, your job is to come up with a series of bash commands that will perform the task. There is no need to put \"#!/bin/bash\" in your answer. Make sure to reason step by step, using this format:\n",
     "Question: \"copy the files in the directory named 'target' into a new directory at the same level as target called 'myNewDirectory'\"\n",
@@ -185,7 +185,6 @@
    "source": [
     "from langchain_experimental.llm_bash.bash import BashProcess\n",
     "\n",
-    "\n",
     "persistent_process = BashProcess(persistent=True)\n",
     "bash_chain = LLMBashChain.from_llm(llm, bash_process=persistent_process, verbose=True)\n",
     "\n",

cookbook/llm_math.ipynb

@@ -45,7 +45,8 @@
     }
    ],
    "source": [
-    "from langchain.llms import OpenAI\nfrom langchain.chains import LLMMathChain\n",
+    "from langchain.chains import LLMMathChain\n",
+    "from langchain.llms import OpenAI\n",
     "\n",
     "llm = OpenAI(temperature=0)\n",
     "llm_math = LLMMathChain.from_llm(llm, verbose=True)\n",

cookbook/meta_prompt.ipynb

@@ -56,8 +56,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.llms import OpenAI\nfrom langchain.chains import LLMChain\nfrom langchain.prompts import PromptTemplate\n",
-    "from langchain.memory import ConversationBufferWindowMemory"
+    "from langchain.chains import LLMChain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.memory import ConversationBufferWindowMemory\n",
+    "from langchain.prompts import PromptTemplate"
    ]
   },
   {
@@ -152,13 +154,13 @@
     "        for j in range(max_iters):\n",
     "            print(f\"(Step {j+1}/{max_iters})\")\n",
     "            print(f\"Assistant: {output}\")\n",
-    "            print(f\"Human: \")\n",
+    "            print(\"Human: \")\n",
     "            human_input = input()\n",
     "            if any(phrase in human_input.lower() for phrase in key_phrases):\n",
     "                break\n",
     "            output = chain.predict(human_input=human_input)\n",
     "        if success_phrase in human_input.lower():\n",
-    "            print(f\"You succeeded! Thanks for playing!\")\n",
+    "            print(\"You succeeded! Thanks for playing!\")\n",
     "            return\n",
     "        meta_chain = initialize_meta_chain()\n",
     "        meta_output = meta_chain.predict(chat_history=get_chat_history(chain.memory))\n",
@@ -166,7 +168,7 @@
     "        instructions = get_new_instructions(meta_output)\n",
     "        print(f\"New Instructions: {instructions}\")\n",
     "        print(\"\\n\" + \"#\" * 80 + \"\\n\")\n",
-    "    print(f\"You failed! Thanks for playing!\")"
+    "    print(\"You failed! Thanks for playing!\")"
    ]
   },
   {

cookbook/multi_modal_output_agent.ipynb

@@ -29,9 +29,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from steamship import Block, Steamship\n",
     "import re\n",
-    "from IPython.display import Image"
+    "\n",
+    "from IPython.display import Image\n",
+    "from steamship import Block, Steamship"
    ]
   },
   {
@@ -41,9 +42,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from langchain.agents import AgentType, initialize_agent\n",
     "from langchain.llms import OpenAI\n",
-    "from langchain.agents import initialize_agent\n",
-    "from langchain.agents import AgentType\n",
     "from langchain.tools import SteamshipImageGenerationTool"
    ]
   },

cookbook/multi_player_dnd.ipynb

@@ -26,13 +26,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from typing import List, Dict, Callable\n",
+    "from typing import Callable, List\n",
+    "\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.schema import (\n",
-    "    AIMessage,\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
-    "    BaseMessage,\n",
     ")"
    ]
   },

cookbook/multiagent_authoritarian.ipynb

@@ -27,26 +27,20 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from collections import OrderedDict\n",
     "import functools\n",
     "import random\n",
-    "import re\n",
-    "import tenacity\n",
-    "from typing import List, Dict, Callable\n",
+    "from collections import OrderedDict\n",
+    "from typing import Callable, List\n",
     "\n",
-    "from langchain.prompts import (\n",
-    "    ChatPromptTemplate,\n",
-    "    HumanMessagePromptTemplate,\n",
-    "    PromptTemplate,\n",
-    ")\n",
-    "from langchain.chains import LLMChain\n",
+    "import tenacity\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.output_parsers import RegexParser\n",
+    "from langchain.prompts import (\n",
+    "    PromptTemplate,\n",
+    ")\n",
     "from langchain.schema import (\n",
-    "    AIMessage,\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
-    "    BaseMessage,\n",
     ")"
    ]
   },

cookbook/multiagent_bidding.ipynb

@@ -24,17 +24,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
-    "import re\n",
+    "from typing import Callable, List\n",
+    "\n",
     "import tenacity\n",
-    "from typing import List, Dict, Callable\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.output_parsers import RegexParser\n",
+    "from langchain.prompts import PromptTemplate\n",
     "from langchain.schema import (\n",
-    "    AIMessage,\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
-    "    BaseMessage,\n",
     ")"
    ]
   },

cookbook/myscale_vector_sql.ipynb

@@ -27,19 +27,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "from os import environ\n",
     "import getpass\n",
-    "from typing import Dict, Any\n",
-    "from langchain.llms import OpenAI\nfrom langchain.utilities import SQLDatabase\nfrom langchain.chains import LLMChain\n",
-    "from langchain_experimental.sql.vector_sql import VectorSQLDatabaseChain\n",
-    "from sqlalchemy import create_engine, Column, MetaData\n",
+    "from os import environ\n",
+    "\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.llms import OpenAI\n",
     "from langchain.prompts import PromptTemplate\n",
+    "from langchain.utilities import SQLDatabase\n",
+    "from langchain_experimental.sql.vector_sql import VectorSQLDatabaseChain\n",
+    "from sqlalchemy import MetaData, create_engine\n",
     "\n",
-    "\n",
-    "from sqlalchemy import create_engine\n",
-    "\n",
-    "MYSCALE_HOST = \"msc-1decbcc9.us-east-1.aws.staging.myscale.cloud\"\n",
+    "MYSCALE_HOST = \"msc-4a9e710a.us-east-1.aws.staging.myscale.cloud\"\n",
     "MYSCALE_PORT = 443\n",
     "MYSCALE_USER = \"chatdata\"\n",
     "MYSCALE_PASSWORD = \"myscale_rocks\"\n",
@@ -76,10 +74,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "from langchain.llms import OpenAI\n",
     "from langchain.callbacks import StdOutCallbackHandler\n",
-    "\n",
+    "from langchain.llms import OpenAI\n",
     "from langchain.utilities.sql_database import SQLDatabase\n",
     "from langchain_experimental.sql.prompt import MYSCALE_PROMPT\n",
     "from langchain_experimental.sql.vector_sql import VectorSQLDatabaseChain\n",
@@ -120,14 +116,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.chains.qa_with_sources.retrieval import RetrievalQAWithSourcesChain\n",
-    "\n",
-    "from langchain_experimental.sql.vector_sql import VectorSQLDatabaseChain\n",
-    "from langchain_experimental.retrievers.vector_sql_database \\\n",
-    "    import VectorSQLDatabaseChainRetriever\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain_experimental.retrievers.vector_sql_database import (\n",
+    "    VectorSQLDatabaseChainRetriever,\n",
+    ")\n",
     "from langchain_experimental.sql.prompt import MYSCALE_PROMPT\n",
-    "from langchain_experimental.sql.vector_sql import VectorSQLRetrieveAllOutputParser\n",
+    "from langchain_experimental.sql.vector_sql import (\n",
+    "    VectorSQLDatabaseChain,\n",
+    "    VectorSQLRetrieveAllOutputParser,\n",
+    ")\n",
     "\n",
     "output_parser_retrieve_all = VectorSQLRetrieveAllOutputParser.from_embeddings(\n",
     "    output_parser.model\n",
@@ -144,7 +142,9 @@
     ")\n",
     "\n",
     "# You need all those keys to get docs\n",
-    "retriever = VectorSQLDatabaseChainRetriever(sql_db_chain=chain, page_content_key=\"abstract\")\n",
+    "retriever = VectorSQLDatabaseChainRetriever(\n",
+    "    sql_db_chain=chain, page_content_key=\"abstract\"\n",
+    ")\n",
     "\n",
     "document_with_metadata_prompt = PromptTemplate(\n",
     "    input_variables=[\"page_content\", \"id\", \"title\", \"authors\", \"pubdate\", \"categories\"],\n",
@@ -162,8 +162,10 @@
     "    },\n",
     "    return_source_documents=True,\n",
     ")\n",
-    "ans = chain(\"Please give me 10 papers to ask what is PageRank?\",\n",
-    "            callbacks=[StdOutCallbackHandler()])\n",
+    "ans = chain(\n",
+    "    \"Please give me 10 papers to ask what is PageRank?\",\n",
+    "    callbacks=[StdOutCallbackHandler()],\n",
+    ")\n",
     "print(ans[\"answer\"])"
    ]
   },

cookbook/openai_functions_retrieval_qa.ipynb

@@ -50,10 +50,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.chains import create_qa_with_sources_chain\n",
     "from langchain.chains.combine_documents.stuff import StuffDocumentsChain\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain.chains import create_qa_with_sources_chain"
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import PromptTemplate"
    ]
   },
   {
@@ -230,9 +230,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains import ConversationalRetrievalChain\n",
+    "from langchain.chains import ConversationalRetrievalChain, LLMChain\n",
     "from langchain.memory import ConversationBufferMemory\n",
-    "from langchain.chains import LLMChain\n",
     "\n",
     "memory = ConversationBufferMemory(memory_key=\"chat_history\", return_messages=True)\n",
     "_template = \"\"\"Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.\\\n",
@@ -357,12 +356,10 @@
    "source": [
     "from typing import List\n",
     "\n",
-    "from pydantic import BaseModel, Field\n",
-    "\n",
     "from langchain.chains.openai_functions import create_qa_with_structure_chain\n",
-    "\n",
     "from langchain.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate\n",
-    "from langchain.schema import SystemMessage, HumanMessage"
+    "from langchain.schema import HumanMessage, SystemMessage\n",
+    "from pydantic import BaseModel, Field"
    ]
   },
   {

cookbook/openai_v1_cookbook.ipynb

@@ -0,0 +1,506 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f970f757-ec76-4bf0-90cd-a2fb68b945e3",
+   "metadata": {},
+   "source": [
+    "# Exploring OpenAI V1 functionality\n",
+    "\n",
+    "On 11.06.23 OpenAI released a number of new features, and along with it bumped their Python SDK to 1.0.0. This notebook shows off the new features and how to use them with LangChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee897729-263a-4073-898f-bb4cf01ed829",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# need openai>=1.1.0, langchain>=0.0.335, langchain-experimental>=0.0.39\n",
+    "!pip install -U openai langchain langchain-experimental"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c3e067ce-7a43-47a7-bc89-41f1de4cf136",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.schema.messages import HumanMessage, SystemMessage"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa7e7e95-90a1-4f73-98fe-10c4b4e0951b",
+   "metadata": {},
+   "source": [
+    "## [Vision](https://platform.openai.com/docs/guides/vision)\n",
+    "\n",
+    "OpenAI released multi-modal models, which can take a sequence of text and images as input."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1c8c3965-d3c9-4186-b5f3-5e67855ef916",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='The image appears to be a diagram representing the architecture or components of a software system or framework related to language processing, possibly named LangChain or associated with a project or product called LangChain, based on the prominent appearance of that term. The diagram is organized into several layers or aspects, each containing various elements or modules:\\n\\n1. **Protocol**: This may be the foundational layer, which includes \"LCEL\" and terms like parallelization, fallbacks, tracing, batching, streaming, async, and composition. These seem related to communication and execution protocols for the system.\\n\\n2. **Integrations Components**: This layer includes \"Model I/O\" with elements such as the model, output parser, prompt, and example selector. It also has a \"Retrieval\" section with a document loader, retriever, embedding model, vector store, and text splitter. Lastly, there\\'s an \"Agent Tooling\" section. These components likely deal with the interaction with external data, models, and tools.\\n\\n3. **Application**: The application layer features \"LangChain\" with chains, agents, agent executors, and common application logic. This suggests that the system uses a modular approach with chains and agents to process language tasks.\\n\\n4. **Deployment**: This contains \"Lang')"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chat = ChatOpenAI(model=\"gpt-4-vision-preview\", max_tokens=256)\n",
+    "chat.invoke(\n",
+    "    [\n",
+    "        HumanMessage(\n",
+    "            content=[\n",
+    "                {\"type\": \"text\", \"text\": \"What is this image showing\"},\n",
+    "                {\n",
+    "                    \"type\": \"image_url\",\n",
+    "                    \"image_url\": {\n",
+    "                        \"url\": \"https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/static/img/langchain_stack.png\",\n",
+    "                        \"detail\": \"auto\",\n",
+    "                    },\n",
+    "                },\n",
+    "            ]\n",
+    "        )\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "210f8248-fcf3-4052-a4a3-0684e08f8785",
+   "metadata": {},
+   "source": [
+    "## [OpenAI assistants](https://platform.openai.com/docs/assistants/overview)\n",
+    "\n",
+    "> The Assistants API allows you to build AI assistants within your own applications. An Assistant has instructions and can leverage models, tools, and knowledge to respond to user queries. The Assistants API currently supports three types of tools: Code Interpreter, Retrieval, and Function calling\n",
+    "\n",
+    "\n",
+    "You can interact with OpenAI Assistants using OpenAI tools or custom tools. When using exclusively OpenAI tools, you can just invoke the assistant directly and get final answers. When using custom tools, you can run the assistant and tool execution loop using the built-in AgentExecutor or easily write your own executor.\n",
+    "\n",
+    "Below we show the different ways to interact with Assistants. As a simple example, let's build a math tutor that can write and run code."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "318da28d-4cec-42ab-ae3e-76d95bb34fa5",
+   "metadata": {},
+   "source": [
+    "### Using only OpenAI tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a9064bbe-d9f7-4a29-a7b3-73933b3197e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.openai_assistant import OpenAIAssistantRunnable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7a20a008-49ac-46d2-aa26-b270118af5ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[ThreadMessage(id='msg_g9OJv0rpPgnc3mHmocFv7OVd', assistant_id='asst_hTwZeNMMphxzSOqJ01uBMsJI', content=[MessageContentText(text=Text(annotations=[], value='The result of \\\\(10 - 4^{2.7}\\\\) is approximately \\\\(-32.224\\\\).'), type='text')], created_at=1699460600, file_ids=[], metadata={}, object='thread.message', role='assistant', run_id='run_nBIT7SiAwtUfSCTrQNSPLOfe', thread_id='thread_14n4GgXwxgNL0s30WJW5F6p0')]"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "interpreter_assistant = OpenAIAssistantRunnable.create_assistant(\n",
+    "    name=\"langchain assistant\",\n",
+    "    instructions=\"You are a personal math tutor. Write and run code to answer math questions.\",\n",
+    "    tools=[{\"type\": \"code_interpreter\"}],\n",
+    "    model=\"gpt-4-1106-preview\",\n",
+    ")\n",
+    "output = interpreter_assistant.invoke({\"content\": \"What's 10 - 4 raised to the 2.7\"})\n",
+    "output"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8ddd181-ac63-4ab6-a40d-a236120379c1",
+   "metadata": {},
+   "source": [
+    "### As a LangChain agent with arbitrary tools\n",
+    "\n",
+    "Now let's recreate this functionality using our own tools. For this example we'll use the [E2B sandbox runtime tool](https://e2b.dev/docs?ref=landing-page-get-started)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee4cc355-f2d6-4c51-bcf7-f502868357d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install e2b duckduckgo-search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "48681ac7-b267-48d4-972c-8a7df8393a21",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.tools import DuckDuckGoSearchRun, E2BDataAnalysisTool\n",
+    "\n",
+    "tools = [E2BDataAnalysisTool(api_key=\"...\"), DuckDuckGoSearchRun()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1c01dd79-dd3e-4509-a2e2-009a7f99f16a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = OpenAIAssistantRunnable.create_assistant(\n",
+    "    name=\"langchain assistant e2b tool\",\n",
+    "    instructions=\"You are a personal math tutor. Write and run code to answer math questions. You can also search the internet.\",\n",
+    "    tools=tools,\n",
+    "    model=\"gpt-4-1106-preview\",\n",
+    "    as_agent=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ac71d8b-4b4b-4f98-b826-6b3c57a34166",
+   "metadata": {},
+   "source": [
+    "#### Using AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1f137f94-801f-4766-9ff5-2de9df5e8079",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'content': \"What's the weather in SF today divided by 2.7\",\n",
+       " 'output': \"The weather in San Francisco today is reported to have temperatures as high as 66 °F. To get the temperature divided by 2.7, we will calculate that:\\n\\n66 °F / 2.7 = 24.44 °F\\n\\nSo, when the high temperature of 66 °F is divided by 2.7, the result is approximately 24.44 °F. Please note that this doesn't have a meteorological meaning; it's purely a mathematical operation based on the given temperature.\"}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.agents import AgentExecutor\n",
+    "\n",
+    "agent_executor = AgentExecutor(agent=agent, tools=tools)\n",
+    "agent_executor.invoke({\"content\": \"What's the weather in SF today divided by 2.7\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d0a0b1d-c1b3-4b50-9dce-1189b51a6206",
+   "metadata": {},
+   "source": [
+    "#### Custom execution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c0475fa7-b6c1-4331-b8e2-55407466c724",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = OpenAIAssistantRunnable.create_assistant(\n",
+    "    name=\"langchain assistant e2b tool\",\n",
+    "    instructions=\"You are a personal math tutor. Write and run code to answer math questions.\",\n",
+    "    tools=tools,\n",
+    "    model=\"gpt-4-1106-preview\",\n",
+    "    as_agent=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b76cb669-6aba-4827-868f-00aa960026f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.agent import AgentFinish\n",
+    "\n",
+    "\n",
+    "def execute_agent(agent, tools, input):\n",
+    "    tool_map = {tool.name: tool for tool in tools}\n",
+    "    response = agent.invoke(input)\n",
+    "    while not isinstance(response, AgentFinish):\n",
+    "        tool_outputs = []\n",
+    "        for action in response:\n",
+    "            tool_output = tool_map[action.tool].invoke(action.tool_input)\n",
+    "            print(action.tool, action.tool_input, tool_output, end=\"\\n\\n\")\n",
+    "            tool_outputs.append(\n",
+    "                {\"output\": tool_output, \"tool_call_id\": action.tool_call_id}\n",
+    "            )\n",
+    "        response = agent.invoke(\n",
+    "            {\n",
+    "                \"tool_outputs\": tool_outputs,\n",
+    "                \"run_id\": action.run_id,\n",
+    "                \"thread_id\": action.thread_id,\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "    return response"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7946116a-b82f-492e-835e-ca958a8949a5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "e2b_data_analysis {'python_code': 'print(10 - 4 ** 2.7)'} {\"stdout\": \"-32.22425314473263\", \"stderr\": \"\", \"artifacts\": []}\n",
+      "\n",
+      "\\( 10 - 4^{2.7} \\) is approximately \\(-32.22425314473263\\).\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = execute_agent(agent, tools, {\"content\": \"What's 10 - 4 raised to the 2.7\"})\n",
+    "print(response.return_values[\"output\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f2744a56-9f4f-4899-827a-fa55821c318c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "e2b_data_analysis {'python_code': 'result = 10 - 4 ** 2.7\\nprint(result + 17.241)'} {\"stdout\": \"-14.983253144732629\", \"stderr\": \"\", \"artifacts\": []}\n",
+      "\n",
+      "When you add \\( 17.241 \\) to \\( 10 - 4^{2.7} \\), the result is approximately \\( -14.98325314473263 \\).\n"
+     ]
+    }
+   ],
+   "source": [
+    "next_response = execute_agent(\n",
+    "    agent, tools, {\"content\": \"now add 17.241\", \"thread_id\": response.thread_id}\n",
+    ")\n",
+    "print(next_response.return_values[\"output\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71c34763-d1e7-4b9a-a9d7-3e4cc0dfc2c4",
+   "metadata": {},
+   "source": [
+    "## [JSON mode](https://platform.openai.com/docs/guides/text-generation/json-mode)\n",
+    "\n",
+    "Constrain the model to only generate valid JSON. Note that you must include a system message with instructions to use JSON for this mode to work.\n",
+    "\n",
+    "Only works with certain models. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "db6072c4-f3f3-415d-872b-71ea9f3c02bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat = ChatOpenAI(model=\"gpt-3.5-turbo-1106\").bind(\n",
+    "    response_format={\"type\": \"json_object\"}\n",
+    ")\n",
+    "\n",
+    "output = chat.invoke(\n",
+    "    [\n",
+    "        SystemMessage(\n",
+    "            content=\"Extract the 'name' and 'origin' of any companies mentioned in the following statement. Return a JSON list.\"\n",
+    "        ),\n",
+    "        HumanMessage(\n",
+    "            content=\"Google was founded in the USA, while Deepmind was founded in the UK\"\n",
+    "        ),\n",
+    "    ]\n",
+    ")\n",
+    "print(output.content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08e00ccf-b991-4249-846b-9500a0ccbfa0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "json.loads(output.content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa9a94d9-4319-4ab7-a979-c475ce6b5f50",
+   "metadata": {},
+   "source": [
+    "## [System fingerprint](https://platform.openai.com/docs/guides/text-generation/reproducible-outputs)\n",
+    "\n",
+    "OpenAI sometimes changes model configurations in a way that impacts outputs. Whenever this happens, the system_fingerprint associated with a generation will change."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1281883c-bf8f-4665-89cd-4f33ccde69ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat = ChatOpenAI(model=\"gpt-3.5-turbo-1106\")\n",
+    "output = chat.generate(\n",
+    "    [\n",
+    "        [\n",
+    "            SystemMessage(\n",
+    "                content=\"Extract the 'name' and 'origin' of any companies mentioned in the following statement. Return a JSON list.\"\n",
+    "            ),\n",
+    "            HumanMessage(\n",
+    "                content=\"Google was founded in the USA, while Deepmind was founded in the UK\"\n",
+    "            ),\n",
+    "        ]\n",
+    "    ]\n",
+    ")\n",
+    "print(output.llm_output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa6565be-985d-4127-848e-c3bca9d7b434",
+   "metadata": {},
+   "source": [
+    "## Breaking changes to Azure classes\n",
+    "\n",
+    "OpenAI V1 rewrote their clients and separated Azure and OpenAI clients. This has led to some changes in LangChain interfaces when using OpenAI V1.\n",
+    "\n",
+    "BREAKING CHANGES:\n",
+    "- To use Azure embeddings with OpenAI V1, you'll need to use the new `AzureOpenAIEmbeddings` instead of the existing `OpenAIEmbeddings`. `OpenAIEmbeddings` continue to work when using Azure with `openai<1`.\n",
+    "```python\n",
+    "from langchain.embeddings import AzureOpenAIEmbeddings\n",
+    "```\n",
+    "\n",
+    "\n",
+    "RECOMMENDED CHANGES:\n",
+    "- When using `AzureChatOpenAI` or `AzureOpenAI`, if passing in an Azure endpoint (eg https://example-resource.azure.openai.com/) this should be specified via the `azure_endpoint` parameter or the `AZURE_OPENAI_ENDPOINT`. We're maintaining backwards compatibility for now with specifying this via `openai_api_base`/`base_url` or env var `OPENAI_API_BASE` but this shouldn't be relied upon.\n",
+    "- When using Azure chat or embedding models, pass in API keys either via `openai_api_key` parameter or `AZURE_OPENAI_API_KEY` parameter. We're maintaining backwards compatibility for now with specifying this via `OPENAI_API_KEY` but this shouldn't be relied upon."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49944887-3972-497e-8da2-6d32d44345a9",
+   "metadata": {},
+   "source": [
+    "## Tools\n",
+    "\n",
+    "Use tools for parallel function calling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "916292d8-0f89-40a6-af1c-5a1122327de8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[GetCurrentWeather(location='New York, NY', unit='fahrenheit'),\n",
+       " GetCurrentWeather(location='Los Angeles, CA', unit='fahrenheit'),\n",
+       " GetCurrentWeather(location='San Francisco, CA', unit='fahrenheit')]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from typing import Literal\n",
+    "\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",
+    "\n",
+    "\n",
+    "class GetCurrentWeather(BaseModel):\n",
+    "    \"\"\"Get the current weather in a location.\"\"\"\n",
+    "\n",
+    "    location: str = Field(description=\"The city and state, e.g. San Francisco, CA\")\n",
+    "    unit: Literal[\"celsius\", \"fahrenheit\"] = Field(\n",
+    "        default=\"fahrenheit\", description=\"The temperature unit, default to fahrenheit\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", \"You are a helpful assistant\"), (\"user\", \"{input}\")]\n",
+    ")\n",
+    "model = ChatOpenAI(model=\"gpt-3.5-turbo-1106\").bind(\n",
+    "    tools=[convert_pydantic_to_openai_tool(GetCurrentWeather)]\n",
+    ")\n",
+    "chain = prompt | model | PydanticToolsParser(tools=[GetCurrentWeather])\n",
+    "\n",
+    "chain.invoke({\"input\": \"what's the weather in NYC, LA, and SF\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "poetry-venv",
+   "language": "python",
+   "name": "poetry-venv"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cookbook/petting_zoo.ipynb

@@ -45,14 +45,14 @@
    "source": [
     "import collections\n",
     "import inspect\n",
-    "import tenacity\n",
     "\n",
+    "import tenacity\n",
     "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.output_parsers import RegexParser\n",
     "from langchain.schema import (\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
-    ")\n",
-    "from langchain.output_parsers import RegexParser"
+    ")"
    ]
   },
   {
@@ -146,7 +146,7 @@
     "            ):\n",
     "                with attempt:\n",
     "                    action = self._act()\n",
-    "        except tenacity.RetryError as e:\n",
+    "        except tenacity.RetryError:\n",
     "            action = self.random_action()\n",
     "        return action"
    ]

cookbook/plan_and_execute_agent.ipynb

@@ -34,7 +34,11 @@
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.llms import OpenAI\n",
     "from langchain.utilities import DuckDuckGoSearchAPIWrapper\n",
-    "from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner"
+    "from langchain_experimental.plan_and_execute import (\n",
+    "    PlanAndExecute,\n",
+    "    load_agent_executor,\n",
+    "    load_chat_planner,\n",
+    ")"
    ]
   },
   {
@@ -56,16 +60,16 @@
     "llm = OpenAI(temperature=0)\n",
     "llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)\n",
     "tools = [\n",
-    " Tool(\n",
-    "     name=\"Search\",\n",
-    "     func=search.run,\n",
-    "     description=\"useful for when you need to answer questions about current events\"\n",
-    " ),\n",
-    " Tool(\n",
-    "     name=\"Calculator\",\n",
-    "     func=llm_math_chain.run,\n",
-    "     description=\"useful for when you need to answer questions about math\"\n",
-    " ),\n",
+    "    Tool(\n",
+    "        name=\"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events\",\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name=\"Calculator\",\n",
+    "        func=llm_math_chain.run,\n",
+    "        description=\"useful for when you need to answer questions about math\",\n",
+    "    ),\n",
     "]"
    ]
   },
@@ -216,7 +220,9 @@
     }
    ],
    "source": [
-    "agent.run(\"Who is the current prime minister of the UK? What is their current age raised to the 0.43 power?\")"
+    "agent.run(\n",
+    "    \"Who is the current prime minister of the UK? What is their current age raised to the 0.43 power?\"\n",
+    ")"
    ]
   },
   {

cookbook/press_releases.ipynb

@@ -55,6 +55,7 @@
    "source": [
     "# Setup API keys for Kay and OpenAI\n",
     "from getpass import getpass\n",
+    "\n",
     "KAY_API_KEY = getpass()\n",
     "OPENAI_API_KEY = getpass()"
    ]
@@ -67,6 +68,7 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "\n",
     "os.environ[\"KAY_API_KEY\"] = KAY_API_KEY\n",
     "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY"
    ]
@@ -83,7 +85,9 @@
     "from langchain.retrievers import KayAiRetriever\n",
     "\n",
     "model = ChatOpenAI(model_name=\"gpt-3.5-turbo\")\n",
-    "retriever = KayAiRetriever.create(dataset_id=\"company\", data_types=[\"PressRelease\"], num_contexts=6)\n",
+    "retriever = KayAiRetriever.create(\n",
+    "    dataset_id=\"company\", data_types=[\"PressRelease\"], num_contexts=6\n",
+    ")\n",
     "qa = ConversationalRetrievalChain.from_llm(model, retriever=retriever)"
    ]
   },
@@ -116,7 +120,7 @@
     "# More sample questions in the Playground on https://kay.ai\n",
     "questions = [\n",
     "    \"How is the healthcare industry adopting generative AI tools?\",\n",
-    "    #\"What are some recent challenges faced by the renewable energy sector?\",\n",
+    "    # \"What are some recent challenges faced by the renewable energy sector?\",\n",
     "]\n",
     "chat_history = []\n",
     "\n",

cookbook/program_aided_language_model.ipynb

@@ -17,8 +17,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_experimental.pal_chain import PALChain\n",
-    "from langchain.llms import OpenAI"
+    "from langchain.llms import OpenAI\n",
+    "from langchain_experimental.pal_chain import PALChain"
    ]
   },
   {

cookbook/qianfan_baidu_elasticesearch_RAG.ipynb

@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# RAG based on Qianfan and BES"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook is an implementation of Retrieval augmented generation (RAG) using Baidu Qianfan Platform combined with Baidu ElasricSearch, where the original data is located on BOS.\n",
+    "## Baidu Qianfan\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",
+    "## Baidu ElasticSearch\n",
+    "[Baidu Cloud VectorSearch](https://cloud.baidu.com/doc/BES/index.html?from=productToDoc) is a fully managed, enterprise-level distributed search and analysis service which is 100% compatible to open source. Baidu Cloud VectorSearch provides low-cost, high-performance, and reliable retrieval and analysis platform level product services for structured/unstructured data. As a vector database , it supports multiple index types and similarity distance methods. "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Installation and Setup\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!pip install qianfan\n",
+    "#!pip install bce-python-sdk\n",
+    "#!pip install elasticsearch == 7.11.0"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from baidubce.auth.bce_credentials import BceCredentials\n",
+    "from baidubce.bce_client_configuration import BceClientConfiguration\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",
+    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "from langchain.vectorstores import BESVectorStore"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Document loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bos_host = \"your bos eddpoint\"\n",
+    "access_key_id = \"your bos access ak\"\n",
+    "secret_access_key = \"your bos access sk\"\n",
+    "\n",
+    "# create BceClientConfiguration\n",
+    "config = BceClientConfiguration(\n",
+    "    credentials=BceCredentials(access_key_id, secret_access_key), endpoint=bos_host\n",
+    ")\n",
+    "\n",
+    "loader = BaiduBOSDirectoryLoader(conf=config, bucket=\"llm-test\", prefix=\"llm/\")\n",
+    "documents = loader.load()\n",
+    "\n",
+    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=0)\n",
+    "split_docs = text_splitter.split_documents(documents)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Embedding and VectorStore"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embeddings = HuggingFaceEmbeddings(model_name=\"shibing624/text2vec-base-chinese\")\n",
+    "embeddings.client = sentence_transformers.SentenceTransformer(embeddings.model_name)\n",
+    "\n",
+    "db = BESVectorStore.from_documents(\n",
+    "    documents=split_docs,\n",
+    "    embedding=embeddings,\n",
+    "    bes_url=\"your bes url\",\n",
+    "    index_name=\"test-index\",\n",
+    "    vector_query_field=\"vector\",\n",
+    ")\n",
+    "\n",
+    "db.client.indices.refresh(index=\"test-index\")\n",
+    "retriever = db.as_retriever()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## QA Retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = QianfanLLMEndpoint(\n",
+    "    model=\"ERNIE-Bot\",\n",
+    "    qianfan_ak=\"your qianfan ak\",\n",
+    "    qianfan_sk=\"your qianfan sk\",\n",
+    "    streaming=True,\n",
+    ")\n",
+    "qa = RetrievalQA.from_chain_type(\n",
+    "    llm=llm, chain_type=\"refine\", retriever=retriever, return_source_documents=True\n",
+    ")\n",
+    "\n",
+    "query = \"什么是张量?\"\n",
+    "print(qa.run(query))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> 张量（Tensor）是一个数学概念，用于表示多维数据。它是一个可以表示多个数值的数组，可以是标量、向量、矩阵等。在深度学习和人工智能领域中，张量常用于表示神经网络的输入、输出和权重等。"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.9.17"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cookbook/rag_fusion.ipynb

@@ -30,10 +30,10 @@
    "outputs": [],
    "source": [
     "import pinecone\n",
-    "from langchain.vectorstores import Pinecone\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import Pinecone\n",
     "\n",
-    "pinecone.init(api_key=\"...\",environment=\"...\")"
+    "pinecone.init(api_key=\"...\", environment=\"...\")"
    ]
   },
   {
@@ -53,7 +53,7 @@
     "    \"doc7\": \"Climate change: The science and models.\",\n",
     "    \"doc8\": \"Global warming: A subset of climate change.\",\n",
     "    \"doc9\": \"How climate change affects daily weather.\",\n",
-    "    \"doc10\": \"The history of climate change activism.\"\n",
+    "    \"doc10\": \"The history of climate change activism.\",\n",
     "}"
    ]
   },
@@ -64,7 +64,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "vectorstore = Pinecone.from_texts(list(all_documents.values()), OpenAIEmbeddings(), index_name='rag-fusion')"
+    "vectorstore = Pinecone.from_texts(\n",
+    "    list(all_documents.values()), OpenAIEmbeddings(), index_name=\"rag-fusion\"\n",
+    ")"
    ]
   },
   {
@@ -85,7 +87,6 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.prompts import ChatPromptTemplate\n",
     "from langchain.schema.output_parser import StrOutputParser"
    ]
   },
@@ -98,7 +99,7 @@
    "source": [
     "from langchain import hub\n",
     "\n",
-    "prompt = hub.pull('langchain-ai/rag-fusion-query-generation')"
+    "prompt = hub.pull(\"langchain-ai/rag-fusion-query-generation\")"
    ]
   },
   {
@@ -122,7 +123,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "generate_queries = prompt | ChatOpenAI(temperature=0) | StrOutputParser() | (lambda x: x.split(\"\\n\"))"
+    "generate_queries = (\n",
+    "    prompt | ChatOpenAI(temperature=0) | StrOutputParser() | (lambda x: x.split(\"\\n\"))\n",
+    ")"
    ]
   },
   {
@@ -171,6 +174,8 @@
    "outputs": [],
    "source": [
     "from langchain.load import dumps, loads\n",
+    "\n",
+    "\n",
     "def reciprocal_rank_fusion(results: list[list], k=60):\n",
     "    fused_scores = {}\n",
     "    for docs in results:\n",
@@ -181,9 +186,12 @@
     "                fused_scores[doc_str] = 0\n",
     "            previous_score = fused_scores[doc_str]\n",
     "            fused_scores[doc_str] += 1 / (rank + k)\n",
-    "            \n",
-    "    reranked_results = [(loads(doc), score) for doc, score in sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)]\n",
-    "    return reranked_results "
+    "\n",
+    "    reranked_results = [\n",
+    "        (loads(doc), score)\n",
+    "        for doc, score in sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)\n",
+    "    ]\n",
+    "    return reranked_results"
    ]
   },
   {

cookbook/retrieval_in_sql.ipynb

@@ -0,0 +1,689 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Incoporating semantic similarity in tabular databases\n",
+    "\n",
+    "In this notebook we will cover how to run semantic search over a specific table column within a single SQL query, combining tabular query with RAG.\n",
+    "\n",
+    "\n",
+    "### Overall workflow\n",
+    "\n",
+    "1. Generating embeddings for a specific column\n",
+    "2. Storing the embeddings in a new column (if column has low cardinality, it's better to use another table containing unique values and their embeddings)\n",
+    "3. Querying using standard SQL queries with [PGVector](https://github.com/pgvector/pgvector) extension which allows using L2 distance (`<->`), Cosine distance (`<=>` or cosine similarity using `1 - <=>`) and Inner product (`<#>`)\n",
+    "4. Running standard SQL query\n",
+    "\n",
+    "### Requirements\n",
+    "\n",
+    "We will need a PostgreSQL database with [pgvector](https://github.com/pgvector/pgvector) extension enabled. For this example, we will use a `Chinook` database using a local PostgreSQL server."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = os.environ.get(\"OPENAI_API_KEY\") or getpass.getpass(\n",
+    "    \"OpenAI API Key:\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.sql_database import SQLDatabase\n",
+    "\n",
+    "CONNECTION_STRING = \"postgresql+psycopg2://postgres:test@localhost:5432/vectordb\"  # Replace with your own\n",
+    "db = SQLDatabase.from_uri(CONNECTION_STRING)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Embedding the song titles"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For this example, we will run queries based on semantic meaning of song titles. In order to do this, let's start by adding a new column in the table for storing the embeddings:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# db.run('ALTER TABLE \"Track\" ADD COLUMN \"embeddings\" vector;')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's generate the embedding for each *track title* and store it as a new column in our \"Track\" table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "\n",
+    "embeddings_model = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3503"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tracks = db.run('SELECT \"Name\" FROM \"Track\"')\n",
+    "song_titles = [s[0] for s in eval(tracks)]\n",
+    "title_embeddings = embeddings_model.embed_documents(song_titles)\n",
+    "len(title_embeddings)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's insert the embeddings in the into the new column from our table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tqdm import tqdm\n",
+    "\n",
+    "for i in tqdm(range(len(title_embeddings))):\n",
+    "    title = titles[i].replace(\"'\", \"''\")\n",
+    "    embedding = title_embeddings[i]\n",
+    "    sql_command = (\n",
+    "        f'UPDATE \"Track\" SET \"embeddings\" = ARRAY{embedding} WHERE \"Name\" ='\n",
+    "        + f\"'{title}'\"\n",
+    "    )\n",
+    "    db.run(sql_command)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can test the semantic search running the following query:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'[(\"Tomorrow\\'s Dream\",), (\\'Remember Tomorrow\\',), (\\'Remember Tomorrow\\',), (\\'The Best Is Yet To Come\\',), (\"Thinking \\'Bout Tomorrow\",)]'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "embeded_title = embeddings_model.embed_query(\"hope about the future\")\n",
+    "query = (\n",
+    "    'SELECT \"Track\".\"Name\" FROM \"Track\" WHERE \"Track\".\"embeddings\" IS NOT NULL ORDER BY \"embeddings\" <-> '\n",
+    "    + f\"'{embeded_title}' LIMIT 5\"\n",
+    ")\n",
+    "db.run(query)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating the SQL Chain"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start by defining useful functions to get info from database and running the query:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_schema(_):\n",
+    "    return db.get_table_info()\n",
+    "\n",
+    "\n",
+    "def run_query(query):\n",
+    "    return db.run(query)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's build the **prompt** we will use. This prompt is an extension from [text-to-postgres-sql](https://smith.langchain.com/hub/jacob/text-to-postgres-sql?organizationId=f9b614b8-5c3a-4e7c-afbc-6d7ad4fd8892) prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "\n",
+    "template = \"\"\"You are a Postgres expert. Given an input question, first create a syntactically correct Postgres query to run, then look at the results of the query and return the answer to the input question.\n",
+    "Unless the user specifies in the question a specific number of examples to obtain, query for at most 5 results using the LIMIT clause as per Postgres. You can order the results to return the most informative data in the database.\n",
+    "Never query for all columns from a table. You must query only the columns that are needed to answer the question. Wrap each column name in double quotes (\") to denote them as delimited identifiers.\n",
+    "Pay attention to use only the column names you can see in the tables below. Be careful to not query for columns that do not exist. Also, pay attention to which column is in which table.\n",
+    "Pay attention to use date('now') function to get the current date, if the question involves \"today\".\n",
+    "\n",
+    "You can use an extra extension which allows you to run semantic similarity using <-> operator on tables containing columns named \"embeddings\".\n",
+    "<-> operator can ONLY be used on embeddings columns.\n",
+    "The embeddings value for a given row typically represents the semantic meaning of that row.\n",
+    "The vector represents an embedding representation of the question, given below. \n",
+    "Do NOT fill in the vector values directly, but rather specify a `[search_word]` placeholder, which should contain the word that would be embedded for filtering.\n",
+    "For example, if the user asks for songs about 'the feeling of loneliness' the query could be:\n",
+    "'SELECT \"[whatever_table_name]\".\"SongName\" FROM \"[whatever_table_name]\" ORDER BY \"embeddings\" <-> '[loneliness]' LIMIT 5'\n",
+    "\n",
+    "Use the following format:\n",
+    "\n",
+    "Question: <Question here>\n",
+    "SQLQuery: <SQL Query to run>\n",
+    "SQLResult: <Result of the SQLQuery>\n",
+    "Answer: <Final answer here>\n",
+    "\n",
+    "Only use the following tables:\n",
+    "\n",
+    "{schema}\n",
+    "\"\"\"\n",
+    "\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", template), (\"human\", \"{question}\")]\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can create the chain using **[LangChain Expression Language](https://python.langchain.com/docs/expression_language/)**:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\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",
+    ")  # We reconnect to db so the new columns are loaded as well.\n",
+    "llm = ChatOpenAI(model_name=\"gpt-4\", temperature=0)\n",
+    "\n",
+    "sql_query_chain = (\n",
+    "    RunnablePassthrough.assign(schema=get_schema)\n",
+    "    | prompt\n",
+    "    | llm.bind(stop=[\"\\nSQLResult:\"])\n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'SQLQuery: SELECT \"Track\".\"Name\" FROM \"Track\" JOIN \"Genre\" ON \"Track\".\"GenreId\" = \"Genre\".\"GenreId\" WHERE \"Genre\".\"Name\" = \\'Rock\\' ORDER BY \"Track\".\"embeddings\" <-> \\'[dispair]\\' LIMIT 5'"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sql_query_chain.invoke(\n",
+    "    {\n",
+    "        \"question\": \"Which are the 5 rock songs with titles about deep feeling of dispair?\"\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This chain simply generates the query. Now we will create the full chain that also handles the execution and the final result for the user:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "\n",
+    "from langchain.schema.runnable import RunnableLambda\n",
+    "\n",
+    "\n",
+    "def replace_brackets(match):\n",
+    "    words_inside_brackets = match.group(1).split(\", \")\n",
+    "    embedded_words = [\n",
+    "        str(embeddings_model.embed_query(word)) for word in words_inside_brackets\n",
+    "    ]\n",
+    "    return \"', '\".join(embedded_words)\n",
+    "\n",
+    "\n",
+    "def get_query(query):\n",
+    "    sql_query = re.sub(r\"\\[([\\w\\s,]+)\\]\", replace_brackets, query)\n",
+    "    return sql_query\n",
+    "\n",
+    "\n",
+    "template = \"\"\"Based on the table schema below, question, sql query, and sql response, write a natural language response:\n",
+    "{schema}\n",
+    "\n",
+    "Question: {question}\n",
+    "SQL Query: {query}\n",
+    "SQL Response: {response}\"\"\"\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", template), (\"human\", \"{question}\")]\n",
+    ")\n",
+    "\n",
+    "full_chain = (\n",
+    "    RunnablePassthrough.assign(query=sql_query_chain)\n",
+    "    | RunnablePassthrough.assign(\n",
+    "        schema=get_schema,\n",
+    "        response=RunnableLambda(lambda x: db.run(get_query(x[\"query\"]))),\n",
+    "    )\n",
+    "    | prompt\n",
+    "    | llm\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using the Chain"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Example 1: Filtering a column based on semantic meaning"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's say we want to retrieve songs that express `deep feeling of dispair`, but filtering based on genre:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"The 5 rock songs with titles that convey a deep feeling of despair are 'Sea Of Sorrow', 'Surrender', 'Indifference', 'Hard Luck Woman', and 'Desire'.\")"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke(\n",
+    "    {\n",
+    "        \"question\": \"Which are the 5 rock songs with titles about deep feeling of dispair?\"\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What is substantially different in implementing this method is that we have combined:\n",
+    "- Semantic search (songs that have titles with some semantic meaning)\n",
+    "- Traditional tabular querying (running JOIN statements to filter track based on genre)\n",
+    "\n",
+    "This is something we _could_ potentially achieve using metadata filtering, but it's more complex to do so (we would need to use a vector database containing the embeddings, and use metadata filtering based on genre).\n",
+    "\n",
+    "However, for other use cases metadata filtering **wouldn't be enough**."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Example 2: Combining filters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"The three albums which have the most amount of songs in the top 150 saddest songs are 'International Superhits' with 5 songs, 'Ten' with 4 songs, and 'Album Of The Year' with 3 songs.\")"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke(\n",
+    "    {\n",
+    "        \"question\": \"I want to know the 3 albums which have the most amount of songs in the top 150 saddest songs\"\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So we have result for 3 albums with most amount of songs in top 150 saddest ones. This **wouldn't** be possible using only standard metadata filtering. Without this _hybdrid query_, we would need some postprocessing to get the result.\n",
+    "\n",
+    "Another similar exmaple:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"The 6 albums with the shortest titles that contain songs which are in the 20 saddest song list are 'Ten', 'Core', 'Big Ones', 'One By One', 'Black Album', and 'Miles Ahead'.\")"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke(\n",
+    "    {\n",
+    "        \"question\": \"I need the 6 albums with shortest title, as long as they contain songs which are in the 20 saddest song list.\"\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's see what the query looks like to double check:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WITH \"SadSongs\" AS (\n",
+      "    SELECT \"TrackId\" FROM \"Track\" \n",
+      "    ORDER BY \"embeddings\" <-> '[sad]' LIMIT 20\n",
+      "),\n",
+      "\"SadAlbums\" AS (\n",
+      "    SELECT DISTINCT \"AlbumId\" FROM \"Track\" \n",
+      "    WHERE \"TrackId\" IN (SELECT \"TrackId\" FROM \"SadSongs\")\n",
+      ")\n",
+      "SELECT \"Album\".\"Title\" FROM \"Album\" \n",
+      "WHERE \"AlbumId\" IN (SELECT \"AlbumId\" FROM \"SadAlbums\") \n",
+      "ORDER BY \"title_len\" ASC \n",
+      "LIMIT 6\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\n",
+    "    sql_query_chain.invoke(\n",
+    "        {\n",
+    "            \"question\": \"I need the 6 albums with shortest title, as long as they contain songs which are in the 20 saddest song list.\"\n",
+    "        }\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Example 3: Combining two separate semantic searches\n",
+    "\n",
+    "One interesting aspect of this approach which is **substantially different from using standar RAG** is that we can even **combine** two semantic search filters:\n",
+    "- _Get 5 saddest songs..._\n",
+    "- _**...obtained from albums with \"lovely\" titles**_\n",
+    "\n",
+    "This could generalize to **any kind of combined RAG** (paragraphs discussing _X_ topic belonging from books about _Y_, replies to a tweet about _ABC_ topic that express _XYZ_ feeling)\n",
+    "\n",
+    "We will combine semantic search on songs and album titles, so we need to do the same for `Album` table:\n",
+    "1. Generate the embeddings\n",
+    "2. Add them to the table as a new column (which we need to add in the table)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# db.run('ALTER TABLE \"Album\" ADD COLUMN \"embeddings\" vector;')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 347/347 [00:01<00:00, 179.64it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "albums = db.run('SELECT \"Title\" FROM \"Album\"')\n",
+    "album_titles = [title[0] for title in eval(albums)]\n",
+    "album_title_embeddings = embeddings_model.embed_documents(album_titles)\n",
+    "for i in tqdm(range(len(album_title_embeddings))):\n",
+    "    album_title = album_titles[i].replace(\"'\", \"''\")\n",
+    "    album_embedding = album_title_embeddings[i]\n",
+    "    sql_command = (\n",
+    "        f'UPDATE \"Album\" SET \"embeddings\" = ARRAY{album_embedding} WHERE \"Title\" ='\n",
+    "        + f\"'{album_title}'\"\n",
+    "    )\n",
+    "    db.run(sql_command)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"[('Realize',), ('Morning Dance',), ('Into The Light',), ('New Adventures In Hi-Fi',), ('Miles Ahead',)]\""
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "embeded_title = embeddings_model.embed_query(\"hope about the future\")\n",
+    "query = (\n",
+    "    'SELECT \"Album\".\"Title\" FROM \"Album\" WHERE \"Album\".\"embeddings\" IS NOT NULL ORDER BY \"embeddings\" <-> '\n",
+    "    + f\"'{embeded_title}' LIMIT 5\"\n",
+    ")\n",
+    "db.run(query)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can combine both filters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db = SQLDatabase.from_uri(\n",
+    "    CONNECTION_STRING\n",
+    ")  # We reconnect to dbso the new columns are loaded as well."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='The songs about breakouts obtained from the top 5 albums about love are \\'Royal Orleans\\', \"Nobody\\'s Fault But Mine\", \\'Achilles Last Stand\\', \\'For Your Life\\', and \\'Hots On For Nowhere\\'.')"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke(\n",
+    "    {\n",
+    "        \"question\": \"I want to know songs about breakouts obtained from top 5 albums about love\"\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is something **different** that **couldn't be achieved** using standard metadata filtering over a vectordb."
+   ]
+  }
+ ],
+ "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.8.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cookbook/rewrite.ipynb

@@ -31,12 +31,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from operator import itemgetter\n",
-    "\n",
-    "from langchain.prompts import ChatPromptTemplate\n",
     "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
     "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnablePassthrough, RunnableLambda\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
     "from langchain.utilities import DuckDuckGoSearchAPIWrapper"
    ]
   },
@@ -74,9 +72,9 @@
    "outputs": [],
    "source": [
     "chain = (\n",
-    "    {\"context\": retriever, \"question\": RunnablePassthrough()} \n",
-    "    | prompt \n",
-    "    | model \n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    "    | prompt\n",
+    "    | model\n",
     "    | StrOutputParser()\n",
     ")"
    ]
@@ -245,6 +243,7 @@
    "source": [
     "# Parser to remove the `**`\n",
     "\n",
+    "\n",
     "def _parse(text):\n",
     "    return text.strip(\"**\")"
    ]
@@ -290,9 +289,10 @@
     "rewrite_retrieve_read_chain = (\n",
     "    {\n",
     "        \"context\": {\"x\": RunnablePassthrough()} | rewriter | retriever,\n",
-    "        \"question\": RunnablePassthrough()} \n",
-    "    | prompt \n",
-    "    | model \n",
+    "        \"question\": RunnablePassthrough(),\n",
+    "    }\n",
+    "    | prompt\n",
+    "    | model\n",
     "    | StrOutputParser()\n",
     ")"
    ]

cookbook/sales_agent_with_context.ipynb

@@ -42,22 +42,22 @@
     "OPENAI_API_KEY = \"sk-xx\"\n",
     "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY\n",
     "\n",
-    "from typing import Dict, List, Any, Union, Callable\n",
-    "from pydantic import BaseModel, Field\n",
-    "from langchain.chains import LLMChain\nfrom langchain.prompts import PromptTemplate\n",
-    "from langchain.llms import BaseLLM\n",
-    "from langchain.chains.base import Chain\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.agents import Tool, LLMSingleActionAgent, AgentExecutor\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.chains import RetrievalQA\n",
-    "from langchain.vectorstores import Chroma\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.prompts.base import StringPromptTemplate\n",
+    "from typing import Any, Callable, Dict, List, Union\n",
+    "\n",
+    "from langchain.agents import AgentExecutor, LLMSingleActionAgent, Tool\n",
     "from langchain.agents.agent import AgentOutputParser\n",
     "from langchain.agents.conversational.prompt import FORMAT_INSTRUCTIONS\n",
-    "from langchain.schema import AgentAction, AgentFinish"
+    "from langchain.chains import LLMChain, RetrievalQA\n",
+    "from langchain.chains.base import Chain\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.llms import BaseLLM, OpenAI\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.prompts.base import StringPromptTemplate\n",
+    "from langchain.schema import AgentAction, AgentFinish\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from pydantic import BaseModel, Field"
    ]
   },
   {

cookbook/selecting_llms_based_on_context_length.ipynb

@@ -0,0 +1,175 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e93283d1",
+   "metadata": {},
+   "source": [
+    "# Selecting LLMs based on Context Length\n",
+    "\n",
+    "Different LLMs have different context lengths. As a very immediate an practical example, OpenAI has two versions of GPT-3.5-Turbo: one with 4k context, another with 16k context. This notebook shows how to route between them based on input."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "cc453450",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.prompt import PromptValue"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1cec6a10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "short_context_model = ChatOpenAI(model=\"gpt-3.5-turbo\")\n",
+    "long_context_model = ChatOpenAI(model=\"gpt-3.5-turbo-16k\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "772da153",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_context_length(prompt: PromptValue):\n",
+    "    messages = prompt.to_messages()\n",
+    "    tokens = short_context_model.get_num_tokens_from_messages(messages)\n",
+    "    return tokens"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "db771e20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = PromptTemplate.from_template(\"Summarize this passage: {context}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "af057e2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def choose_model(prompt: PromptValue):\n",
+    "    context_len = get_context_length(prompt)\n",
+    "    if context_len < 30:\n",
+    "        print(\"short model\")\n",
+    "        return short_context_model\n",
+    "    else:\n",
+    "        print(\"long model\")\n",
+    "        return long_context_model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "84f3e07d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = prompt | choose_model | StrOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "d8b14f8f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "short model\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The passage mentions that a frog visited a pond.'"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"context\": \"a frog went to a pond\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "70ebd3dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "long model\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The passage describes a frog that moved from one pond to another and perched on a log.'"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\n",
+    "    {\"context\": \"a frog went to a pond and sat on a log and went to a different pond\"}\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7e29fef",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cookbook/self_query_hotel_search.ipynb

@@ -7,9 +7,33 @@
    "source": [
     "# Building hotel room search with self-querying retrieval\n",
     "\n",
+    "In this example we'll walk through how to build and iterate on a hotel room search service that leverages an LLM to generate structured filter queries that can then be passed to a vector store.\n",
+    "\n",
+    "For an introduction to self-querying retrieval [check out the docs](https://python.langchain.com/docs/modules/data_connection/retrievers/self_query)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d621de99-d993-4f4b-b94a-d02b2c7ad4e0",
+   "metadata": {},
+   "source": [
+    "## Imports and data prep\n",
+    "\n",
+    "In this example we use `ChatOpenAI` for the model and `ElasticsearchStore` for the vector store, but these can be swapped out with an LLM/ChatModel and [any VectorStore that support self-querying](https://python.langchain.com/docs/integrations/retrievers/self_query/).\n",
+    "\n",
     "Download data from: https://www.kaggle.com/datasets/keshavramaiah/hotel-recommendation"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8ecd1fbb-bdba-420b-bcc7-5ea8a232ab11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install langchain lark openai elasticsearch pandas"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -27,8 +51,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "details = pd.read_csv(\"~/Downloads/archive/Hotel_details.csv\").drop_duplicates(subset=\"hotelid\").set_index(\"hotelid\")\n",
-    "attributes = pd.read_csv(\"~/Downloads/archive/Hotel_Room_attributes.csv\", index_col=\"id\")\n",
+    "details = (\n",
+    "    pd.read_csv(\"~/Downloads/archive/Hotel_details.csv\")\n",
+    "    .drop_duplicates(subset=\"hotelid\")\n",
+    "    .set_index(\"hotelid\")\n",
+    ")\n",
+    "attributes = pd.read_csv(\n",
+    "    \"~/Downloads/archive/Hotel_Room_attributes.csv\", index_col=\"id\"\n",
+    ")\n",
     "price = pd.read_csv(\"~/Downloads/archive/hotels_RoomPrice.csv\", index_col=\"id\")"
    ]
   },
@@ -184,9 +214,20 @@
     }
    ],
    "source": [
-    "latest_price = price.drop_duplicates(subset=\"refid\", keep=\"last\")[[\"hotelcode\", \"roomtype\", \"onsiterate\", \"roomamenities\", \"maxoccupancy\", \"mealinclusiontype\"]]\n",
+    "latest_price = price.drop_duplicates(subset=\"refid\", keep=\"last\")[\n",
+    "    [\n",
+    "        \"hotelcode\",\n",
+    "        \"roomtype\",\n",
+    "        \"onsiterate\",\n",
+    "        \"roomamenities\",\n",
+    "        \"maxoccupancy\",\n",
+    "        \"mealinclusiontype\",\n",
+    "    ]\n",
+    "]\n",
     "latest_price[\"ratedescription\"] = attributes.loc[latest_price.index][\"ratedescription\"]\n",
-    "latest_price = latest_price.join(details[[\"hotelname\", \"city\", \"country\", \"starrating\"]], on=\"hotelcode\")\n",
+    "latest_price = latest_price.join(\n",
+    "    details[[\"hotelname\", \"city\", \"country\", \"starrating\"]], on=\"hotelcode\"\n",
+    ")\n",
     "latest_price = latest_price.rename({\"ratedescription\": \"roomdescription\"}, axis=1)\n",
     "latest_price[\"mealsincluded\"] = ~latest_price[\"mealinclusiontype\"].isnull()\n",
     "latest_price.pop(\"hotelcode\")\n",
@@ -220,7 +261,7 @@
     "res = model.predict(\n",
     "    \"Below is a table with information about hotel rooms. \"\n",
     "    \"Return a JSON list with an entry for each column. Each entry should have \"\n",
-    "    \"{\\\"name\\\": \\\"column name\\\", \\\"description\\\": \\\"column description\\\", \\\"type\\\": \\\"column data type\\\"}\"\n",
+    "    '{\"name\": \"column name\", \"description\": \"column description\", \"type\": \"column data type\"}'\n",
     "    f\"\\n\\n{latest_price.head()}\\n\\nJSON:\\n\"\n",
     ")"
    ]
@@ -314,9 +355,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "attribute_info[-2]['description'] += f\". Valid values are {sorted(latest_price['starrating'].value_counts().index.tolist())}\"\n",
-    "attribute_info[3]['description'] += f\". Valid values are {sorted(latest_price['maxoccupancy'].value_counts().index.tolist())}\"\n",
-    "attribute_info[-3]['description'] += f\". Valid values are {sorted(latest_price['country'].value_counts().index.tolist())}\""
+    "attribute_info[-2][\n",
+    "    \"description\"\n",
+    "] += f\". Valid values are {sorted(latest_price['starrating'].value_counts().index.tolist())}\"\n",
+    "attribute_info[3][\n",
+    "    \"description\"\n",
+    "] += f\". Valid values are {sorted(latest_price['maxoccupancy'].value_counts().index.tolist())}\"\n",
+    "attribute_info[-3][\n",
+    "    \"description\"\n",
+    "] += f\". Valid values are {sorted(latest_price['country'].value_counts().index.tolist())}\""
    ]
   },
   {
@@ -384,7 +431,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains.query_constructor.base import get_query_constructor_prompt, load_query_constructor_runnable"
+    "from langchain.chains.query_constructor.base import (\n",
+    "    get_query_constructor_prompt,\n",
+    "    load_query_constructor_runnable,\n",
+    ")"
    ]
   },
   {
@@ -568,7 +618,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "chain = load_query_constructor_runnable(ChatOpenAI(model='gpt-3.5-turbo', temperature=0), doc_contents, attribute_info)"
+    "chain = load_query_constructor_runnable(\n",
+    "    ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0), doc_contents, attribute_info\n",
+    ")"
    ]
   },
   {
@@ -610,7 +662,11 @@
     }
    ],
    "source": [
-    "chain.invoke({\"query\": \"Find a 2-person room in Vienna or London, preferably with meals included and AC\"})"
+    "chain.invoke(\n",
+    "    {\n",
+    "        \"query\": \"Find a 2-person room in Vienna or London, preferably with meals included and AC\"\n",
+    "    }\n",
+    ")"
    ]
   },
   {
@@ -632,10 +688,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "attribute_info[-3]['description'] += \". NOTE: Only use the 'eq' operator if a specific country is mentioned. If a region is mentioned, include all relevant countries in filter.\"\n",
+    "attribute_info[-3][\n",
+    "    \"description\"\n",
+    "] += \". NOTE: Only use the 'eq' operator if a specific country is mentioned. If a region is mentioned, include all relevant countries in filter.\"\n",
     "chain = load_query_constructor_runnable(\n",
-    "    ChatOpenAI(model='gpt-3.5-turbo', temperature=0), \n",
-    "    doc_contents, \n",
+    "    ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0),\n",
+    "    doc_contents,\n",
     "    attribute_info,\n",
     ")"
    ]
@@ -680,10 +738,12 @@
    "source": [
     "content_attr = [\"roomtype\", \"roomamenities\", \"roomdescription\", \"hotelname\"]\n",
     "doc_contents = \"A detailed description of a hotel room, including information about the room type and room amenities.\"\n",
-    "filter_attribute_info = tuple(ai for ai in attribute_info if ai[\"name\"] not in content_attr)\n",
+    "filter_attribute_info = tuple(\n",
+    "    ai for ai in attribute_info if ai[\"name\"] not in content_attr\n",
+    ")\n",
     "chain = load_query_constructor_runnable(\n",
-    "    ChatOpenAI(model='gpt-3.5-turbo', temperature=0), \n",
-    "    doc_contents, \n",
+    "    ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0),\n",
+    "    doc_contents,\n",
     "    filter_attribute_info,\n",
     ")"
    ]
@@ -706,7 +766,11 @@
     }
    ],
    "source": [
-    "chain.invoke({\"query\": \"Find a 2-person room in Vienna or London, preferably with meals included and AC\"})"
+    "chain.invoke(\n",
+    "    {\n",
+    "        \"query\": \"Find a 2-person room in Vienna or London, preferably with meals included and AC\"\n",
+    "    }\n",
+    ")"
    ]
   },
   {
@@ -836,14 +900,22 @@
     "examples = [\n",
     "    (\n",
     "        \"I want a hotel in the Balkans with a king sized bed and a hot tub. Budget is $300 a night\",\n",
-    "        {\"query\": \"king-sized bed, hot tub\", \"filter\": 'and(in(\"country\", [\"Bulgaria\", \"Greece\", \"Croatia\", \"Serbia\"]), lte(\"onsiterate\", 300))'}\n",
+    "        {\n",
+    "            \"query\": \"king-sized bed, hot tub\",\n",
+    "            \"filter\": 'and(in(\"country\", [\"Bulgaria\", \"Greece\", \"Croatia\", \"Serbia\"]), lte(\"onsiterate\", 300))',\n",
+    "        },\n",
     "    ),\n",
     "    (\n",
     "        \"A room with breakfast included for 3 people, at a Hilton\",\n",
-    "        {\"query\": \"Hilton\", \"filter\": 'and(eq(\"mealsincluded\", true), gte(\"maxoccupancy\", 3))'}\n",
+    "        {\n",
+    "            \"query\": \"Hilton\",\n",
+    "            \"filter\": 'and(eq(\"mealsincluded\", true), gte(\"maxoccupancy\", 3))',\n",
+    "        },\n",
     "    ),\n",
     "]\n",
-    "prompt = get_query_constructor_prompt(doc_contents, filter_attribute_info, examples=examples)\n",
+    "prompt = get_query_constructor_prompt(\n",
+    "    doc_contents, filter_attribute_info, examples=examples\n",
+    ")\n",
     "print(prompt.format(query=\"{query}\"))"
    ]
   },
@@ -855,10 +927,10 @@
    "outputs": [],
    "source": [
     "chain = load_query_constructor_runnable(\n",
-    "    ChatOpenAI(model='gpt-3.5-turbo', temperature=0), \n",
-    "    doc_contents, \n",
+    "    ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0),\n",
+    "    doc_contents,\n",
     "    filter_attribute_info,\n",
-    "    examples=examples\n",
+    "    examples=examples,\n",
     ")"
    ]
   },
@@ -880,7 +952,11 @@
     }
    ],
    "source": [
-    "chain.invoke({\"query\": \"Find a 2-person room in Vienna or London, preferably with meals included and AC\"})"
+    "chain.invoke(\n",
+    "    {\n",
+    "        \"query\": \"Find a 2-person room in Vienna or London, preferably with meals included and AC\"\n",
+    "    }\n",
+    ")"
    ]
   },
   {
@@ -932,7 +1008,11 @@
     }
    ],
    "source": [
-    "chain.invoke({\"query\": \"I want to stay somewhere highly rated along the coast. I want a room with a patio and a fireplace.\"})"
+    "chain.invoke(\n",
+    "    {\n",
+    "        \"query\": \"I want to stay somewhere highly rated along the coast. I want a room with a patio and a fireplace.\"\n",
+    "    }\n",
+    ")"
    ]
   },
   {
@@ -953,11 +1033,11 @@
    "outputs": [],
    "source": [
     "chain = load_query_constructor_runnable(\n",
-    "    ChatOpenAI(model='gpt-3.5-turbo', temperature=0), \n",
-    "    doc_contents, \n",
+    "    ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0),\n",
+    "    doc_contents,\n",
     "    filter_attribute_info,\n",
     "    examples=examples,\n",
-    "    fix_invalid=True\n",
+    "    fix_invalid=True,\n",
     ")"
    ]
   },
@@ -979,7 +1059,11 @@
     }
    ],
    "source": [
-    "chain.invoke({\"query\": \"I want to stay somewhere highly rated along the coast. I want a room with a patio and a fireplace.\"})"
+    "chain.invoke(\n",
+    "    {\n",
+    "        \"query\": \"I want to stay somewhere highly rated along the coast. I want a room with a patio and a fireplace.\"\n",
+    "    }\n",
+    ")"
    ]
   },
   {
@@ -1000,7 +1084,6 @@
    "outputs": [],
    "source": [
     "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.schema import Document\n",
     "from langchain.vectorstores import ElasticsearchStore\n",
     "\n",
     "embeddings = OpenAIEmbeddings()"
@@ -1032,8 +1115,8 @@
     "#     docs.append(doc)\n",
     "# vecstore = ElasticsearchStore.from_documents(\n",
     "#     docs,\n",
-    "#     embeddings, \n",
-    "#     es_url=\"http://localhost:9200\", \n",
+    "#     embeddings,\n",
+    "#     es_url=\"http://localhost:9200\",\n",
     "#     index_name=\"hotel_rooms\",\n",
     "#     # strategy=ElasticsearchStore.ApproxRetrievalStrategy(\n",
     "#     #     hybrid=True,\n",
@@ -1049,9 +1132,9 @@
    "outputs": [],
    "source": [
     "vecstore = ElasticsearchStore(\n",
-    "    \"hotel_rooms\", \n",
-    "    embedding=embeddings, \n",
-    "    es_url=\"http://localhost:9200\", \n",
+    "    \"hotel_rooms\",\n",
+    "    embedding=embeddings,\n",
+    "    es_url=\"http://localhost:9200\",\n",
     "    # strategy=ElasticsearchStore.ApproxRetrievalStrategy(hybrid=True) # seems to not be available in community version\n",
     ")"
    ]
@@ -1065,7 +1148,9 @@
    "source": [
     "from langchain.retrievers import SelfQueryRetriever\n",
     "\n",
-    "retriever = SelfQueryRetriever(query_constructor=chain, vectorstore=vecstore, verbose=True)"
+    "retriever = SelfQueryRetriever(\n",
+    "    query_constructor=chain, vectorstore=vecstore, verbose=True\n",
+    ")"
    ]
   },
   {
@@ -1142,7 +1227,9 @@
     }
    ],
    "source": [
-    "results = retriever.get_relevant_documents(\"I want to stay somewhere highly rated along the coast. I want a room with a patio and a fireplace.\")\n",
+    "results = retriever.get_relevant_documents(\n",
+    "    \"I want to stay somewhere highly rated along the coast. I want a room with a patio and a fireplace.\"\n",
+    ")\n",
     "for res in results:\n",
     "    print(res.page_content)\n",
     "    print(\"\\n\" + \"-\" * 20 + \"\\n\")"

cookbook/smart_llm.ipynb

@@ -51,8 +51,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import PromptTemplate\n",
     "from langchain_experimental.smart_llm import SmartLLMChain"
    ]
   },

cookbook/stepback-qa.ipynb

@@ -40,11 +40,11 @@
     "examples = [\n",
     "    {\n",
     "        \"input\": \"Could the members of The Police perform lawful arrests?\",\n",
-    "        \"output\": \"what can the members of The Police do?\"\n",
+    "        \"output\": \"what can the members of The Police do?\",\n",
     "    },\n",
     "    {\n",
-    "        \"input\": \"Jan Sindel’s was born in what country?\", \n",
-    "        \"output\": \"what is Jan Sindel’s personal history?\"\n",
+    "        \"input\": \"Jan Sindel’s was born in what country?\",\n",
+    "        \"output\": \"what is Jan Sindel’s personal history?\",\n",
     "    },\n",
     "]\n",
     "# We now transform these to example messages\n",
@@ -67,13 +67,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "prompt = ChatPromptTemplate.from_messages([\n",
-    "    (\"system\", \"\"\"You are an expert at world knowledge. Your task is to step back and paraphrase a question to a more generic step-back question, which is easier to answer. Here are a few examples:\"\"\"),\n",
-    "    # Few shot examples\n",
-    "    few_shot_prompt,\n",
-    "    # New question\n",
-    "    (\"user\", \"{question}\"),\n",
-    "])"
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\n",
+    "            \"system\",\n",
+    "            \"\"\"You are an expert at world knowledge. Your task is to step back and paraphrase a question to a more generic step-back question, which is easier to answer. Here are a few examples:\"\"\",\n",
+    "        ),\n",
+    "        # Few shot examples\n",
+    "        few_shot_prompt,\n",
+    "        # New question\n",
+    "        (\"user\", \"{question}\"),\n",
+    "    ]\n",
+    ")"
    ]
   },
   {
@@ -126,9 +131,9 @@
    "source": [
     "from langchain.utilities import DuckDuckGoSearchAPIWrapper\n",
     "\n",
-    "\n",
     "search = DuckDuckGoSearchAPIWrapper(max_results=4)\n",
     "\n",
+    "\n",
     "def retriever(query):\n",
     "    return search.run(query)"
    ]
@@ -211,14 +216,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "chain = {\n",
-    "    # Retrieve context using the normal question\n",
-    "    \"normal_context\": RunnableLambda(lambda x: x['question']) | retriever,\n",
-    "    # Retrieve context using the step-back question\n",
-    "    \"step_back_context\": question_gen | retriever,\n",
-    "    # Pass on the question\n",
-    "    \"question\": lambda x: x[\"question\"]\n",
-    "} | response_prompt | ChatOpenAI(temperature=0) | StrOutputParser()"
+    "chain = (\n",
+    "    {\n",
+    "        # Retrieve context using the normal question\n",
+    "        \"normal_context\": RunnableLambda(lambda x: x[\"question\"]) | retriever,\n",
+    "        # Retrieve context using the step-back question\n",
+    "        \"step_back_context\": question_gen | retriever,\n",
+    "        # Pass on the question\n",
+    "        \"question\": lambda x: x[\"question\"],\n",
+    "    }\n",
+    "    | response_prompt\n",
+    "    | ChatOpenAI(temperature=0)\n",
+    "    | StrOutputParser()\n",
+    ")"
    ]
   },
   {
@@ -273,12 +283,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "chain = {\n",
-    "    # Retrieve context using the normal question (only the first 3 results)\n",
-    "    \"normal_context\": RunnableLambda(lambda x: x['question']) | retriever,\n",
-    "    # Pass on the question\n",
-    "    \"question\": lambda x: x[\"question\"]\n",
-    "} | response_prompt | ChatOpenAI(temperature=0) | StrOutputParser()"
+    "chain = (\n",
+    "    {\n",
+    "        # Retrieve context using the normal question (only the first 3 results)\n",
+    "        \"normal_context\": RunnableLambda(lambda x: x[\"question\"]) | retriever,\n",
+    "        # Pass on the question\n",
+    "        \"question\": lambda x: x[\"question\"],\n",
+    "    }\n",
+    "    | response_prompt\n",
+    "    | ChatOpenAI(temperature=0)\n",
+    "    | StrOutputParser()\n",
+    ")"
    ]
   },
   {

cookbook/tree_of_thought.ipynb

@@ -51,7 +51,7 @@
     }
    ],
    "source": [
-    "sudoku_puzzle =   \"3,*,*,2|1,*,3,*|*,1,*,3|4,*,*,1\"\n",
+    "sudoku_puzzle = \"3,*,*,2|1,*,3,*|*,1,*,3|4,*,*,1\"\n",
     "sudoku_solution = \"3,4,1,2|1,2,3,4|2,1,4,3|4,3,2,1\"\n",
     "problem_description = f\"\"\"\n",
     "{sudoku_puzzle}\n",
@@ -64,7 +64,7 @@
     "- Keep the known digits from previous valid thoughts in place.\n",
     "- Each thought can be a partial or the final solution.\n",
     "\"\"\".strip()\n",
-    "print(problem_description)\n"
+    "print(problem_description)"
    ]
   },
   {
@@ -84,13 +84,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import re\n",
     "from typing import Tuple\n",
+    "\n",
     "from langchain_experimental.tot.checker import ToTChecker\n",
     "from langchain_experimental.tot.thought import ThoughtValidity\n",
-    "import re\n",
+    "\n",
     "\n",
     "class MyChecker(ToTChecker):\n",
-    "    def evaluate(self, problem_description: str, thoughts: Tuple[str, ...] = ()) -> ThoughtValidity:\n",
+    "    def evaluate(\n",
+    "        self, problem_description: str, thoughts: Tuple[str, ...] = ()\n",
+    "    ) -> ThoughtValidity:\n",
     "        last_thought = thoughts[-1]\n",
     "        clean_solution = last_thought.replace(\" \", \"\").replace('\"', \"\")\n",
     "        regex_solution = clean_solution.replace(\"*\", \".\").replace(\"|\", \"\\\\|\")\n",
@@ -116,10 +120,22 @@
    "outputs": [],
    "source": [
     "checker = MyChecker()\n",
-    "assert checker.evaluate(\"\", (\"3,*,*,2|1,*,3,*|*,1,*,3|4,*,*,1\",)) == ThoughtValidity.VALID_INTERMEDIATE\n",
-    "assert checker.evaluate(\"\", (\"3,4,1,2|1,2,3,4|2,1,4,3|4,3,2,1\",)) == ThoughtValidity.VALID_FINAL\n",
-    "assert checker.evaluate(\"\", (\"3,4,1,2|1,2,3,4|2,1,4,3|4,3,*,1\",)) == ThoughtValidity.VALID_INTERMEDIATE\n",
-    "assert checker.evaluate(\"\", (\"3,4,1,2|1,2,3,4|2,1,4,3|4,*,3,1\",)) == ThoughtValidity.INVALID"
+    "assert (\n",
+    "    checker.evaluate(\"\", (\"3,*,*,2|1,*,3,*|*,1,*,3|4,*,*,1\",))\n",
+    "    == ThoughtValidity.VALID_INTERMEDIATE\n",
+    ")\n",
+    "assert (\n",
+    "    checker.evaluate(\"\", (\"3,4,1,2|1,2,3,4|2,1,4,3|4,3,2,1\",))\n",
+    "    == ThoughtValidity.VALID_FINAL\n",
+    ")\n",
+    "assert (\n",
+    "    checker.evaluate(\"\", (\"3,4,1,2|1,2,3,4|2,1,4,3|4,3,*,1\",))\n",
+    "    == ThoughtValidity.VALID_INTERMEDIATE\n",
+    ")\n",
+    "assert (\n",
+    "    checker.evaluate(\"\", (\"3,4,1,2|1,2,3,4|2,1,4,3|4,*,3,1\",))\n",
+    "    == ThoughtValidity.INVALID\n",
+    ")"
    ]
   },
   {
@@ -203,7 +219,9 @@
    "source": [
     "from langchain_experimental.tot.base import ToTChain\n",
     "\n",
-    "tot_chain = ToTChain(llm=llm, checker=MyChecker(), k=30, c=5, verbose=True, verbose_llm=False)\n",
+    "tot_chain = ToTChain(\n",
+    "    llm=llm, checker=MyChecker(), k=30, c=5, verbose=True, verbose_llm=False\n",
+    ")\n",
     "tot_chain.run(problem_description=problem_description)"
    ]
   },

cookbook/twitter-the-algorithm-analysis-deeplake.ipynb

@@ -34,8 +34,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
     "import getpass\n",
+    "import os\n",
     "\n",
     "from langchain.embeddings.openai import OpenAIEmbeddings\n",
     "from langchain.vectorstores import DeepLake\n",
@@ -109,6 +109,7 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "\n",
     "from langchain.document_loaders import TextLoader\n",
     "\n",
     "root_dir = \"./the-algorithm\"\n",
@@ -118,7 +119,7 @@
     "        try:\n",
     "            loader = TextLoader(os.path.join(dirpath, file), encoding=\"utf-8\")\n",
     "            docs.extend(loader.load_and_split())\n",
-    "        except Exception as e:\n",
+    "        except Exception:\n",
     "            pass"
    ]
   },
@@ -3807,8 +3808,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.chains import ConversationalRetrievalChain\n",
+    "from langchain.chat_models import ChatOpenAI\n",
     "\n",
     "model = ChatOpenAI(model_name=\"gpt-3.5-turbo-0613\")  # switch to 'gpt-4'\n",
     "qa = ConversationalRetrievalChain.from_llm(model, retriever=retriever)"

cookbook/two_agent_debate_tools.ipynb

@@ -22,17 +22,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from typing import List, Dict, Callable\n",
-    "from langchain.chains import ConversationChain\n",
+    "from typing import Callable, List\n",
+    "\n",
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.llms import OpenAI\n",
     "from langchain.memory import ConversationBufferMemory\n",
-    "from langchain.prompts.prompt import PromptTemplate\n",
     "from langchain.schema import (\n",
     "    AIMessage,\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
-    "    BaseMessage,\n",
     ")"
    ]
   },
@@ -49,10 +46,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import Tool\n",
-    "from langchain.agents import initialize_agent\n",
-    "from langchain.agents import AgentType\n",
-    "from langchain.agents import load_tools"
+    "from langchain.agents import AgentType, initialize_agent, load_tools"
    ]
   },
   {

cookbook/two_player_dnd.ipynb

@@ -22,7 +22,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from typing import List, Dict, Callable\n",
+    "from typing import Callable, List\n",
+    "\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.schema import (\n",
     "    HumanMessage,\n",

cookbook/wikibase_agent.ipynb

@@ -35,7 +35,7 @@
     "tags": []
    },
    "source": [
-    "### API keys and other secrats\n",
+    "### API keys and other secrets\n",
     "\n",
     "We use an `.ini` file, like this: \n",
     "```\n",
@@ -192,10 +192,10 @@
     "    return current\n",
     "\n",
     "\n",
-    "import requests\n",
-    "\n",
     "from typing import Optional\n",
     "\n",
+    "import requests\n",
+    "\n",
     "\n",
     "def vocab_lookup(\n",
     "    search: str,\n",
@@ -319,9 +319,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import requests\n",
-    "from typing import List, Dict, Any\n",
     "import json\n",
+    "from typing import Any, Dict, List\n",
+    "\n",
+    "import requests\n",
     "\n",
     "\n",
     "def run_sparql(\n",
@@ -389,17 +390,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import (\n",
-    "    Tool,\n",
-    "    AgentExecutor,\n",
-    "    LLMSingleActionAgent,\n",
-    "    AgentOutputParser,\n",
-    ")\n",
-    "from langchain.prompts import StringPromptTemplate\n",
-    "from langchain.llms import OpenAI\nfrom langchain.chains import LLMChain\n",
+    "import re\n",
     "from typing import List, Union\n",
-    "from langchain.schema import AgentAction, AgentFinish\n",
-    "import re"
+    "\n",
+    "from langchain.agents import (\n",
+    "    AgentExecutor,\n",
+    "    AgentOutputParser,\n",
+    "    LLMSingleActionAgent,\n",
+    "    Tool,\n",
+    ")\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.prompts import StringPromptTemplate\n",
+    "from langchain.schema import AgentAction, AgentFinish"
    ]
   },
   {

docs/.local_build.sh

@@ -15,6 +15,7 @@ poetry run python scripts/model_feat_table.py
 poetry run nbdoc_build --srcdir docs
 cp ../cookbook/README.md src/pages/cookbook.mdx
 cp ../.github/CONTRIBUTING.md docs/contributing.md
+wget https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md -O docs/langserve.md
 poetry run python scripts/generate_api_reference_links.py
 yarn install
 yarn start

docs/api_reference/_static/css/custom.css

@@ -15,3 +15,11 @@ pre {
 #my-component-root *, #headlessui-portal-root * {
   z-index: 10000;
 }
+
+table.longtable code {
+  white-space: normal;
+}
+
+table.longtable td {
+  max-width: 600px;
+}

docs/api_reference/create_api_rst.py

@@ -2,9 +2,9 @@
 import importlib
 import inspect
 import typing
-from pathlib import Path
-from typing import TypedDict, Sequence, List, Dict, Literal, Union, Optional
 from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Literal, Optional, Sequence, TypedDict, Union
 
 from pydantic import BaseModel
 
@@ -13,8 +13,10 @@ 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"]
@@ -292,6 +294,17 @@ def _document_langchain_experimental() -> None:
 
 
 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)
@@ -306,7 +319,6 @@ def _document_langchain_core() -> None:
             "agents.output_parsers": agents["output_parsers"],
             "agents.format_scratchpad": agents["format_scratchpad"],
             "tools.render": tools["render"],
-            "schema.runnable": schema["runnable"],
         }
     )
 
@@ -318,8 +330,9 @@ def _document_langchain_core() -> None:
 
 def main() -> None:
     """Generate the reference.rst file for each package."""
-    _document_langchain_core()
+    _document_langchain()
     _document_langchain_experimental()
+    _document_langchain_core()
 
 
 if __name__ == "__main__":

docs/api_reference/requirements.txt

@@ -1,5 +1,6 @@
 -e libs/langchain
 -e libs/experimental
+-e libs/core
 pydantic<2
 autodoc_pydantic==1.8.0
 myst_parser

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

@@ -34,6 +34,9 @@
         <li class="nav-item">
           <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('experimental_api_reference') }}">Experimental</a>
         </li>

docs/docs/_static/css/custom.css

@@ -1,21 +0,0 @@
-pre {
-  white-space: break-spaces;
-}
-
-@media (min-width: 1200px) {
-  .container,
-  .container-lg,
-  .container-md,
-  .container-sm,
-  .container-xl {
-    max-width: 2560px !important;
-  }
-}
-
-#my-component-root *, #headlessui-portal-root * {
-  z-index: 10000;
-}
-
-.content-container p {
-    margin: revert;
-}