bump 281 (#10189)

I have restructured the code to ensure uniform handling of ImportError.
In place of previously used ValueError, I've adopted the standard
practice of raising ImportError with explanatory messages. This
modification enhances code readability and clarifies that any problems
stem from module importation.

---------

Co-authored-by: Aashish Saini <141953346+AashishSainiShorthillsAI@users.noreply.github.com>
Co-authored-by: AryamanJaiswalShorthillsAI <142397527+AryamanJaiswalShorthillsAI@users.noreply.github.com>
Co-authored-by: Adarsh Shrivastav <142413097+AdarshKumarShorthillsAI@users.noreply.github.com>
Co-authored-by: Vishal <141389263+VishalYadavShorthillsAI@users.noreply.github.com>
Co-authored-by: ChetnaGuptaShorthillsAI <142381084+ChetnaGuptaShorthillsAI@users.noreply.github.com>
Co-authored-by: PankajKumarShorthillsAI <142473460+PankajKumarShorthillsAI@users.noreply.github.com>
Co-authored-by: AbhishekYadavShorthillsAI <142393903+AbhishekYadavShorthillsAI@users.noreply.github.com>
Co-authored-by: AmitSinghShorthillsAI <142410046+AmitSinghShorthillsAI@users.noreply.github.com>
Co-authored-by: Aayush <142384656+AayushShorthillsAI@users.noreply.github.com>
Co-authored-by: AnujMauryaShorthillsAI <142393269+AnujMauryaShorthillsAI@users.noreply.github.com>

.github/CONTRIBUTING.md

@@ -33,7 +33,7 @@ best way to get our attention.
 ### 🚩GitHub Issues
 
 Our [issues](https://github.com/hwchase17/langchain/issues) page is kept up to date
-with bugs, improvements, and feature requests. 
+with bugs, improvements, and feature requests.
 
 There is a taxonomy of labels to help with sorting and discovery of issues of interest. Please use these to help
 organize issues.
@@ -44,7 +44,7 @@ If you are adding an issue, please try to keep it focused on a single, modular b
 If two issues are related, or blocking, please link them rather than combining them.
 
 We will try to keep these issues as up to date as possible, though
-with the rapid rate of develop in this field some may get out of date.
+with the rapid rate of development in this field some may get out of date.
 If you notice this happening, please let us know.
 
 ### 🙋Getting Help
@@ -61,11 +61,11 @@ we do not want these to get in the way of getting good code into the codebase.
 
 > **Note:** You can run this repository locally (which is described below) or in a [development container](https://containers.dev/) (which is described in the [.devcontainer folder](https://github.com/hwchase17/langchain/tree/master/.devcontainer)).
 
-This project uses [Poetry](https://python-poetry.org/) as a dependency manager. Check out Poetry's [documentation on how to install it](https://python-poetry.org/docs/#installation) on your system before proceeding.
+This project uses [Poetry](https://python-poetry.org/) v1.5.1 as a dependency manager. Check out Poetry's [documentation on how to install it](https://python-poetry.org/docs/#installation) on your system before proceeding.
 
 ❗Note: If you use `Conda` or `Pyenv` as your environment / package manager, avoid dependency conflicts by doing the following first:
 1. *Before installing Poetry*, create and activate a new Conda env (e.g. `conda create -n langchain python=3.9`)
-2. Install Poetry (see above)
+2. Install Poetry v1.5.1 (see above)
 3. Tell Poetry to use the virtualenv python environment (`poetry config virtualenvs.prefer-active-python true`)
 4. Continue with the following steps.
 
@@ -73,21 +73,21 @@ There are two separate projects in this repository:
 - `langchain`: core langchain code, abstractions, and use cases
 - `langchain.experimental`: more experimental code
 
-Each of these has their OWN development environment. 
+Each of these has their OWN development environment.
 In order to run any of the commands below, please move into their respective directories.
 For example, to contribute to `langchain` run `cd libs/langchain` before getting started with the below.
 
 To install requirements:
 
 ```bash
-poetry install -E all
+poetry install --with test
 ```
 
-This will install all requirements for running the package, examples, linting, formatting, tests, and coverage. Note the `-E all` flag will install all optional dependencies necessary for integration testing.
+This will install all requirements for running the package, examples, linting, formatting, tests, and coverage.
 
-❗Note: If you're running Poetry 1.4.1 and receive a `WheelFileValidationError` for `debugpy` during installation, you can try either downgrading to Poetry 1.4.0 or disabling "modern installation" (`poetry config installer.modern-installation false`) and re-install requirements. See [this `debugpy` issue](https://github.com/microsoft/debugpy/issues/1246) for more details.
+❗Note: If during installation you receive a `WheelFileValidationError` for `debugpy`, please make sure you are running Poetry v1.5.1. This bug was present in older versions of Poetry (e.g. 1.4.1) and has been resolved in newer releases. If you are still seeing this bug on v1.5.1, you may also try disabling "modern installation" (`poetry config installer.modern-installation false`) and re-installing requirements. See [this `debugpy` issue](https://github.com/microsoft/debugpy/issues/1246) for more details.
 
-Now, you should be able to run the common tasks in the following section. To double check, run `make test`, all tests should pass. If they don't you may need to pip install additional dependencies, such as `numexpr` and `openapi_schema_pydantic`.
+Now assuming `make` and `pytest` are installed, you should be able to run the common tasks in the following section. To double check, run `make test` under `libs/langchain`, all tests should pass. If they don't, you may need to pip install additional dependencies, such as `numexpr` and `openapi_schema_pydantic`.
 
 ## ✅ Common Tasks
 
@@ -134,7 +134,7 @@ We recognize linting can be annoying - if you do not want to do it, please conta
 ### Spellcheck
 
 Spellchecking for this project is done via [codespell](https://github.com/codespell-project/codespell).
-Note that `codespell` finds common typos, so could have false-positive (correctly spelled but rarely used) and false-negatives (not finding misspelled) words.
+Note that `codespell` finds common typos, so it could have false-positive (correctly spelled but rarely used) and false-negatives (not finding misspelled) words.
 
 To check spelling for this project:
 
@@ -175,9 +175,9 @@ If you're adding a new dependency to Langchain, assume that it will be an option
 that most users won't have it installed.
 
 Users that do not have the dependency installed should be able to **import** your code without
-any side effects (no warnings, no errors, no exceptions). 
+any side effects (no warnings, no errors, no exceptions).
 
-To introduce the dependency to the pyproject.toml file correctly, please do the following: 
+To introduce the dependency to the pyproject.toml file correctly, please do the following:
 
 1. Add the dependency to the main group as an optional dependency
   ```bash
@@ -220,7 +220,7 @@ If you add new logic, please add a unit test.
 
 Integration tests cover logic that requires making calls to outside APIs (often integration with other services).
 
-**warning** Almost no tests should be integration tests. 
+**warning** Almost no tests should be integration tests.
 
   Tests that require making network connections make it difficult for other
   developers to test the code.
@@ -307,4 +307,3 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
 
 If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
 If you have a Twitter account you would like us to mention, please let us know in the PR or in another manner.
-

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,5 +1,5 @@
 name: "\U0001F41B Bug Report"
-description: Submit a bug report to help us improve LangChain
+description: Submit a bug report to help us improve LangChain. To report a security issue, please instead use the security option below.
 labels: ["02 Bug Report"]
 body:
   - type: markdown

.github/actions/poetry_setup/action.yml

@@ -15,64 +15,52 @@ inputs:
     description: Poetry version
     required: true
 
-  install-command:
-    description: Command run for installing dependencies
-    required: false
-    default: poetry install
-
   cache-key:
     description: Cache key to use for manual handling of caching
     required: true
 
   working-directory:
-    description: Directory to run install-command in
-    required: false
-    default: ""
+    description: Directory whose poetry.lock file should be cached
+    required: true
 
 runs:
   using: composite
   steps:
     - uses: actions/setup-python@v4
-      name: Setup python $${ inputs.python-version }}
+      name: Setup python ${{ inputs.python-version }}
       with:
         python-version: ${{ inputs.python-version }}
 
     - uses: actions/cache@v3
-      id: cache-pip
-      name: Cache Pip ${{ inputs.python-version }}
+      id: cache-bin-poetry
+      name: Cache Poetry binary - Python ${{ inputs.python-version }}
       env:
-        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "15"
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "1"
+      with:
+        path: |
+          /opt/pipx/venvs/poetry
+          /opt/pipx_bin/poetry
+        # This step caches the poetry installation, so make sure it's keyed on the poetry version as well.
+        key: bin-poetry-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-${{ inputs.poetry-version }}
+
+    - name: Install poetry
+      if: steps.cache-bin-poetry.outputs.cache-hit != 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      run: pipx install "poetry==$POETRY_VERSION" --python "python$PYTHON_VERSION" --verbose
+
+    - name: Restore pip and poetry cached dependencies
+      uses: actions/cache@v3
+      env:
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "4"
+        WORKDIR: ${{ inputs.working-directory == '' && '.' || inputs.working-directory }}
       with:
         path: |
           ~/.cache/pip
-        key: pip-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}
-
-    - run: pipx install poetry==${{ inputs.poetry-version }} --python python${{ inputs.python-version }}
-      shell: bash
-
-    - name: Check Poetry File
-      shell: bash
-      working-directory: ${{ inputs.working-directory }}
-      run: |
-        poetry check
-
-    - name: Check lock file
-      shell: bash
-      working-directory: ${{ inputs.working-directory }}
-      run: |
-        poetry lock --check
-
-    - uses: actions/cache@v3
-      id: cache-poetry
-      env:
-        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "15"
-      with:
-        path: |
           ~/.cache/pypoetry/virtualenvs
           ~/.cache/pypoetry/cache
           ~/.cache/pypoetry/artifacts
-        key: poetry-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-poetry-${{ inputs.poetry-version }}-${{ inputs.cache-key }}-${{ hashFiles('poetry.lock') }}
-
-    - run: ${{ inputs.install-command }}
-      working-directory: ${{ inputs.working-directory }}
-      shell: bash
+          ${{ env.WORKDIR }}/.venv
+        key: py-deps-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-poetry-${{ inputs.poetry-version }}-${{ inputs.cache-key }}-${{ hashFiles(format('{0}/**/poetry.lock', env.WORKDIR)) }}

.github/tools/git-restore-mtime

@@ -0,0 +1,606 @@
+#!/usr/bin/env python3
+#
+# git-restore-mtime - Change mtime of files based on commit date of last change
+#
+#    Copyright (C) 2012 Rodrigo Silva (MestreLion) <linux@rodrigosilva.com>
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program. See <http://www.gnu.org/licenses/gpl.html>
+#
+# Source: https://github.com/MestreLion/git-tools
+# Version: July 13, 2023 (commit hash 5f832e72453e035fccae9d63a5056918d64476a2)
+"""
+Change the modification time (mtime) of files in work tree, based on the
+date of the most recent commit that modified the file, including renames.
+
+Ignores untracked files and uncommitted deletions, additions and renames, and
+by default modifications too.
+---
+Useful prior to generating release tarballs, so each file is archived with a
+date that is similar to the date when the file was actually last modified,
+assuming the actual modification date and its commit date are close.
+"""
+
+# TODO:
+# - Add -z on git whatchanged/ls-files, so we don't deal with filename decoding
+# - When Python is bumped to 3.7, use text instead of universal_newlines on subprocess
+# - Update "Statistics for some large projects" with modern hardware and repositories.
+# - Create a README.md for git-restore-mtime alone. It deserves extensive documentation
+#   - Move Statistics there
+# - See git-extras as a good example on project structure and documentation
+
+# FIXME:
+# - When current dir is outside the worktree, e.g. using --work-tree, `git ls-files`
+#   assume any relative pathspecs are to worktree root, not the current dir. As such,
+#   relative pathspecs may not work.
+# - Renames are tricky:
+#   - R100 should not change mtime, but original name is not on filelist. Should
+#     track renames until a valid (A, M) mtime found and then set on current name.
+#   - Should set mtime for both current and original directories.
+#   - Check mode changes with unchanged blobs?
+# - Check file (A, D) for the directory mtime is not sufficient:
+#   - Renames also change dir mtime, unless rename was on a parent dir
+#   - If most recent change of all files in a dir was a Modification (M),
+#     dir might not be touched at all.
+#   - Dirs containing only subdirectories but no direct files will also
+#     not be touched. They're files' [grand]parent dir, but never their dirname().
+#   - Some solutions:
+#     - After files done, perform some dir processing for missing dirs, finding latest
+#       file (A, D, R)
+#     - Simple approach: dir mtime is the most recent child (dir or file) mtime
+#     - Use a virtual concept of "created at most at" to fill missing info, bubble up
+#       to parents and grandparents
+#   - When handling [grand]parent dirs, stay inside <pathspec>
+# - Better handling of merge commits. `-m` is plain *wrong*. `-c/--cc` is perfect, but
+#   painfully slow. First pass without merge commits is not accurate. Maybe add a new
+#   `--accurate` mode for `--cc`?
+
+if __name__ != "__main__":
+    raise ImportError("{} should not be used as a module.".format(__name__))
+
+import argparse
+import datetime
+import logging
+import os.path
+import shlex
+import signal
+import subprocess
+import sys
+import time
+
+__version__ = "2022.12+dev"
+
+# Update symlinks only if the platform supports not following them
+UPDATE_SYMLINKS = bool(os.utime in getattr(os, 'supports_follow_symlinks', []))
+
+# Call os.path.normpath() only if not in a POSIX platform (Windows)
+NORMALIZE_PATHS = (os.path.sep != '/')
+
+# How many files to process in each batch when re-trying merge commits
+STEPMISSING = 100
+
+# (Extra) keywords for the os.utime() call performed by touch()
+UTIME_KWS = {} if not UPDATE_SYMLINKS else {'follow_symlinks': False}
+
+
+# Command-line interface ######################################################
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=__doc__.split('\n---')[0])
+
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--quiet', '-q', dest='loglevel',
+        action="store_const", const=logging.WARNING, default=logging.INFO,
+        help="Suppress informative messages and summary statistics.")
+    group.add_argument('--verbose', '-v', action="count", help="""
+        Print additional information for each processed file.
+        Specify twice to further increase verbosity.
+        """)
+
+    parser.add_argument('--cwd', '-C', metavar="DIRECTORY", help="""
+        Run as if %(prog)s was started in directory %(metavar)s.
+        This affects how --work-tree, --git-dir and PATHSPEC arguments are handled.
+        See 'man 1 git' or 'git --help' for more information.
+        """)
+
+    parser.add_argument('--git-dir', dest='gitdir', metavar="GITDIR", help="""
+        Path to the git repository, by default auto-discovered by searching
+        the current directory and its parents for a .git/ subdirectory.
+        """)
+
+    parser.add_argument('--work-tree', dest='workdir', metavar="WORKTREE", help="""
+        Path to the work tree root, by default the parent of GITDIR if it's
+        automatically discovered, or the current directory if GITDIR is set.
+        """)
+
+    parser.add_argument('--force', '-f', default=False, action="store_true", help="""
+        Force updating files with uncommitted modifications.
+        Untracked files and uncommitted deletions, renames and additions are
+        always ignored.
+        """)
+
+    parser.add_argument('--merge', '-m', default=False, action="store_true", help="""
+        Include merge commits.
+        Leads to more recent times and more files per commit, thus with the same
+        time, which may or may not be what you want.
+        Including merge commits may lead to fewer commits being evaluated as files
+        are found sooner, which can improve performance, sometimes substantially.
+        But as merge commits are usually huge, processing them may also take longer.
+        By default, merge commits are only used for files missing from regular commits.
+        """)
+
+    parser.add_argument('--first-parent', default=False, action="store_true", help="""
+        Consider only the first parent, the "main branch", when evaluating merge commits.
+        Only effective when merge commits are processed, either when --merge is
+        used or when finding missing files after the first regular log search.
+        See --skip-missing.
+        """)
+
+    parser.add_argument('--skip-missing', '-s', dest="missing", default=True,
+        action="store_false", help="""
+        Do not try to find missing files.
+        If merge commits were not evaluated with --merge and some files were
+        not found in regular commits, by default %(prog)s searches for these
+        files again in the merge commits.
+        This option disables this retry, so files found only in merge commits
+        will not have their timestamp updated.
+        """)
+
+    parser.add_argument('--no-directories', '-D', dest='dirs', default=True,
+        action="store_false", help="""
+        Do not update directory timestamps.
+        By default, use the time of its most recently created, renamed or deleted file.
+        Note that just modifying a file will NOT update its directory time.
+        """)
+
+    parser.add_argument('--test', '-t', default=False, action="store_true",
+        help="Test run: do not actually update any file timestamp.")
+
+    parser.add_argument('--commit-time', '-c', dest='commit_time', default=False,
+        action='store_true', help="Use commit time instead of author time.")
+
+    parser.add_argument('--oldest-time', '-o', dest='reverse_order', default=False,
+        action='store_true', help="""
+        Update times based on the oldest, instead of the most recent commit of a file.
+        This reverses the order in which the git log is processed to emulate a
+        file "creation" date. Note this will be inaccurate for files deleted and
+        re-created at later dates.
+        """)
+
+    parser.add_argument('--skip-older-than', metavar='SECONDS', type=int, help="""
+        Ignore files that are currently older than %(metavar)s.
+        Useful in workflows that assume such files already have a correct timestamp,
+        as it may improve performance by processing fewer files.
+        """)
+
+    parser.add_argument('--skip-older-than-commit', '-N', default=False,
+        action='store_true', help="""
+        Ignore files older than the timestamp it would be updated to.
+        Such files may be considered "original", likely in the author's repository.
+        """)
+
+    parser.add_argument('--unique-times', default=False, action="store_true", help="""
+        Set the microseconds to a unique value per commit.
+        Allows telling apart changes that would otherwise have identical timestamps,
+        as git's time accuracy is in seconds.
+        """)
+
+    parser.add_argument('pathspec', nargs='*', metavar='PATHSPEC', help="""
+        Only modify paths matching %(metavar)s, relative to current directory.
+        By default, update all but untracked files and submodules.
+        """)
+
+    parser.add_argument('--version', '-V', action='version',
+        version='%(prog)s version {version}'.format(version=get_version()))
+
+    args_ = parser.parse_args()
+    if args_.verbose:
+        args_.loglevel = max(logging.TRACE, logging.DEBUG // args_.verbose)
+    args_.debug = args_.loglevel <= logging.DEBUG
+    return args_
+
+
+def get_version(version=__version__):
+    if not version.endswith('+dev'):
+        return version
+    try:
+        cwd = os.path.dirname(os.path.realpath(__file__))
+        return Git(cwd=cwd, errors=False).describe().lstrip('v')
+    except Git.Error:
+        return '-'.join((version, "unknown"))
+
+
+# Helper functions ############################################################
+
+def setup_logging():
+    """Add TRACE logging level and corresponding method, return the root logger"""
+    logging.TRACE = TRACE = logging.DEBUG // 2
+    logging.Logger.trace = lambda _, m, *a, **k: _.log(TRACE, m, *a, **k)
+    return logging.getLogger()
+
+
+def normalize(path):
+    r"""Normalize paths from git, handling non-ASCII characters.
+
+    Git stores paths as UTF-8 normalization form C.
+    If path contains non-ASCII or non-printable characters, git outputs the UTF-8
+    in octal-escaped notation, escaping double-quotes and backslashes, and then
+    double-quoting the whole path.
+    https://git-scm.com/docs/git-config#Documentation/git-config.txt-corequotePath
+
+    This function reverts this encoding, so:
+    normalize(r'"Back\\slash_double\"quote_a\303\247a\303\255"') =>
+        r'Back\slash_double"quote_açaí')
+
+    Paths with invalid UTF-8 encoding, such as single 0x80-0xFF bytes (e.g, from
+    Latin1/Windows-1251 encoding) are decoded using surrogate escape, the same
+    method used by Python for filesystem paths. So 0xE6 ("æ" in Latin1, r'\\346'
+    from Git) is decoded as "\udce6". See https://peps.python.org/pep-0383/ and
+    https://vstinner.github.io/painful-history-python-filesystem-encoding.html
+
+    Also see notes on `windows/non-ascii-paths.txt` about path encodings on
+    non-UTF-8 platforms and filesystems.
+    """
+    if path and path[0] == '"':
+        # Python 2: path = path[1:-1].decode("string-escape")
+        # Python 3: https://stackoverflow.com/a/46650050/624066
+        path = (path[1:-1]                 # Remove enclosing double quotes
+                .encode('latin1')          # Convert to bytes, required by 'unicode-escape'
+                .decode('unicode-escape')  # Perform the actual octal-escaping decode
+                .encode('latin1')          # 1:1 mapping to bytes, UTF-8 encoded
+                .decode('utf8', 'surrogateescape'))  # Decode from UTF-8
+    if NORMALIZE_PATHS:
+        # Make sure the slash matches the OS; for Windows we need a backslash
+        path = os.path.normpath(path)
+    return path
+
+
+def dummy(*_args, **_kwargs):
+    """No-op function used in dry-run tests"""
+
+
+def touch(path, mtime):
+    """The actual mtime update"""
+    os.utime(path, (mtime, mtime), **UTIME_KWS)
+
+
+def touch_ns(path, mtime_ns):
+    """The actual mtime update, using nanoseconds for unique timestamps"""
+    os.utime(path, None, ns=(mtime_ns, mtime_ns), **UTIME_KWS)
+
+
+def isodate(secs: int):
+    # time.localtime() accepts floats, but discards fractional part
+    return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(secs))
+
+
+def isodate_ns(ns: int):
+    # for integers fromtimestamp() is equivalent and ~16% slower than isodate()
+    return datetime.datetime.fromtimestamp(ns / 1000000000).isoformat(sep=' ')
+
+
+def get_mtime_ns(secs: int, idx: int):
+    # Time resolution for filesystems and functions:
+    # ext-4 and other POSIX filesystems: 1 nanosecond
+    # NTFS (Windows default): 100 nanoseconds
+    # datetime.datetime() (due to 64-bit float epoch): 1 microsecond
+    us = idx % 1000000  # 10**6
+    return 1000 * (1000000 * secs + us)
+
+
+def get_mtime_path(path):
+    return os.path.getmtime(path)
+
+
+# Git class and parse_log(), the heart of the script ##########################
+
+class Git:
+    def __init__(self, workdir=None, gitdir=None, cwd=None, errors=True):
+        self.gitcmd = ['git']
+        self.errors = errors
+        self._proc = None
+        if workdir: self.gitcmd.extend(('--work-tree', workdir))
+        if gitdir:  self.gitcmd.extend(('--git-dir',   gitdir))
+        if cwd:     self.gitcmd.extend(('-C',          cwd))
+        self.workdir, self.gitdir = self._get_repo_dirs()
+
+    def ls_files(self, paths: list = None):
+        return (normalize(_) for _ in self._run('ls-files --full-name', paths))
+
+    def ls_dirty(self, force=False):
+        return (normalize(_[3:].split(' -> ', 1)[-1])
+                for _ in self._run('status --porcelain')
+                if _[:2] != '??' and (not force or (_[0] in ('R', 'A')
+                                                    or _[1] == 'D')))
+
+    def log(self, merge=False, first_parent=False, commit_time=False,
+            reverse_order=False, paths: list = None):
+        cmd = 'whatchanged --pretty={}'.format('%ct' if commit_time else '%at')
+        if merge:         cmd += ' -m'
+        if first_parent:  cmd += ' --first-parent'
+        if reverse_order: cmd += ' --reverse'
+        return self._run(cmd, paths)
+
+    def describe(self):
+        return self._run('describe --tags', check=True)[0]
+
+    def terminate(self):
+        if self._proc is None:
+            return
+        try:
+            self._proc.terminate()
+        except OSError:
+            # Avoid errors on OpenBSD
+            pass
+
+    def _get_repo_dirs(self):
+        return (os.path.normpath(_) for _ in
+            self._run('rev-parse --show-toplevel --absolute-git-dir', check=True))
+
+    def _run(self, cmdstr: str, paths: list = None, output=True, check=False):
+        cmdlist = self.gitcmd + shlex.split(cmdstr)
+        if paths:
+            cmdlist.append('--')
+            cmdlist.extend(paths)
+        popen_args = dict(universal_newlines=True, encoding='utf8')
+        if not self.errors:
+            popen_args['stderr'] = subprocess.DEVNULL
+        log.trace("Executing: %s", ' '.join(cmdlist))
+        if not output:
+            return subprocess.call(cmdlist, **popen_args)
+        if check:
+            try:
+                stdout: str = subprocess.check_output(cmdlist, **popen_args)
+                return stdout.splitlines()
+            except subprocess.CalledProcessError as e:
+                raise self.Error(e.returncode, e.cmd, e.output, e.stderr)
+        self._proc = subprocess.Popen(cmdlist, stdout=subprocess.PIPE, **popen_args)
+        return (_.rstrip() for _ in self._proc.stdout)
+
+    def __del__(self):
+        self.terminate()
+
+    class Error(subprocess.CalledProcessError):
+        """Error from git executable"""
+
+
+def parse_log(filelist, dirlist, stats, git, merge=False, filterlist=None):
+    mtime = 0
+    datestr = isodate(0)
+    for line in git.log(
+            merge,
+            args.first_parent,
+            args.commit_time,
+            args.reverse_order,
+            filterlist
+    ):
+        stats['loglines'] += 1
+
+        # Blank line between Date and list of files
+        if not line:
+            continue
+
+        # Date line
+        if line[0] != ':':  # Faster than `not line.startswith(':')`
+            stats['commits'] += 1
+            mtime = int(line)
+            if args.unique_times:
+                mtime = get_mtime_ns(mtime, stats['commits'])
+            if args.debug:
+                datestr = isodate(mtime)
+            continue
+
+        # File line: three tokens if it describes a renaming, otherwise two
+        tokens = line.split('\t')
+
+        # Possible statuses:
+        # M: Modified (content changed)
+        # A: Added (created)
+        # D: Deleted
+        # T: Type changed: to/from regular file, symlinks, submodules
+        # R099: Renamed (moved), with % of unchanged content. 100 = pure rename
+        # Not possible in log: C=Copied, U=Unmerged, X=Unknown, B=pairing Broken
+        status = tokens[0].split(' ')[-1]
+        file = tokens[-1]
+
+        # Handles non-ASCII chars and OS path separator
+        file = normalize(file)
+
+        def do_file():
+            if args.skip_older_than_commit and get_mtime_path(file) <= mtime:
+                stats['skip'] += 1
+                return
+            if args.debug:
+                log.debug("%d\t%d\t%d\t%s\t%s",
+                          stats['loglines'], stats['commits'], stats['files'],
+                          datestr, file)
+            try:
+                touch(os.path.join(git.workdir, file), mtime)
+                stats['touches'] += 1
+            except Exception as e:
+                log.error("ERROR: %s: %s", e, file)
+                stats['errors'] += 1
+
+        def do_dir():
+            if args.debug:
+                log.debug("%d\t%d\t-\t%s\t%s",
+                          stats['loglines'], stats['commits'],
+                          datestr, "{}/".format(dirname or '.'))
+            try:
+                touch(os.path.join(git.workdir, dirname), mtime)
+                stats['dirtouches'] += 1
+            except Exception as e:
+                log.error("ERROR: %s: %s", e, dirname)
+                stats['direrrors'] += 1
+
+        if file in filelist:
+            stats['files'] -= 1
+            filelist.remove(file)
+            do_file()
+
+        if args.dirs and status in ('A', 'D'):
+            dirname = os.path.dirname(file)
+            if dirname in dirlist:
+                dirlist.remove(dirname)
+                do_dir()
+
+        # All files done?
+        if not stats['files']:
+            git.terminate()
+            return
+
+
+# Main Logic ##################################################################
+
+def main():
+    start = time.time()  # yes, Wall time. CPU time is not realistic for users.
+    stats = {_: 0 for _ in ('loglines', 'commits', 'touches', 'skip', 'errors',
+                            'dirtouches', 'direrrors')}
+
+    logging.basicConfig(level=args.loglevel, format='%(message)s')
+    log.trace("Arguments: %s", args)
+
+    # First things first: Where and Who are we?
+    if args.cwd:
+        log.debug("Changing directory: %s", args.cwd)
+        try:
+            os.chdir(args.cwd)
+        except OSError as e:
+            log.critical(e)
+            return e.errno
+    # Using both os.chdir() and `git -C` is redundant, but might prevent side effects
+    # `git -C` alone could be enough if we make sure that:
+    # - all paths, including args.pathspec, are processed by git: ls-files, rev-parse
+    # - touch() / os.utime() path argument is always prepended with git.workdir
+    try:
+        git = Git(workdir=args.workdir, gitdir=args.gitdir, cwd=args.cwd)
+    except Git.Error as e:
+        # Not in a git repository, and git already informed user on stderr. So we just...
+        return e.returncode
+
+    # Get the files managed by git and build file list to be processed
+    if UPDATE_SYMLINKS and not args.skip_older_than:
+        filelist = set(git.ls_files(args.pathspec))
+    else:
+        filelist = set()
+        for path in git.ls_files(args.pathspec):
+            fullpath = os.path.join(git.workdir, path)
+
+            # Symlink (to file, to dir or broken - git handles the same way)
+            if not UPDATE_SYMLINKS and os.path.islink(fullpath):
+                log.warning("WARNING: Skipping symlink, no OS support for updates: %s",
+                            path)
+                continue
+
+            # skip files which are older than given threshold
+            if (args.skip_older_than
+                    and start - get_mtime_path(fullpath) > args.skip_older_than):
+                continue
+
+            # Always add files relative to worktree root
+            filelist.add(path)
+
+    # If --force, silently ignore uncommitted deletions (not in the filesystem)
+    # and renames / additions (will not be found in log anyway)
+    if args.force:
+        filelist -= set(git.ls_dirty(force=True))
+    # Otherwise, ignore any dirty files
+    else:
+        dirty = set(git.ls_dirty())
+        if dirty:
+            log.warning("WARNING: Modified files in the working directory were ignored."
+                "\nTo include such files, commit your changes or use --force.")
+            filelist -= dirty
+
+    # Build dir list to be processed
+    dirlist = set(os.path.dirname(_) for _ in filelist) if args.dirs else set()
+
+    stats['totalfiles'] = stats['files'] = len(filelist)
+    log.info("{0:,} files to be processed in work dir".format(stats['totalfiles']))
+
+    if not filelist:
+        # Nothing to do. Exit silently and without errors, just like git does
+        return
+
+    # Process the log until all files are 'touched'
+    log.debug("Line #\tLog #\tF.Left\tModification Time\tFile Name")
+    parse_log(filelist, dirlist, stats, git, args.merge, args.pathspec)
+
+    # Missing files
+    if filelist:
+        # Try to find them in merge logs, if not done already
+        # (usually HUGE, thus MUCH slower!)
+        if args.missing and not args.merge:
+            filterlist = list(filelist)
+            missing = len(filterlist)
+            log.info("{0:,} files not found in log, trying merge commits".format(missing))
+            for i in range(0, missing, STEPMISSING):
+                parse_log(filelist, dirlist, stats, git,
+                          merge=True, filterlist=filterlist[i:i + STEPMISSING])
+
+        # Still missing some?
+        for file in filelist:
+            log.warning("WARNING: not found in the log: %s", file)
+
+    # Final statistics
+    # Suggestion: use git-log --before=mtime to brag about skipped log entries
+    def log_info(msg, *a, width=13):
+        ifmt = '{:%d,}'    % (width,)  # not using 'n' for consistency with ffmt
+        ffmt = '{:%d,.2f}' % (width,)
+        # %-formatting lacks a thousand separator, must pre-render with .format()
+        log.info(msg.replace('%d', ifmt).replace('%f', ffmt).format(*a))
+
+    log_info(
+        "Statistics:\n"
+        "%f seconds\n"
+        "%d log lines processed\n"
+        "%d commits evaluated",
+        time.time() - start, stats['loglines'], stats['commits'])
+
+    if args.dirs:
+        if stats['direrrors']: log_info("%d directory update errors", stats['direrrors'])
+        log_info("%d directories updated", stats['dirtouches'])
+
+    if stats['touches'] != stats['totalfiles']:
+                        log_info("%d files",              stats['totalfiles'])
+    if stats['skip']:   log_info("%d files skipped",      stats['skip'])
+    if stats['files']:  log_info("%d files missing",      stats['files'])
+    if stats['errors']: log_info("%d file update errors", stats['errors'])
+
+    log_info("%d files updated", stats['touches'])
+
+    if args.test:
+        log.info("TEST RUN - No files modified!")
+
+
+# Keep only essential, global assignments here. Any other logic must be in main()
+log = setup_logging()
+args = parse_args()
+
+# Set the actual touch() and other functions based on command-line arguments
+if args.unique_times:
+    touch = touch_ns
+    isodate = isodate_ns
+
+# Make sure this is always set last to ensure --test behaves as intended
+if args.test:
+    touch = dummy
+
+# UI done, it's showtime!
+try:
+    sys.exit(main())
+except KeyboardInterrupt:
+    log.info("\nAborting")
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    os.kill(os.getpid(), signal.SIGINT)

.github/workflows/_lint.yml

@@ -9,38 +9,134 @@ on:
         description: "From which folder this pipeline executes"
 
 env:
-  POETRY_VERSION: "1.4.2"
+  POETRY_VERSION: "1.5.1"
+  WORKDIR: ${{ inputs.working-directory == '' && '.' || inputs.working-directory }}
 
 jobs:
   build:
-    defaults:
-      run:
-        working-directory: ${{ inputs.working-directory }}
     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.
+        # It's extremely unlikely that there's a lint issue on any version in between
+        # that doesn't show up on the min or max versions.
+        #
+        # GitHub rate-limits how many jobs can be running at any one time.
+        # Starting new jobs is also relatively slow,
+        # so linting on fewer versions makes CI faster.
         python-version:
           - "3.8"
-          - "3.9"
-          - "3.10"
           - "3.11"
     steps:
       - uses: actions/checkout@v3
-      - name: Install poetry
+        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: |
-          pipx install poetry==$POETRY_VERSION
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+          # 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"
         with:
           python-version: ${{ matrix.python-version }}
-          cache: poetry
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
+          cache-key: lint
+
+      - name: Check Poetry File
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: |
+          poetry check
+
+      - name: Check lock file
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: |
+          poetry lock --check
+
       - name: Install dependencies
+        working-directory: ${{ inputs.working-directory }}
         run: |
           poetry install
+
       - name: Install langchain editable
-        if: ${{ inputs.working-directory != 'langchain' }}
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.working-directory != 'libs/langchain' }}
         run: |
           pip install -e ../langchain
+
+      - name: Restore black cache
+        uses: actions/cache@v3
+        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 }}-
+
+      - name: Get .mypy_cache to speed up mypy
+        uses: actions/cache@v3
+        env:
+          SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
+        with:
+          path: |
+            ${{ env.WORKDIR }}/.mypy_cache
+          key: mypy-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', env.WORKDIR)) }}
+
       - 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

@@ -0,0 +1,81 @@
+name: pydantic v1/v2 compatibility
+
+on:
+  workflow_call:
+    inputs:
+      working-directory:
+        required: true
+        type: string
+        description: "From which folder this pipeline executes"
+
+env:
+  POETRY_VERSION: "1.5.1"
+
+jobs:
+  build:
+    defaults:
+      run:
+        working-directory: ${{ inputs.working-directory }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+    name: Pydantic v1/v2 compatibility - Python ${{ matrix.python-version }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
+          cache-key: pydantic-cross-compat
+
+      - name: Install dependencies
+        shell: bash
+        run: poetry install
+
+      - name: Install the opposite major version of pydantic
+        # If normal tests use pydantic v1, here we'll use v2, and vice versa.
+        shell: bash
+        run: |
+          # Determine the major part of pydantic version
+          REGULAR_VERSION=$(poetry run python -c "import pydantic; print(pydantic.__version__)" | cut -d. -f1)
+
+          if [[ "$REGULAR_VERSION" == "1" ]]; then
+            PYDANTIC_DEP=">=2.1,<3"
+            TEST_WITH_VERSION="2"
+          elif [[ "$REGULAR_VERSION" == "2" ]]; then
+            PYDANTIC_DEP="<2"
+            TEST_WITH_VERSION="1"
+          else
+            echo "Unexpected pydantic major version '$REGULAR_VERSION', cannot determine which version to use for cross-compatibility test."
+            exit 1
+          fi
+
+          # Install via `pip` instead of `poetry add` to avoid changing lockfile,
+          # which would prevent caching from working: the cache would get saved
+          # to a different key than where it gets loaded from.
+          poetry run pip install "pydantic${PYDANTIC_DEP}"
+
+          # Ensure that the correct pydantic is installed now.
+          echo "Checking pydantic version... Expecting ${TEST_WITH_VERSION}"
+
+          # Determine the major part of pydantic version
+          CURRENT_VERSION=$(poetry run python -c "import pydantic; print(pydantic.__version__)" | cut -d. -f1)
+
+          # Check that the major part of pydantic version is as expected, if not
+          # raise an error
+          if [[ "$CURRENT_VERSION" != "$TEST_WITH_VERSION" ]]; then
+            echo "Error: expected pydantic version ${CURRENT_VERSION} to have been installed, but found: ${TEST_WITH_VERSION}"
+            exit 1
+          fi
+          echo "Found pydantic version ${CURRENT_VERSION}, as expected"
+      - name: Run pydantic compatibility tests
+        shell: bash
+        run: make test

.github/workflows/_release.yml

@@ -9,26 +9,37 @@ on:
         description: "From which folder this pipeline executes"
 
 env:
-  POETRY_VERSION: "1.4.2"
+  POETRY_VERSION: "1.5.1"
 
 jobs:
   if_release:
-    if: |
-        ${{ github.event.pull_request.merged == true }}
-        && ${{ contains(github.event.pull_request.labels.*.name, 'release') }}
+    # Disallow publishing from branches that aren't `master`.
+    if: github.ref == 'refs/heads/master'
     runs-on: ubuntu-latest
+    permissions:
+      # This permission is used for trusted publishing:
+      # https://blog.pypi.org/posts/2023-04-20-introducing-trusted-publishers/
+      #
+      # Trusted publishing has to also be configured on PyPI for each package:
+      # 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@v3
-      - name: Install poetry
-        run: pipx install poetry==$POETRY_VERSION
-      - name: Set up Python 3.10
-        uses: actions/setup-python@v4
+
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.10"
-          cache: "poetry"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
+          cache-key: release
+
       - name: Build project for distribution
         run: poetry build
       - name: Check Version
@@ -45,8 +56,9 @@ jobs:
           generateReleaseNotes: true
           tag: v${{ steps.check-version.outputs.version }}
           commit: master
-      - name: Publish to PyPI
-        env:
-          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
-        run: |
-          poetry publish
+      - 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,13 +7,9 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
-      test_type:
-        type: string
-        description: "Test types to run"
-        default: '["core", "extended", "core-pydantic-2"]'
 
 env:
-  POETRY_VERSION: "1.4.2"
+  POETRY_VERSION: "1.5.1"
 
 jobs:
   build:
@@ -28,57 +24,22 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
-        test_type: ${{ fromJSON(inputs.test_type) }}
-    name: Python ${{ matrix.python-version }} ${{ matrix.test_type }}
+    name: Python ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@v3
-      - name: Set up Python ${{ matrix.python-version }}
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
         uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
           working-directory: ${{ inputs.working-directory }}
-          poetry-version: "1.4.2"
-          cache-key: ${{ matrix.test_type }}
-          install-command: |
-              if [ "${{ matrix.test_type }}" == "core" ]; then
-                echo "Running core tests, installing dependencies with poetry..."
-                poetry install
-              elif [ "${{ matrix.test_type }}" == "core-pydantic-2" ]; then
-                echo "Running core-pydantic-v2 tests, installing dependencies with poetry..."
-                poetry install
-                poetry add pydantic@2.1
-              else
-                echo "Running extended tests, installing dependencies with poetry..."
-                poetry install -E extended_testing
-              fi
-      - name: Verify pydantic version
-        run: |
-          if [ "${{ matrix.test_type }}" == "core-pydantic-2" ]; then
-            EXPECTED_VERSION=2
-          else
-            EXPECTED_VERSION=1
-          fi
-          echo "Checking pydantic version... Expecting ${EXPECTED_VERSION}"
-          
-          # Determine the major part of pydantic version
-          VERSION=$(poetry run python -c "import pydantic; print(pydantic.__version__)" | cut -d. -f1)
-          
-          # Check that the major part of pydantic version is as expected, if not
-          # raise an error
-          if [[ "$VERSION" -ne $EXPECTED_VERSION ]]; then
-            echo "Error: pydantic version must be equal to ${EXPECTED_VERSION}; Found: ${VERSION}"
-            exit 1
-          fi
-          echo "Found pydantic version ${VERSION}, as expected"
+          cache-key: core
+
+      - name: Install dependencies
         shell: bash
-      - name: Run ${{matrix.test_type}} tests
-        run: |
-          case "${{ matrix.test_type }}" in
-              core | core-pydantic-2)
-                  make test
-                  ;;
-              *)
-                  make extended_tests
-                  ;;
-          esac
+        run: poetry install
+
+      - name: Run core tests
         shell: bash
+        run: make test

.github/workflows/langchain_ci.yml

@@ -8,10 +8,25 @@ on:
     paths:
       - '.github/workflows/_lint.yml'
       - '.github/workflows/_test.yml'
+      - '.github/workflows/_pydantic_compatibility.yml'
       - '.github/workflows/langchain_ci.yml'
       - 'libs/langchain/**'
   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.5.1"
+  WORKDIR: "libs/langchain"
+
 jobs:
   lint:
     uses:
@@ -19,10 +34,50 @@ jobs:
     with:
       working-directory: libs/langchain
     secrets: inherit
+
   test:
     uses:
       ./.github/workflows/_test.yml
     with:
       working-directory: libs/langchain
-      test_type: '["core", "extended"]'
-    secrets: inherit
+    secrets: inherit
+
+  pydantic-compatibility:
+    uses:
+      ./.github/workflows/_pydantic_compatibility.yml
+    with:
+      working-directory: libs/langchain
+    secrets: inherit
+
+  extended-tests:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ${{ env.WORKDIR }}
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+    name: Python ${{ matrix.python-version }} extended tests
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: libs/langchain
+          cache-key: extended
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          echo "Running extended tests, installing dependencies with poetry..."
+          poetry install -E extended_testing
+
+      - name: Run extended tests
+        run: make extended_tests

.github/workflows/langchain_experimental_ci.yml

@@ -13,6 +13,20 @@ on:
       - 'libs/experimental/**'
   workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
 
+# If another push to the same PR or branch happens while this workflow is still running,
+# cancel the earlier run in favor of the next run.
+#
+# There's no point in testing an outdated version of the code. GitHub only allows
+# a limited number of job runners to be active at the same time, so it's better to cancel
+# pointless jobs early so that more useful jobs can run sooner.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  POETRY_VERSION: "1.5.1"
+  WORKDIR: "libs/experimental"
+
 jobs:
   lint:
     uses:
@@ -20,10 +34,82 @@ jobs:
     with:
       working-directory: libs/experimental
     secrets: inherit
+
   test:
     uses:
       ./.github/workflows/_test.yml
     with:
       working-directory: libs/experimental
-      test_type: '["core"]'
-    secrets: inherit
+    secrets: inherit
+
+  # It's possible that langchain-experimental works fine with the latest *published* langchain,
+  # but is broken with the langchain on `master`.
+  #
+  # We want to catch situations like that *before* releasing a new langchain, hence this test.
+  test-with-latest-langchain:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ${{ env.WORKDIR }}
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+    name: test with unpublished langchain - Python ${{ matrix.python-version }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ env.WORKDIR }}
+          cache-key: unpublished-langchain
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          echo "Running tests with unpublished langchain, installing dependencies with poetry..."
+          poetry install
+
+          echo "Editably installing langchain outside of poetry, to avoid messing up lockfile..."
+          poetry run pip install -e ../langchain
+
+      - name: Run tests
+        run: make test
+  extended-tests:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ${{ env.WORKDIR }}
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+    name: Python ${{ matrix.python-version }} extended tests
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: libs/experimental
+          cache-key: extended
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          echo "Running extended tests, installing dependencies with poetry..."
+          poetry install -E extended_testing
+
+      - name: Run extended tests
+        run: make extended_tests

.github/workflows/langchain_experimental_release.yml

@@ -2,13 +2,6 @@
 name: libs/experimental Release
 
 on:
-  pull_request:
-    types:
-      - closed
-    branches:
-      - master
-    paths:
-      - 'libs/experimental/pyproject.toml'
   workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
 
 jobs:
@@ -17,4 +10,4 @@ jobs:
       ./.github/workflows/_release.yml
     with:
       working-directory: libs/experimental
-    secrets: inherit
+    secrets: inherit

.github/workflows/langchain_release.yml

@@ -2,13 +2,6 @@
 name: libs/langchain Release
 
 on:
-  pull_request:
-    types:
-      - closed
-    branches:
-      - master
-    paths:
-      - 'libs/langchain/pyproject.toml'
   workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
 
 jobs:
@@ -17,4 +10,4 @@ jobs:
       ./.github/workflows/_release.yml
     with:
       working-directory: libs/langchain
-    secrets: inherit
+    secrets: inherit

.github/workflows/scheduled_test.yml

@@ -6,7 +6,7 @@ on:
     - cron:  '0 13 * * *'
 
 env:
-  POETRY_VERSION: "1.4.2"
+  POETRY_VERSION: "1.5.1"
 
 jobs:
   build:
@@ -25,18 +25,25 @@ jobs:
     name: Python ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@v3
+
       - name: Set up Python ${{ matrix.python-version }}
         uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          poetry-version: "1.4.2"
+          poetry-version: ${{ env.POETRY_VERSION }}
           working-directory: libs/langchain
-          install-command: |
-            echo "Running scheduled tests, installing dependencies with poetry..."
-            poetry install --with=test_integration
+          cache-key: scheduled
+
+      - name: Install dependencies
+        working-directory: libs/langchain
+        shell: bash
+        run: |
+          echo "Running scheduled tests, installing dependencies with poetry..."
+          poetry install --with=test_integration
+
       - name: Run tests
+        shell: bash
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
         run: |
           make scheduled_tests
-        shell: bash

README.md

@@ -2,18 +2,18 @@
 
 ⚡ Building applications with LLMs through composability ⚡
 
-[![Release Notes](https://img.shields.io/github/release/hwchase17/langchain)](https://github.com/hwchase17/langchain/releases)
-[![CI](https://github.com/hwchase17/langchain/actions/workflows/langchain_ci.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/langchain_ci.yml)
-[![Experimental CI](https://github.com/hwchase17/langchain/actions/workflows/langchain_experimental_ci.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/langchain_experimental_ci.yml)
+[![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/releases)
+[![CI](https://github.com/langchain-ai/langchain/actions/workflows/langchain_ci.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/langchain_ci.yml)
+[![Experimental CI](https://github.com/langchain-ai/langchain/actions/workflows/langchain_experimental_ci.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/langchain_experimental_ci.yml)
 [![Downloads](https://static.pepy.tech/badge/langchain/month)](https://pepy.tech/project/langchain)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
 [![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
-[![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/hwchase17/langchain)
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/hwchase17/langchain)
-[![GitHub star chart](https://img.shields.io/github/stars/hwchase17/langchain?style=social)](https://star-history.com/#hwchase17/langchain)
+[![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)
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/langchain-ai/langchain)
+[![GitHub star chart](https://img.shields.io/github/stars/langchain-ai/langchain?style=social)](https://star-history.com/#langchain-ai/langchain)
 [![Dependency Status](https://img.shields.io/librariesio/github/langchain-ai/langchain)](https://libraries.io/github/langchain-ai/langchain)
-[![Open Issues](https://img.shields.io/github/issues-raw/hwchase17/langchain)](https://github.com/hwchase17/langchain/issues)
+[![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/hwchase17/langchainjs).

SECURITY.md

@@ -0,0 +1,6 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security vulnerabilities by email to `security@langchain.dev`.
+This email is an alias to a subset of our maintainers, and will ensure the issue is promptly triaged and acted upon as needed.

docs/api_reference/conf.py

@@ -156,7 +156,7 @@ html_context = {
 html_static_path = ["_static"]
 
 # These paths are either relative to html_static_path
-# or fully qualified paths (eg. https://...)
+# or fully qualified paths (e.g. https://...)
 html_css_files = [
     "css/custom.css",
 ]

docs/api_reference/create_api_rst.py

@@ -150,7 +150,8 @@ def _load_package_modules(
 
         relative_module_name = file_path.relative_to(package_path)
 
-        if relative_module_name.name.startswith("_"):
+        # Skip if any module part starts with an underscore
+        if any(part.startswith("_") for part in relative_module_name.parts):
             continue
 
         # Get the full namespace of the module
@@ -227,7 +228,7 @@ Classes
     :toctree: {module}
 """
 
-            for class_ in classes:
+            for class_ in sorted(classes, key=lambda c: c["qualified_name"]):
                 if not class_["is_public"]:
                     continue
 

docs/api_reference/guide_imports.json

@@ -338,10 +338,11 @@
         "Neptune Open Cypher QA Chain": "https://python.langchain.com/docs/use_cases/more/graph/neptune_cypher_qa",
         "NebulaGraphQAChain": "https://python.langchain.com/docs/use_cases/more/graph/graph_nebula_qa",
         "KuzuQAChain": "https://python.langchain.com/docs/use_cases/more/graph/graph_kuzu_qa",
+        "FalkorDBQAChain": "https://python.langchain.com/docs/use_cases/more/graph/graph_falkordb_qa",
         "HugeGraph QA Chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_hugegraph_qa",
         "GraphSparqlQAChain": "https://python.langchain.com/docs/use_cases/more/graph/graph_sparql_qa",
         "ArangoDB QA chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_arangodb_qa",
-        "Graph DB QA chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_cypher_qa",
+        "Neo4j DB QA chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_cypher_qa",
         "How to use a SmartLLMChain": "https://python.langchain.com/docs/use_cases/more/self_check/smart_llm",
         "Multi-Agent Simulated Environment: Petting Zoo": "https://python.langchain.com/docs/use_cases/agent_simulations/petting_zoo",
         "Multi-agent decentralized speaker selection": "https://python.langchain.com/docs/use_cases/agent_simulations/multiagent_bidding",
@@ -2071,8 +2072,8 @@
         "PromptLayer": "https://python.langchain.com/docs/integrations/providers/promptlayer",
         "PromptLayer OpenAI": "https://python.langchain.com/docs/integrations/llms/promptlayer_openai"
     },
-    "DeepLake": {
-        "Deep Lake": "https://python.langchain.com/docs/integrations/providers/deeplake",
+    "Activeloop DeepLake": {
+        "Deep Lake": "https://python.langchain.com/docs/integrations/providers/activeloop_deeplake",
         "Activeloop's Deep Lake": "https://python.langchain.com/docs/integrations/vectorstores/activeloop_deeplake",
         "Analysis of Twitter the-algorithm source code with LangChain, GPT4 and Activeloop's Deep Lake": "https://python.langchain.com/docs/use_cases/question_answering/how_to/code/twitter-the-algorithm-analysis-deeplake",
         "Use LangChain, GPT and Activeloop's Deep Lake to work with code base": "https://python.langchain.com/docs/use_cases/question_answering/how_to/code/code-analysis-deeplake",
@@ -3174,6 +3175,12 @@
     "KuzuQAChain": {
         "KuzuQAChain": "https://python.langchain.com/docs/use_cases/more/graph/graph_kuzu_qa"
     },
+    "FalkorDBGraph": {
+        "KuzuQAChain": "https://python.langchain.com/docs/use_cases/more/graph/graph_falkordb_qa"
+    },
+    "FalkorDBQAChain": {
+        "FalkorDB QA Chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_falkordb_qa"
+    },
     "HugeGraphQAChain": {
         "HugeGraph QA Chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_hugegraph_qa"
     },
@@ -3202,10 +3209,10 @@
         "Graph QA": "https://python.langchain.com/docs/use_cases/more/graph/graph_qa"
     },
     "GraphCypherQAChain": {
-        "Graph DB QA chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_cypher_qa"
+        "Neo4j DB QA chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_cypher_qa"
     },
     "Neo4jGraph": {
-        "Graph DB QA chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_cypher_qa"
+        "Neo4j DB QA chain": "https://python.langchain.com/docs/use_cases/more/graph/graph_cypher_qa"
     },
     "LLMBashChain": {
         "Bash chain": "https://python.langchain.com/docs/use_cases/more/code_writing/llm_bash"

docs/api_reference/requirements.txt

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

docs/api_reference/templates/redirects.html

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

docs/docs_skeleton/docs/community.md

@@ -28,7 +28,7 @@ LangChain is the product of over 5,000+ contributions by 1,500+ contributors, an
 # 🌍 Meetups, Events, and Hackathons
 
 One of our favorite things about working in AI is how much enthusiasm there is for building together. We want to help make that as easy and impactful for you as possible! 
-- **Find a meetup, hackathon, or webinar:** you can find the one for you on on our [global events calendar](https://mirror-feeling-d80.notion.site/0bc81da76a184297b86ca8fc782ee9a3?v=0d80342540df465396546976a50cfb3f).  
+- **Find a meetup, hackathon, or webinar:** you can find the one for you on our [global events calendar](https://mirror-feeling-d80.notion.site/0bc81da76a184297b86ca8fc782ee9a3?v=0d80342540df465396546976a50cfb3f).  
     - **Submit an event to our calendar:** email us at events@langchain.dev with a link to your event page! We can also help you spread the word with our local communities.
 - **Host a meetup:** If you want to bring a group of builders together, we want to help! We can publicize your event on our event calendar/Twitter, share with our local communities in Discord, send swag, or potentially hook you up with a sponsor. Email us at events@langchain.dev to tell us about your event!
 - **Become a meetup sponsor:** we often hear from groups of builders that want to get together, but are blocked or limited on some dimension (space to host, budget for snacks, prizes to distribute, etc.). If you’d like to help, send us an email to events@langchain.dev we can share more about how it works!
@@ -47,8 +47,8 @@ If you’re working on something you’re proud of, and think the LangChain comm
 
 Here’s where our team hangs out, talks shop, spotlights cool work, and shares what we’re up to. We’d love to see you there too.
 
-- **[Twitter](https://twitter.com/LangChainAI):** we post about what we’re working on and what cool things we’re seeing in the space. If you tag @langchainai in your post, we’ll almost certainly see it, and can snow you some love!
-- **[Discord](https://discord.gg/6adMQxSpJS):** connect with with >30k developers who are building with LangChain
+- **[Twitter](https://twitter.com/LangChainAI):** we post about what we’re working on and what cool things we’re seeing in the space. If you tag @langchainai in your post, we’ll almost certainly see it, and can show you some love!
+- **[Discord](https://discord.gg/6adMQxSpJS):** connect with >30k developers who are building with LangChain
 - **[GitHub](https://github.com/langchain-ai/langchain):** open pull requests, contribute to a discussion, and/or contribute
 - **[Subscribe to our bi-weekly Release Notes](https://6w1pwbss0py.typeform.com/to/KjZB1auB):** a twice/month email roundup of the coolest things going on in our orbit
 - **Slack:** if you’re building an application in production at your company, we’d love to get into a Slack channel together. Fill out [this form](https://airtable.com/appwQzlErAS2qiP0L/shrGtGaVBVAz7NcV2) and we’ll get in touch about setting one up.

docs/docs_skeleton/docs/expression_language/index.mdx

@@ -0,0 +1,14 @@
+---
+sidebar_class_name: hidden
+---
+
+# LangChain Expression Language (LCEL)
+
+LangChain Expression Language or LCEL is a declarative way to easily compose chains together.
+Any chain constructed this way will automatically have full sync, async, and streaming support.
+
+#### [Interface](/docs/expression_language/interface)
+The base interface shared by all LCEL objects
+
+#### [Cookbook](/docs/expression_language/cookbook)
+Examples of common LCEL usage patterns

docs/docs_skeleton/docs/get_started/introduction.mdx

@@ -28,7 +28,7 @@ LangChain provides standard, extendable interfaces and external integrations for
 
 #### [Model I/O](/docs/modules/model_io/)
 Interface with language models
-#### [Data connection](/docs/modules/data_connection/)
+#### [Retrieval](/docs/modules/data_connection/)
 Interface with application-specific data
 #### [Chains](/docs/modules/chains/)
 Construct sequences of calls
@@ -42,23 +42,22 @@ Log and stream intermediate steps of any chain
 ## Examples, ecosystem, and resources
 ### [Use cases](/docs/use_cases/)
 Walkthroughs and best-practices for common end-to-end use cases, like:
-- [Chatbots](/docs/use_cases/chatbots/)
+- [Chatbots](/docs/use_cases/chatbots)
 - [Answering questions using sources](/docs/use_cases/question_answering/)
-- [Analyzing structured data](/docs/use_cases/tabular.html)
+- [Analyzing structured data](/docs/use_cases/sql)
 - and much more...
 
 ### [Guides](/docs/guides/)
 Learn best practices for developing with LangChain.
 
 ### [Ecosystem](/docs/ecosystem/)
-LangChain is part of a rich ecosystem of tools that integrate with our framework and build on top of it. Check out our growing list of [integrations](/docs/integrations/) and [dependent repos](/docs/ecosystem/dependents).
+LangChain is part of a rich ecosystem of tools that integrate with our framework and build on top of it. Check out our growing list of [integrations](/docs/integrations/) and [dependent repos](/docs/additional_resources/dependents).
 
 ### [Additional resources](/docs/additional_resources/)
 Our community is full of prolific developers, creative builders, and fantastic teachers. Check out [YouTube tutorials](/docs/additional_resources/youtube.html) for great tutorials from folks in the community, and [Gallery](https://github.com/kyrolabs/awesome-langchain) for a list of awesome LangChain projects, compiled by the folks at [KyroLabs](https://kyrolabs.com).
 
-<h3><span style={{color:"#2e8555"}}> Support </span></h3>
-
-Join us on [GitHub](https://github.com/hwchase17/langchain) or [Discord](https://discord.gg/6adMQxSpJS) to ask questions, share feedback, meet other developers building with LangChain, and dream about the future of LLM’s.
+### [Community](/docs/community)
+Head to the [Community navigator](/docs/community) to find places to ask questions, share feedback, meet other developers, and dream about the future of LLM’s.
 
 ## API reference
 

docs/docs_skeleton/docs/get_started/quickstart.mdx

@@ -59,8 +59,8 @@ LangChain provides several objects to easily distinguish between different roles
 If none of those roles sound right, there is also a `ChatMessage` class where you can specify the role manually.
 For more information on how to use these different messages most effectively, see our prompting guide.
 
-LangChain exposes a standard interface for both, but it's useful to understand this difference in order to construct prompts for a given language model.
-The standard interface that LangChain exposes has two methods:
+LangChain provides a standard interface for both, but it's useful to understand this difference in order to construct prompts for a given language model.
+The standard interface that LangChain provides has two methods:
 - `predict`: Takes in a string, returns a string
 - `predict_messages`: Takes in a list of messages, returns a message.
 
@@ -107,7 +107,7 @@ import PromptTemplateChatModel from "@snippets/get_started/quickstart/prompt_tem
 <PromptTemplateLLM/>
 
 However, the advantages of using these over raw string formatting are several.
-You can "partial" out variables - eg you can format only some of the variables at a time.
+You can "partial" out variables - e.g. you can format only some of the variables at a time.
 You can compose them together, easily combining different templates into a single prompt.
 For explanations of these functionalities, see the [section on prompts](/docs/modules/model_io/prompts) for more detail.
 
@@ -121,12 +121,12 @@ Let's take a look at this below:
 
 ChatPromptTemplates can also include other things besides ChatMessageTemplates - see the [section on prompts](/docs/modules/model_io/prompts) for more detail.
 
-## Output Parsers
+## Output parsers
 
 OutputParsers convert the raw output of an LLM into a format that can be used downstream.
 There are few main type of OutputParsers, including:
 
-- Convert text from LLM -> structured information (eg JSON)
+- Convert text from LLM -> structured information (e.g. JSON)
 - Convert a ChatMessage into just a string
 - Convert the extra information returned from a call besides the message (like OpenAI function invocation) into a string.
 
@@ -149,7 +149,7 @@ import LLMChain from "@snippets/get_started/quickstart/llm_chain.mdx"
 
 <LLMChain/>
 
-## Next Steps
+## Next steps
 
 This is it!
 We've now gone over how to create the core building block of LangChain applications - the LLMChains.

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

@@ -3,7 +3,7 @@ sidebar_position: 3
 ---
 # Comparison Evaluators
 
-Comparison evaluators in LangChain help measure two different chain or LLM outputs. These evaluators are helpful for comparative analyses, such as A/B testing between two language models, or comparing different versions of the same model. They can also be useful for things like generating preference scores for ai-assisted reinforcement learning.
+Comparison evaluators in LangChain help measure two different chains or LLM outputs. These evaluators are helpful for comparative analyses, such as A/B testing between two language models, or comparing different versions of the same model. They can also be useful for things like generating preference scores for ai-assisted reinforcement learning.
 
 These evaluators inherit from the `PairwiseStringEvaluator` class, providing a comparison interface for two strings - typically, the outputs from two different prompts or models, or two versions of the same model. In essence, a comparison evaluator performs an evaluation on a pair of strings and returns a dictionary containing the evaluation score and other relevant details.
 
@@ -16,7 +16,7 @@ Here's a summary of the key methods and properties of a comparison evaluator:
 - `requires_input`: This property indicates whether this evaluator requires an input string.
 - `requires_reference`: This property specifies whether this evaluator requires a reference label.
 
-Detailed information about creating custom evaluators and the available built-in comparison evaluators are provided in the following sections.
+Detailed information about creating custom evaluators and the available built-in comparison evaluators is provided in the following sections.
 
 import DocCardList from "@theme/DocCardList";
 

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

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

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

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

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

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

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

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

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

@@ -37,11 +37,11 @@ This agent is designed to be used in conversational settings.
 The prompt is designed to make the agent helpful and conversational.
 It uses the ReAct framework to decide which tool to use, and uses memory to remember the previous conversation interactions.
 
-### [Self ask with search](/docs/modules/agents/agent_types/self_ask_with_search.html)
+### [Self-ask with search](/docs/modules/agents/agent_types/self_ask_with_search.html)
 
 This agent utilizes a single tool that should be named `Intermediate Answer`.
 This tool should be able to lookup factual answers to questions. This agent
-is equivalent to the original [self ask with search paper](https://ofir.io/self-ask.pdf),
+is equivalent to the original [self-ask with search paper](https://ofir.io/self-ask.pdf),
 where a Google search API was provided as the tool.
 
 ### [ReAct document store](/docs/modules/agents/agent_types/react_docstore.html)
@@ -54,4 +54,4 @@ This agent is equivalent to the
 original [ReAct paper](https://arxiv.org/pdf/2210.03629.pdf), specifically the Wikipedia example.
 
 ## [Plan-and-execute agents](/docs/modules/agents/agent_types/plan_and_execute.html)
-Plan and execute agents accomplish an objective by first planning what to do, then executing the sub tasks. This idea is largely inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) and then the ["Plan-and-Solve" paper](https://arxiv.org/abs/2305.04091).
+Plan-and-execute agents accomplish an objective by first planning what to do, then executing the sub tasks. This idea is largely inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) and then the ["Plan-and-Solve" paper](https://arxiv.org/abs/2305.04091).

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

@@ -1,6 +1,6 @@
-# Plan and execute
+# Plan-and-execute
 
-Plan and execute agents accomplish an objective by first planning what to do, then executing the sub tasks. This idea is largely inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) and then the ["Plan-and-Solve" paper](https://arxiv.org/abs/2305.04091).
+Plan-and-execute agents accomplish an objective by first planning what to do, then executing the sub tasks. This idea is largely inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) and then the ["Plan-and-Solve" paper](https://arxiv.org/abs/2305.04091).
 
 The planning is almost always done by an LLM.
 

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -30,4 +30,4 @@ Chains allow us to combine multiple components together to create a single, cohe
 
 import GetStarted from "@snippets/modules/chains/get_started.mdx"
 
-<GetStarted/>
+<GetStarted/>

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

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

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

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

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

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

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

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

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

@@ -2,15 +2,60 @@
 sidebar_position: 1
 ---
 
-# Data connection
+# Retrieval
 
-Many LLM applications require user-specific data that is not part of the model's training set. LangChain gives you the 
-building blocks to load, transform, store and query your data via:
+Many LLM applications require user-specific data that is not part of the model's training set.
+The primary way of accomplishing this is through Retrieval Augmented Generation (RAG).
+In this process, external data is *retrieved* and then passed to the LLM when doing the *generation* step.
 
-- [Document loaders](/docs/modules/data_connection/document_loaders/): Load documents from many different sources
-- [Document transformers](/docs/modules/data_connection/document_transformers/): Split documents, convert documents into Q&A format, drop redundant documents, and more
-- [Text embedding models](/docs/modules/data_connection/text_embedding/): Take unstructured text and turn it into a list of floating point numbers
-- [Vector stores](/docs/modules/data_connection/vectorstores/): Store and search over embedded data
-- [Retrievers](/docs/modules/data_connection/retrievers/): Query your data
+LangChain provides all the building blocks for RAG applications - from simple to complex.
+This section of the documentation covers everything related to the *retrieval* step - e.g. the fetching of the data.
+Although this sounds simple, it can be subtly complex.
+This encompasses several key modules.
 
 ![data_connection_diagram](/img/data_connection.jpg)
+
+**[Document loaders](/docs/modules/data_connection/document_loaders/)**
+
+Load documents from many different sources.
+LangChain provides over 100 different document loaders as well as integrations with other major providers in the space,
+like AirByte and Unstructured.
+We provide integrations to load all types of documents (HTML, PDF, code) from all types of locations (private s3 buckets, public websites).
+
+**[Document transformers](/docs/modules/data_connection/document_transformers/)**
+
+A key part of retrieval is fetching only the relevant parts of documents.
+This involves several transformation steps in order to best prepare the documents for retrieval.
+One of the primary ones here is splitting (or chunking) a large document into smaller chunks.
+LangChain provides several different algorithms for doing this, as well as logic optimized for specific document types (code, markdown, etc).
+
+**[Text embedding models](/docs/modules/data_connection/text_embedding/)**
+
+Another key part of retrieval has become creating embeddings for documents.
+Embeddings capture the semantic meaning of the text, allowing you to quickly and
+efficiently find other pieces of text that are similar.
+LangChain provides integrations with over 25 different embedding providers and methods,
+from open-source to proprietary API,
+allowing you to choose the one best suited for your needs.
+LangChain provides a standard interface, allowing you to easily swap between models.
+
+**[Vector stores](/docs/modules/data_connection/vectorstores/)**
+
+With the rise of embeddings, there has emerged a need for databases to support efficient storage and searching of these embeddings.
+LangChain provides integrations with over 50 different vectorstores, from open-source local ones to cloud-hosted proprietary ones,
+allowing you to choose the one best suited for your needs.
+LangChain exposes a standard interface, allowing you to easily swap between vector stores.
+
+**[Retrievers](/docs/modules/data_connection/retrievers/)**
+
+Once the data is in the database, you still need to retrieve it.
+LangChain supports many different retrieval algorithms and is one of the places where we add the most value.
+We support basic methods that are easy to get started - namely simple semantic search.
+However, we have also added a collection of algorithms on top of this to increase performance.
+These include:
+
+- [Parent Document Retriever](/docs/modules/data_connection/retrievers/parent_document_retriever): This allows you to create multiple embeddings per parent document, allowing you to look up smaller chunks but return larger context.
+- [Self Query Retriever](/docs/modules/data_connection/retrievers/self_query): User questions often contain a reference to something that isn't just semantic but rather expresses some logic that can best be represented as a metadata filter. Self-query allows you to parse out the *semantic* part of a query from other *metadata filters* present in the query.
+- [Ensemble Retriever](/docs/modules/data_connection/retrievers/ensemble): Sometimes you may want to retrieve documents from multiple different sources, or using multiple different algorithms. The ensemble retriever allows you to easily do this.
+- And more!
+

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

@@ -5,10 +5,10 @@ One challenge with retrieval is that usually you don't know the specific queries
 Contextual compression is meant to fix this. The idea is simple: instead of immediately returning retrieved documents as-is, you can compress them using the context of the given query, so that only the relevant information is returned. “Compressing” here refers to both compressing the contents of an individual document and filtering out documents wholesale.
 
 To use the Contextual Compression Retriever, you'll need:
-- a base Retriever
+- a base retriever
 - a Document Compressor
 
-The Contextual Compression Retriever passes queries to the base Retriever, takes the initial documents and passes them through the Document Compressor. The Document Compressor takes a list of Documents and shortens it by reducing the contents of Documents or dropping Documents altogether.
+The Contextual Compression Retriever passes queries to the base retriever, takes the initial documents and passes them through the Document Compressor. The Document Compressor takes a list of documents and shortens it by reducing the contents of documents or dropping documents altogether.
 
 ![](https://drive.google.com/uc?id=1CtNgWODXZudxAWSRiWgSGEoTNrUFT98v)
 

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

@@ -8,7 +8,7 @@ Head to [Integrations](/docs/integrations/retrievers/) for documentation on buil
 :::
 
 A retriever is an interface that returns documents given an unstructured query. It is more general than a vector store.
-A retriever does not need to be able to store documents, only to return (or retrieve) it. Vector stores can be used
+A retriever does not need to be able to store documents, only to return (or retrieve) them. Vector stores can be used
 as the backbone of a retriever, but there are other types of retrievers as well.
 
 ## Get started

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

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

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

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

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

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

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

@@ -11,7 +11,7 @@ The Embeddings class is a class designed for interfacing with text embedding mod
 
 Embeddings create a vector representation of a piece of text. This is useful because it means we can think about text in the vector space, and do things like semantic search where we look for pieces of text that are most similar in the vector space.
 
-The base Embeddings class in LangChain exposes two methods: one for embedding documents and one for embedding a query. The former takes as input multiple texts, while the latter takes a single text. The reason for having these as two separate methods is that some embedding providers have different embedding methods for documents (to be searched over) vs queries (the search query itself).
+The base Embeddings class in LangChain provides two methods: one for embedding documents and one for embedding a query. The former takes as input multiple texts, while the latter takes a single text. The reason for having these as two separate methods is that some embedding providers have different embedding methods for documents (to be searched over) vs queries (the search query itself).
 
 ## Get started
 

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

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

docs/docs_skeleton/docs/modules/index.mdx

@@ -8,7 +8,7 @@ LangChain provides standard, extendable interfaces and external integrations for
 
 #### [Model I/O](/docs/modules/model_io/)
 Interface with language models
-#### [Data connection](/docs/modules/data_connection/)
+#### [Retrieval](/docs/modules/data_connection/)
 Interface with application-specific data
 #### [Chains](/docs/modules/chains/)
 Construct sequences of calls

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

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

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

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

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

@@ -1,4 +1,4 @@
-# Conversation buffer memory
+# Conversation Buffer
 
 This notebook shows how to use `ConversationBufferMemory`. This memory allows for storing of messages and then extracts the messages in a variable.
 

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 # Caching
-LangChain provides an optional caching layer for Chat Models. This is useful for two reasons:
+LangChain provides an optional caching layer for chat models. This is useful for two reasons:
 
 It can save you money by reducing the number of API calls you make to the LLM provider, if you're often requesting the same completion multiple times.
 It can speed up your application by reducing the number of API calls you make to the LLM provider.

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

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

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

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

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

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

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

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

docs/docs_skeleton/docs/modules/model_io/prompts/prompt_templates/few_shot_examples.mdx

@@ -1,6 +1,6 @@
 # Few-shot prompt templates
 
-In this tutorial, we'll learn how to create a prompt template that uses few shot examples. A few shot prompt template can be constructed from either a set of examples, or from an Example Selector object.
+In this tutorial, we'll learn how to create a prompt template that uses few-shot examples. A few-shot prompt template can be constructed from either a set of examples, or from an Example Selector object.
 
 import Example from "@snippets/modules/model_io/prompts/prompt_templates/few_shot_examples.mdx"
 

docs/docs_skeleton/docs/modules/model_io/prompts/prompt_templates/index.mdx

@@ -6,7 +6,7 @@ sidebar_position: 0
 
 Prompt templates are pre-defined recipes for generating prompts for language models.
 
-A template may include instructions, few shot examples, and specific context and
+A template may include instructions, few-shot examples, and specific context and
 questions appropriate for a given task.
 
 LangChain provides tooling to create and work with prompt templates.

docs/docs_skeleton/docs/modules/model_io/prompts/prompt_templates/partial.mdx

@@ -1,6 +1,6 @@
 # Partial prompt templates
 
-Like other methods, it can make sense to "partial" a prompt template - eg pass in a subset of the required values, as to create a new prompt template which expects only the remaining subset of values.
+Like other methods, it can make sense to "partial" a prompt template - e.g. pass in a subset of the required values, as to create a new prompt template which expects only the remaining subset of values.
 
 LangChain supports this in two ways:
 1. Partial formatting with string values.

docs/docs_skeleton/docs/modules/model_io/prompts/prompt_templates/prompt_composition.mdx

@@ -2,8 +2,8 @@
 
 This notebook goes over how to compose multiple prompts together. This can be useful when you want to reuse parts of prompts. This can be done with a PipelinePrompt. A PipelinePrompt consists of two main parts:
 
-- Final prompt: This is the final prompt that is returned
-- Pipeline prompts: This is a list of tuples, consisting of a string name and a prompt template. Each prompt template will be formatted and then passed to future prompt templates as a variable with the same name.
+- Final prompt: The final prompt that is returned
+- Pipeline prompts: A list of tuples, consisting of a string name and a prompt template. Each prompt template will be formatted and then passed to future prompt templates as a variable with the same name.
 
 import Example from "@snippets/modules/model_io/prompts/prompt_templates/prompt_composition.mdx"
 

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

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

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

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

docs/docs_skeleton/sidebars.js

@@ -44,6 +44,16 @@ module.exports = {
         id: "modules/index"
       },
     },
+    {
+      type: "category",
+      label: "LangChain Expression Language",
+      collapsed: true,
+      items: [{ type: "autogenerated", dirName: "expression_language" } ],
+      link: {
+        type: 'doc',
+        id: "expression_language/index"
+      },
+    },
     {
       type: "category",
       label: "Guides",
@@ -52,17 +62,7 @@ module.exports = {
       link: {
         type: 'generated-index',
         description: 'Design guides for key parts of the development process',
-      slug: "guides",
-      },
-    },
-    {
-      type: "category",
-      label: "Ecosystem",
-      collapsed: true,
-      items: [{ type: "autogenerated", dirName: "ecosystem" }],
-      link: {
-        type: 'generated-index',
-      slug: "ecosystem",
+        slug: "guides",
       },
     },
     {
@@ -72,7 +72,7 @@ module.exports = {
       items: [{ type: "autogenerated", dirName: "additional_resources" }, { type: "link", label: "Gallery", href: "https://github.com/kyrolabs/awesome-langchain" }],
       link: {
         type: 'generated-index',
-      slug: "additional_resources",
+        slug: "additional_resources",
       },
     },
     'community'

docs/docs_skeleton/src/theme/CodeBlock/index.js

@@ -24,8 +24,7 @@ function Imports({ imports }) {
           <li key={imported}>
             <a href={docs}>
               <span>{imported}</span>
-            </a>{" "}
-            from <code>{source}</code>
+            </a>
           </li>
         ))}
       </ul>

docs/docs_skeleton/vercel.json

@@ -1,5 +1,9 @@
 {
   "redirects": [
+    {
+      "source": "/docs/modules/data_connection/caching_embeddings(/?)",
+      "destination": "/docs/modules/data_connection/text_embedding/caching_embeddings"
+    },
     {
       "source": "/en/latest/additional_resources/youtube.html",
       "destination": "/docs/additional_resources/youtube"
@@ -166,7 +170,7 @@
     },
     {
       "source": "/docs/integrations/deeplake",
-      "destination": "/docs/integrations/providers/deeplake"
+      "destination": "/docs/integrations/providers/activeloop_deeplake"
     },
     {
       "source": "/docs/integrations/diffbot",
@@ -2948,6 +2952,46 @@
       "source": "/docs/modules/model_io/models/llms/integrations/writer",
       "destination": "/docs/integrations/llms/writer"
     },
+    {
+      "source": "/docs/integrations/llms/amazon_api_gateway_example",
+      "destination": "/docs/integrations/llms/amazon_api_gateway"
+    },
+    {
+      "source": "/docs/integrations/llms/azureml_endpoint_example",
+      "destination": "/docs/integrations/llms/azure_ml"
+    },
+    {
+      "source": "/docs/integrations/llms/azure_openai_example",
+      "destination": "/docs/integrations/llms/azure_openai"
+    },
+    {
+      "source": "/docs/integrations/llms/cerebriumai_example",
+      "destination": "/docs/integrations/llms/cerebriumai"
+    },
+    {
+      "source": "/docs/integrations/llms/deepinfra_example",
+      "destination": "/docs/integrations/llms/deepinfra"
+    },
+    {
+      "source": "/docs/integrations/llms/Fireworks",
+      "destination": "/docs/integrations/llms/fireworks"
+    },
+    {
+      "source": "/docs/integrations/llms/forefrontai_example",
+      "destination": "/docs/integrations/llms/forefrontai"
+    },
+    {
+      "source": "/docs/integrations/llms/gooseai_example",
+      "destination": "/docs/integrations/llms/gooseai"
+    },
+    {
+      "source": "/docs/integrations/llms/petals_example",
+      "destination": "/docs/integrations/llms/petals"
+    },
+    {
+      "source": "/docs/integrations/llms/pipelineai_example",
+      "destination": "/docs/integrations/llms/pipelineai"
+    },
     {
       "source": "/en/latest/modules/prompts.html",
       "destination": "/docs/modules/model_io/prompts"
@@ -3432,6 +3476,14 @@
       "source": "/docs/modules/chains/additional/graph_kuzu_qa",
       "destination": "/docs/use_cases/more/graph/graph_kuzu_qa"
     },
+    {
+      "source": "/docs/use_cases/graph/graph_falkordb_qa",
+      "destination": "/docs/use_cases/more/graph/graph_falkordb_qa"
+    },
+    {
+      "source": "/docs/modules/chains/additional/graph_falkordb_qa",
+      "destination": "/docs/use_cases/more/graph/graph_falkordb_qa"
+    },
     {
       "source": "/docs/use_cases/graph/graph_nebula_qa",
       "destination": "/docs/use_cases/more/graph/graph_nebula_qa"
@@ -3543,6 +3595,18 @@
     {
       "source": "/en/latest/integrations/:path*",
       "destination": "/docs/integrations/providers/:path*"
+    },
+    {
+      "source": "/docs/guides/expression_language(/?)",
+      "destination": "/docs/expression_language/"
+    },
+    {
+      "source": "/docs/guides/expression_language/:path*",
+      "destination": "/docs/expression_language/:path*"
+    },
+    {
+      "source": "/docs/ecosystem/dependents",
+      "destination": "/docs/additional_resources/dependents"
     }
   ]
 }

docs/extras/_templates/integration.mdx

@@ -47,7 +47,7 @@ from langchain.embeddings import integration_class_REPLACE_ME
 ```
 
 
-## Chat Models
+## Chat models
 
 See a [usage example](/docs/integrations/chat/INCLUDE_REAL_NAME)
 

docs/extras/additional_resources/dependents.mdx

@@ -0,0 +1,376 @@
+# Dependents
+
+Dependents stats for `langchain-ai/langchain`
+
+[![](https://img.shields.io/static/v1?label=Used%20by&message=19495&color=informational&logo=slickpic)](https://github.com/langchain-ai/langchain/network/dependents)
+[![](https://img.shields.io/static/v1?label=Used%20by%20(public)&message=355&color=informational&logo=slickpic)](https://github.com/langchain-ai/langchain/network/dependents)
+[![](https://img.shields.io/static/v1?label=Used%20by%20(private)&message=19140&color=informational&logo=slickpic)](https://github.com/langchain-ai/langchain/network/dependents)
+[![](https://img.shields.io/static/v1?label=Used%20by%20(stars)&message=22524&color=informational&logo=slickpic)](https://github.com/langchain-ai/langchain/network/dependents)
+
+
+[update: `2023-08-17`; only dependent repositories with Stars > 100]
+
+
+| Repository | Stars  |
+| :--------  | -----: |
+|[openai/openai-cookbook](https://github.com/openai/openai-cookbook) | 46276 |
+|[AntonOsika/gpt-engineer](https://github.com/AntonOsika/gpt-engineer) | 41497 |
+|[imartinez/privateGPT](https://github.com/imartinez/privateGPT) | 36296 |
+|[LAION-AI/Open-Assistant](https://github.com/LAION-AI/Open-Assistant) | 34861 |
+|[microsoft/TaskMatrix](https://github.com/microsoft/TaskMatrix) | 33906 |
+|[hpcaitech/ColossalAI](https://github.com/hpcaitech/ColossalAI) | 31654 |
+|[streamlit/streamlit](https://github.com/streamlit/streamlit) | 26571 |
+|[reworkd/AgentGPT](https://github.com/reworkd/AgentGPT) | 25819 |
+|[OpenBB-finance/OpenBBTerminal](https://github.com/OpenBB-finance/OpenBBTerminal) | 23180 |
+|[geekan/MetaGPT](https://github.com/geekan/MetaGPT) | 21968 |
+|[jerryjliu/llama_index](https://github.com/jerryjliu/llama_index) | 20204 |
+|[StanGirard/quivr](https://github.com/StanGirard/quivr) | 20142 |
+|[openai/chatgpt-retrieval-plugin](https://github.com/openai/chatgpt-retrieval-plugin) | 19215 |
+|[mindsdb/mindsdb](https://github.com/mindsdb/mindsdb) | 17580 |
+|[cube-js/cube](https://github.com/cube-js/cube) | 16003 |
+|[PromtEngineer/localGPT](https://github.com/PromtEngineer/localGPT) | 15134 |
+|[mlflow/mlflow](https://github.com/mlflow/mlflow) | 15027 |
+|[chatchat-space/Langchain-Chatchat](https://github.com/chatchat-space/Langchain-Chatchat) | 14024 |
+|[GaiZhenbiao/ChuanhuChatGPT](https://github.com/GaiZhenbiao/ChuanhuChatGPT) | 12020 |
+|[logspace-ai/langflow](https://github.com/logspace-ai/langflow) | 11599 |
+|[openai/evals](https://github.com/openai/evals) | 11509 |
+|[airbytehq/airbyte](https://github.com/airbytehq/airbyte) | 11493 |
+|[databrickslabs/dolly](https://github.com/databrickslabs/dolly) | 10531 |
+|[go-skynet/LocalAI](https://github.com/go-skynet/LocalAI) | 9955 |
+|[AIGC-Audio/AudioGPT](https://github.com/AIGC-Audio/AudioGPT) | 9081 |
+|[gventuri/pandas-ai](https://github.com/gventuri/pandas-ai) | 8201 |
+|[hwchase17/langchainjs](https://github.com/hwchase17/langchainjs) | 7754 |
+|[langgenius/dify](https://github.com/langgenius/dify) | 7348 |
+|[PipedreamHQ/pipedream](https://github.com/PipedreamHQ/pipedream) | 6950 |
+|[h2oai/h2ogpt](https://github.com/h2oai/h2ogpt) | 6858 |
+|[arc53/DocsGPT](https://github.com/arc53/DocsGPT) | 6300 |
+|[0xpayne/gpt-migrate](https://github.com/0xpayne/gpt-migrate) | 6193 |
+|[eosphoros-ai/DB-GPT](https://github.com/eosphoros-ai/DB-GPT) | 6026 |
+|[bentoml/OpenLLM](https://github.com/bentoml/OpenLLM) | 5641 |
+|[jmorganca/ollama](https://github.com/jmorganca/ollama) | 5448 |
+|[e2b-dev/e2b](https://github.com/e2b-dev/e2b) | 5365 |
+|[mage-ai/mage-ai](https://github.com/mage-ai/mage-ai) | 5352 |
+|[wenda-LLM/wenda](https://github.com/wenda-LLM/wenda) | 5192 |
+|[liaokongVFX/LangChain-Chinese-Getting-Started-Guide](https://github.com/liaokongVFX/LangChain-Chinese-Getting-Started-Guide) | 5129 |
+|[zilliztech/GPTCache](https://github.com/zilliztech/GPTCache) | 4993 |
+|[GreyDGL/PentestGPT](https://github.com/GreyDGL/PentestGPT) | 4831 |
+|[zauberzeug/nicegui](https://github.com/zauberzeug/nicegui) | 4824 |
+|[serge-chat/serge](https://github.com/serge-chat/serge) | 4783 |
+|[Shaunwei/RealChar](https://github.com/Shaunwei/RealChar) | 4779 |
+|[gkamradt/langchain-tutorials](https://github.com/gkamradt/langchain-tutorials) | 4752 |
+|[openchatai/OpenChat](https://github.com/openchatai/OpenChat) | 4452 |
+|[intel-analytics/BigDL](https://github.com/intel-analytics/BigDL) | 4286 |
+|[madawei2699/myGPTReader](https://github.com/madawei2699/myGPTReader) | 4167 |
+|[MineDojo/Voyager](https://github.com/MineDojo/Voyager) | 3952 |
+|[embedchain/embedchain](https://github.com/embedchain/embedchain) | 3887 |
+|[postgresml/postgresml](https://github.com/postgresml/postgresml) | 3636 |
+|[assafelovic/gpt-researcher](https://github.com/assafelovic/gpt-researcher) | 3480 |
+|[llm-workflow-engine/llm-workflow-engine](https://github.com/llm-workflow-engine/llm-workflow-engine) | 3445 |
+|[marqo-ai/marqo](https://github.com/marqo-ai/marqo) | 3397 |
+|[kyegomez/tree-of-thoughts](https://github.com/kyegomez/tree-of-thoughts) | 3366 |
+|[RayVentura/ShortGPT](https://github.com/RayVentura/ShortGPT) | 3335 |
+|[Azure-Samples/azure-search-openai-demo](https://github.com/Azure-Samples/azure-search-openai-demo) | 3316 |
+|[langchain-ai/chat-langchain](https://github.com/langchain-ai/chat-langchain) | 3270 |
+|[khoj-ai/khoj](https://github.com/khoj-ai/khoj) | 3266 |
+|[PrefectHQ/marvin](https://github.com/PrefectHQ/marvin) | 3176 |
+|[project-baize/baize-chatbot](https://github.com/project-baize/baize-chatbot) | 2999 |
+|[whitead/paper-qa](https://github.com/whitead/paper-qa) | 2932 |
+|[OpenGVLab/InternGPT](https://github.com/OpenGVLab/InternGPT) | 2816 |
+|[continuedev/continue](https://github.com/continuedev/continue) | 2803 |
+|[ParisNeo/lollms-webui](https://github.com/ParisNeo/lollms-webui) | 2679 |
+|[OpenBMB/ToolBench](https://github.com/OpenBMB/ToolBench) | 2673 |
+|[shroominic/codeinterpreter-api](https://github.com/shroominic/codeinterpreter-api) | 2492 |
+|[OpenBMB/BMTools](https://github.com/OpenBMB/BMTools) | 2486 |
+|[GerevAI/gerev](https://github.com/GerevAI/gerev) | 2450 |
+|[SamurAIGPT/EmbedAI](https://github.com/SamurAIGPT/EmbedAI) | 2448 |
+|[Unstructured-IO/unstructured](https://github.com/Unstructured-IO/unstructured) | 2255 |
+|[Mintplex-Labs/anything-llm](https://github.com/Mintplex-Labs/anything-llm) | 2216 |
+|[emptycrown/llama-hub](https://github.com/emptycrown/llama-hub) | 2198 |
+|[homanp/superagent](https://github.com/homanp/superagent) | 2177 |
+|[yanqiangmiffy/Chinese-LangChain](https://github.com/yanqiangmiffy/Chinese-LangChain) | 2144 |
+|[OpenGVLab/Ask-Anything](https://github.com/OpenGVLab/Ask-Anything) | 2092 |
+|[IntelligenzaArtificiale/Free-Auto-GPT](https://github.com/IntelligenzaArtificiale/Free-Auto-GPT) | 2060 |
+|[thomas-yanxin/LangChain-ChatGLM-Webui](https://github.com/thomas-yanxin/LangChain-ChatGLM-Webui) | 2039 |
+|[NVIDIA/NeMo-Guardrails](https://github.com/NVIDIA/NeMo-Guardrails) | 1992 |
+|[Farama-Foundation/PettingZoo](https://github.com/Farama-Foundation/PettingZoo) | 1949 |
+|[hwchase17/notion-qa](https://github.com/hwchase17/notion-qa) | 1915 |
+|[paulpierre/RasaGPT](https://github.com/paulpierre/RasaGPT) | 1783 |
+|[jupyterlab/jupyter-ai](https://github.com/jupyterlab/jupyter-ai) | 1761 |
+|[vocodedev/vocode-python](https://github.com/vocodedev/vocode-python) | 1627 |
+|[pinterest/querybook](https://github.com/pinterest/querybook) | 1509 |
+|[psychic-api/psychic](https://github.com/psychic-api/psychic) | 1499 |
+|[Kav-K/GPTDiscord](https://github.com/Kav-K/GPTDiscord) | 1476 |
+|[avinashkranjan/Amazing-Python-Scripts](https://github.com/avinashkranjan/Amazing-Python-Scripts) | 1471 |
+|[hegelai/prompttools](https://github.com/hegelai/prompttools) | 1392 |
+|[jina-ai/langchain-serve](https://github.com/jina-ai/langchain-serve) | 1370 |
+|[Forethought-Technologies/AutoChain](https://github.com/Forethought-Technologies/AutoChain) | 1360 |
+|[keephq/keep](https://github.com/keephq/keep) | 1357 |
+|[ttengwang/Caption-Anything](https://github.com/ttengwang/Caption-Anything) | 1345 |
+|[lunasec-io/lunasec](https://github.com/lunasec-io/lunasec) | 1342 |
+|[agiresearch/OpenAGI](https://github.com/agiresearch/OpenAGI) | 1332 |
+|[noahshinn024/reflexion](https://github.com/noahshinn024/reflexion) | 1314 |
+|[jina-ai/dev-gpt](https://github.com/jina-ai/dev-gpt) | 1314 |
+|[jina-ai/thinkgpt](https://github.com/jina-ai/thinkgpt) | 1313 |
+|[greshake/llm-security](https://github.com/greshake/llm-security) | 1299 |
+|[mmz-001/knowledge_gpt](https://github.com/mmz-001/knowledge_gpt) | 1237 |
+|[101dotxyz/GPTeam](https://github.com/101dotxyz/GPTeam) | 1232 |
+|[richardyc/Chrome-GPT](https://github.com/richardyc/Chrome-GPT) | 1223 |
+|[eyurtsev/kor](https://github.com/eyurtsev/kor) | 1192 |
+|[pluralsh/plural](https://github.com/pluralsh/plural) | 1126 |
+|[juncongmoo/chatllama](https://github.com/juncongmoo/chatllama) | 1117 |
+|[visual-openllm/visual-openllm](https://github.com/visual-openllm/visual-openllm) | 1110 |
+|[poe-platform/api-bot-tutorial](https://github.com/poe-platform/api-bot-tutorial) | 1096 |
+|[refuel-ai/autolabel](https://github.com/refuel-ai/autolabel) | 1080 |
+|[microsoft/X-Decoder](https://github.com/microsoft/X-Decoder) | 1075 |
+|[irgolic/AutoPR](https://github.com/irgolic/AutoPR) | 1068 |
+|[SamurAIGPT/Camel-AutoGPT](https://github.com/SamurAIGPT/Camel-AutoGPT) | 984 |
+|[peterw/Chat-with-Github-Repo](https://github.com/peterw/Chat-with-Github-Repo) | 957 |
+|[chatarena/chatarena](https://github.com/chatarena/chatarena) | 955 |
+|[griptape-ai/griptape](https://github.com/griptape-ai/griptape) | 944 |
+|[psychic-api/rag-stack](https://github.com/psychic-api/rag-stack) | 942 |
+|[nod-ai/SHARK](https://github.com/nod-ai/SHARK) | 909 |
+|[filip-michalsky/SalesGPT](https://github.com/filip-michalsky/SalesGPT) | 899 |
+|[melih-unsal/DemoGPT](https://github.com/melih-unsal/DemoGPT) | 896 |
+|[rlancemartin/auto-evaluator](https://github.com/rlancemartin/auto-evaluator) | 889 |
+|[cirediatpl/FigmaChain](https://github.com/cirediatpl/FigmaChain) | 868 |
+|[seanpixel/Teenage-AGI](https://github.com/seanpixel/Teenage-AGI) | 854 |
+|[cheshire-cat-ai/core](https://github.com/cheshire-cat-ai/core) | 847 |
+|[run-llama/llama-lab](https://github.com/run-llama/llama-lab) | 836 |
+|[corca-ai/EVAL](https://github.com/corca-ai/EVAL) | 818 |
+|[Anil-matcha/ChatPDF](https://github.com/Anil-matcha/ChatPDF) | 798 |
+|[alejandro-ao/ask-multiple-pdfs](https://github.com/alejandro-ao/ask-multiple-pdfs) | 782 |
+|[hwchase17/chat-your-data](https://github.com/hwchase17/chat-your-data) | 748 |
+|[LambdaLabsML/examples](https://github.com/LambdaLabsML/examples) | 741 |
+|[ajndkr/lanarky](https://github.com/ajndkr/lanarky) | 732 |
+|[microsoft/Llama-2-Onnx](https://github.com/microsoft/Llama-2-Onnx) | 722 |
+|[e-johnstonn/BriefGPT](https://github.com/e-johnstonn/BriefGPT) | 710 |
+|[billxbf/ReWOO](https://github.com/billxbf/ReWOO) | 710 |
+|[kennethleungty/Llama-2-Open-Source-LLM-CPU-Inference](https://github.com/kennethleungty/Llama-2-Open-Source-LLM-CPU-Inference) | 707 |
+|[databrickslabs/pyspark-ai](https://github.com/databrickslabs/pyspark-ai) | 704 |
+|[OpenBMB/AgentVerse](https://github.com/OpenBMB/AgentVerse) | 704 |
+|[kreneskyp/ix](https://github.com/kreneskyp/ix) | 692 |
+|[akshata29/entaoai](https://github.com/akshata29/entaoai) | 682 |
+|[promptfoo/promptfoo](https://github.com/promptfoo/promptfoo) | 670 |
+|[getmetal/motorhead](https://github.com/getmetal/motorhead) | 662 |
+|[ruoccofabrizio/azure-open-ai-embeddings-qna](https://github.com/ruoccofabrizio/azure-open-ai-embeddings-qna) | 650 |
+|[YiVal/YiVal](https://github.com/YiVal/YiVal) | 632 |
+|[whyiyhw/chatgpt-wechat](https://github.com/whyiyhw/chatgpt-wechat) | 624 |
+|[SamurAIGPT/ChatGPT-Developer-Plugins](https://github.com/SamurAIGPT/ChatGPT-Developer-Plugins) | 617 |
+|[dot-agent/openagent](https://github.com/dot-agent/openagent) | 602 |
+|[msoedov/langcorn](https://github.com/msoedov/langcorn) | 588 |
+|[namuan/dr-doc-search](https://github.com/namuan/dr-doc-search) | 585 |
+|[microsoft/PodcastCopilot](https://github.com/microsoft/PodcastCopilot) | 581 |
+|[alexanderatallah/window.ai](https://github.com/alexanderatallah/window.ai) | 569 |
+|[StevenGrove/GPT4Tools](https://github.com/StevenGrove/GPT4Tools) | 568 |
+|[xusenlinzy/api-for-open-llm](https://github.com/xusenlinzy/api-for-open-llm) | 559 |
+|[NoDataFound/hackGPT](https://github.com/NoDataFound/hackGPT) | 558 |
+|[langchain-ai/auto-evaluator](https://github.com/langchain-ai/auto-evaluator) | 554 |
+|[yeagerai/yeagerai-agent](https://github.com/yeagerai/yeagerai-agent) | 537 |
+|[FlagOpen/FlagEmbedding](https://github.com/FlagOpen/FlagEmbedding) | 534 |
+|[amosjyng/langchain-visualizer](https://github.com/amosjyng/langchain-visualizer) | 534 |
+|[OpenGenerativeAI/GenossGPT](https://github.com/OpenGenerativeAI/GenossGPT) | 524 |
+|[jina-ai/agentchain](https://github.com/jina-ai/agentchain) | 496 |
+|[mckaywrigley/repo-chat](https://github.com/mckaywrigley/repo-chat) | 495 |
+|[michaelthwan/searchGPT](https://github.com/michaelthwan/searchGPT) | 494 |
+|[explosion/spacy-llm](https://github.com/explosion/spacy-llm) | 492 |
+|[plastic-labs/tutor-gpt](https://github.com/plastic-labs/tutor-gpt) | 490 |
+|[freddyaboulton/gradio-tools](https://github.com/freddyaboulton/gradio-tools) | 488 |
+|[xuwenhao/geektime-ai-course](https://github.com/xuwenhao/geektime-ai-course) | 481 |
+|[tgscan-dev/tgscan](https://github.com/tgscan-dev/tgscan) | 480 |
+|[langchain-ai/langchain-aiplugin](https://github.com/langchain-ai/langchain-aiplugin) | 480 |
+|[mpaepper/content-chatbot](https://github.com/mpaepper/content-chatbot) | 473 |
+|[yvann-hub/Robby-chatbot](https://github.com/yvann-hub/Robby-chatbot) | 471 |
+|[steamship-core/steamship-langchain](https://github.com/steamship-core/steamship-langchain) | 467 |
+|[langchain-ai/streamlit-agent](https://github.com/langchain-ai/streamlit-agent) | 463 |
+|[jonra1993/fastapi-alembic-sqlmodel-async](https://github.com/jonra1993/fastapi-alembic-sqlmodel-async) | 463 |
+|[continuum-llms/chatgpt-memory](https://github.com/continuum-llms/chatgpt-memory) | 463 |
+|[poe-platform/poe-protocol](https://github.com/poe-platform/poe-protocol) | 441 |
+|[alejandro-ao/langchain-ask-pdf](https://github.com/alejandro-ao/langchain-ask-pdf) | 437 |
+|[Dicklesworthstone/llama_embeddings_fastapi_service](https://github.com/Dicklesworthstone/llama_embeddings_fastapi_service) | 432 |
+|[DataDog/dd-trace-py](https://github.com/DataDog/dd-trace-py) | 431 |
+|[daveebbelaar/langchain-experiments](https://github.com/daveebbelaar/langchain-experiments) | 431 |
+|[jiran214/GPT-vup](https://github.com/jiran214/GPT-vup) | 428 |
+|[Azure-Samples/openai](https://github.com/Azure-Samples/openai) | 419 |
+|[NimbleBoxAI/ChainFury](https://github.com/NimbleBoxAI/ChainFury) | 414 |
+|[CarperAI/OpenELM](https://github.com/CarperAI/OpenELM) | 411 |
+|[daodao97/chatdoc](https://github.com/daodao97/chatdoc) | 404 |
+|[MiuLab/Taiwan-LLaMa](https://github.com/MiuLab/Taiwan-LLaMa) | 402 |
+|[logan-markewich/llama_index_starter_pack](https://github.com/logan-markewich/llama_index_starter_pack) | 399 |
+|[mtenenholtz/chat-twitter](https://github.com/mtenenholtz/chat-twitter) | 394 |
+|[opentensor/bittensor](https://github.com/opentensor/bittensor) | 393 |
+|[showlab/VLog](https://github.com/showlab/VLog) | 392 |
+|[microsoft/sample-app-aoai-chatGPT](https://github.com/microsoft/sample-app-aoai-chatGPT) | 391 |
+|[truera/trulens](https://github.com/truera/trulens) | 390 |
+|[Anil-matcha/Chatbase](https://github.com/Anil-matcha/Chatbase) | 363 |
+|[marella/chatdocs](https://github.com/marella/chatdocs) | 360 |
+|[jondurbin/airoboros](https://github.com/jondurbin/airoboros) | 357 |
+|[mosaicml/examples](https://github.com/mosaicml/examples) | 353 |
+|[wandb/weave](https://github.com/wandb/weave) | 352 |
+|[huchenxucs/ChatDB](https://github.com/huchenxucs/ChatDB) | 350 |
+|[rsaryev/talk-codebase](https://github.com/rsaryev/talk-codebase) | 343 |
+|[steamship-packages/langchain-production-starter](https://github.com/steamship-packages/langchain-production-starter) | 335 |
+|[jerlendds/osintbuddy](https://github.com/jerlendds/osintbuddy) | 335 |
+|[andylokandy/gpt-4-search](https://github.com/andylokandy/gpt-4-search) | 329 |
+|[MagnivOrg/prompt-layer-library](https://github.com/MagnivOrg/prompt-layer-library) | 325 |
+|[personoids/personoids-lite](https://github.com/personoids/personoids-lite) | 319 |
+|[momegas/megabots](https://github.com/momegas/megabots) | 317 |
+|[itamargol/openai](https://github.com/itamargol/openai) | 312 |
+|[intel/intel-extension-for-transformers](https://github.com/intel/intel-extension-for-transformers) | 310 |
+|[monarch-initiative/ontogpt](https://github.com/monarch-initiative/ontogpt) | 310 |
+|[BlackHC/llm-strategy](https://github.com/BlackHC/llm-strategy) | 308 |
+|[Nuggt-dev/Nuggt](https://github.com/Nuggt-dev/Nuggt) | 305 |
+|[cofactoryai/textbase](https://github.com/cofactoryai/textbase) | 304 |
+|[Cheems-Seminar/grounded-segment-any-parts](https://github.com/Cheems-Seminar/grounded-segment-any-parts) | 296 |
+|[onlyphantom/llm-python](https://github.com/onlyphantom/llm-python) | 288 |
+|[morpheuslord/GPT_Vuln-analyzer](https://github.com/morpheuslord/GPT_Vuln-analyzer) | 285 |
+|[sullivan-sean/chat-langchainjs](https://github.com/sullivan-sean/chat-langchainjs) | 280 |
+|[wandb/edu](https://github.com/wandb/edu) | 277 |
+|[austin2035/chatpdf](https://github.com/austin2035/chatpdf) | 275 |
+|[liangwq/Chatglm_lora_multi-gpu](https://github.com/liangwq/Chatglm_lora_multi-gpu) | 273 |
+|[preset-io/promptimize](https://github.com/preset-io/promptimize) | 272 |
+|[Haste171/langchain-chatbot](https://github.com/Haste171/langchain-chatbot) | 271 |
+|[hnawaz007/pythondataanalysis](https://github.com/hnawaz007/pythondataanalysis) | 268 |
+|[JohnSnowLabs/langtest](https://github.com/JohnSnowLabs/langtest) | 268 |
+|[conceptofmind/toolformer](https://github.com/conceptofmind/toolformer) | 263 |
+|[sugarforever/LangChain-Tutorials](https://github.com/sugarforever/LangChain-Tutorials) | 260 |
+|[Safiullah-Rahu/CSV-AI](https://github.com/Safiullah-Rahu/CSV-AI) | 259 |
+|[artitw/text2text](https://github.com/artitw/text2text) | 257 |
+|[bborn/howdoi.ai](https://github.com/bborn/howdoi.ai) | 256 |
+|[JayZeeDesign/researcher-gpt](https://github.com/JayZeeDesign/researcher-gpt) | 252 |
+|[paolorechia/learn-langchain](https://github.com/paolorechia/learn-langchain) | 251 |
+|[ur-whitelab/exmol](https://github.com/ur-whitelab/exmol) | 251 |
+|[Azure-Samples/miyagi](https://github.com/Azure-Samples/miyagi) | 248 |
+|[recalign/RecAlign](https://github.com/recalign/RecAlign) | 243 |
+|[airobotlab/KoChatGPT](https://github.com/airobotlab/KoChatGPT) | 242 |
+|[explodinggradients/ragas](https://github.com/explodinggradients/ragas) | 232 |
+|[kaleido-lab/dolphin](https://github.com/kaleido-lab/dolphin) | 232 |
+|[hwchase17/chroma-langchain](https://github.com/hwchase17/chroma-langchain) | 230 |
+|[eosphoros-ai/DB-GPT-Hub](https://github.com/eosphoros-ai/DB-GPT-Hub) | 229 |
+|[shaman-ai/agent-actors](https://github.com/shaman-ai/agent-actors) | 227 |
+|[gia-guar/JARVIS-ChatGPT](https://github.com/gia-guar/JARVIS-ChatGPT) | 224 |
+|[shamspias/customizable-gpt-chatbot](https://github.com/shamspias/customizable-gpt-chatbot) | 223 |
+|[hwchase17/langchain-streamlit-template](https://github.com/hwchase17/langchain-streamlit-template) | 222 |
+|[alvarosevilla95/autolang](https://github.com/alvarosevilla95/autolang) | 221 |
+|[radi-cho/datasetGPT](https://github.com/radi-cho/datasetGPT) | 221 |
+|[gustavz/DataChad](https://github.com/gustavz/DataChad) | 219 |
+|[pablomarin/GPT-Azure-Search-Engine](https://github.com/pablomarin/GPT-Azure-Search-Engine) | 217 |
+|[su77ungr/CASALIOY](https://github.com/su77ungr/CASALIOY) | 217 |
+|[ennucore/clippinator](https://github.com/ennucore/clippinator) | 211 |
+|[edreisMD/plugnplai](https://github.com/edreisMD/plugnplai) | 210 |
+|[kaarthik108/snowChat](https://github.com/kaarthik108/snowChat) | 210 |
+|[PradipNichite/Youtube-Tutorials](https://github.com/PradipNichite/Youtube-Tutorials) | 206 |
+|[ur-whitelab/chemcrow-public](https://github.com/ur-whitelab/chemcrow-public) | 202 |
+|[CambioML/pykoi](https://github.com/CambioML/pykoi) | 199 |
+|[jbrukh/gpt-jargon](https://github.com/jbrukh/gpt-jargon) | 198 |
+|[LC1332/Chat-Haruhi-Suzumiya](https://github.com/LC1332/Chat-Haruhi-Suzumiya) | 196 |
+|[nicknochnack/LangchainDocuments](https://github.com/nicknochnack/LangchainDocuments) | 196 |
+|[yuanjie-ai/ChatLLM](https://github.com/yuanjie-ai/ChatLLM) | 196 |
+|[plchld/InsightFlow](https://github.com/plchld/InsightFlow) | 196 |
+|[yakami129/VirtualWife](https://github.com/yakami129/VirtualWife) | 194 |
+|[Mintplex-Labs/vector-admin](https://github.com/Mintplex-Labs/vector-admin) | 191 |
+|[SamPink/dev-gpt](https://github.com/SamPink/dev-gpt) | 190 |
+|[yasyf/compress-gpt](https://github.com/yasyf/compress-gpt) | 190 |
+|[benthecoder/ClassGPT](https://github.com/benthecoder/ClassGPT) | 190 |
+|[WongSaang/chatgpt-ui-server](https://github.com/WongSaang/chatgpt-ui-server) | 182 |
+|[voxel51/voxelgpt](https://github.com/voxel51/voxelgpt) | 181 |
+|[hardbyte/qabot](https://github.com/hardbyte/qabot) | 176 |
+|[orgexyz/BlockAGI](https://github.com/orgexyz/BlockAGI) | 174 |
+|[handrew/browserpilot](https://github.com/handrew/browserpilot) | 173 |
+|[miaoshouai/miaoshouai-assistant](https://github.com/miaoshouai/miaoshouai-assistant) | 172 |
+|[microsoft/azure-openai-in-a-day-workshop](https://github.com/microsoft/azure-openai-in-a-day-workshop) | 170 |
+|[kyegomez/swarms](https://github.com/kyegomez/swarms) | 169 |
+|[Azure-Samples/azure-search-power-skills](https://github.com/Azure-Samples/azure-search-power-skills) | 169 |
+|[chakkaradeep/pyCodeAGI](https://github.com/chakkaradeep/pyCodeAGI) | 169 |
+|[ethanyanjiali/minChatGPT](https://github.com/ethanyanjiali/minChatGPT) | 167 |
+|[ccurme/yolopandas](https://github.com/ccurme/yolopandas) | 166 |
+|[ju-bezdek/langchain-decorators](https://github.com/ju-bezdek/langchain-decorators) | 165 |
+|[Azure-Samples/azure-search-openai-demo-csharp](https://github.com/Azure-Samples/azure-search-openai-demo-csharp) | 164 |
+|[fengyuli-dev/multimedia-gpt](https://github.com/fengyuli-dev/multimedia-gpt) | 164 |
+|[grumpyp/aixplora](https://github.com/grumpyp/aixplora) | 162 |
+|[langchain-ai/web-explorer](https://github.com/langchain-ai/web-explorer) | 158 |
+|[JorisdeJong123/7-Days-of-LangChain](https://github.com/JorisdeJong123/7-Days-of-LangChain) | 158 |
+|[shauryr/S2QA](https://github.com/shauryr/S2QA) | 158 |
+|[Azure-Samples/jp-azureopenai-samples](https://github.com/Azure-Samples/jp-azureopenai-samples) | 157 |
+|[AkshitIreddy/Interactive-LLM-Powered-NPCs](https://github.com/AkshitIreddy/Interactive-LLM-Powered-NPCs) | 156 |
+|[ibiscp/LLM-IMDB](https://github.com/ibiscp/LLM-IMDB) | 156 |
+|[jmpaz/promptlib](https://github.com/jmpaz/promptlib) | 156 |
+|[mayooear/private-chatbot-mpt30b-langchain](https://github.com/mayooear/private-chatbot-mpt30b-langchain) | 155 |
+|[homanp/vercel-langchain](https://github.com/homanp/vercel-langchain) | 152 |
+|[mlops-for-all/mlops-for-all.github.io](https://github.com/mlops-for-all/mlops-for-all.github.io) | 151 |
+|[vaibkumr/prompt-optimizer](https://github.com/vaibkumr/prompt-optimizer) | 151 |
+|[Agenta-AI/agenta](https://github.com/Agenta-AI/agenta) | 150 |
+|[Klingefjord/chatgpt-telegram](https://github.com/Klingefjord/chatgpt-telegram) | 149 |
+|[menloparklab/falcon-langchain](https://github.com/menloparklab/falcon-langchain) | 148 |
+|[deeppavlov/dream](https://github.com/deeppavlov/dream) | 146 |
+|[positive666/Prompt-Can-Anything](https://github.com/positive666/Prompt-Can-Anything) | 145 |
+|[menloparklab/langchain-cohere-qdrant-doc-retrieval](https://github.com/menloparklab/langchain-cohere-qdrant-doc-retrieval) | 145 |
+|[realminchoi/babyagi-ui](https://github.com/realminchoi/babyagi-ui) | 145 |
+|[SpecterOps/Nemesis](https://github.com/SpecterOps/Nemesis) | 144 |
+|[Jaseci-Labs/jaseci](https://github.com/Jaseci-Labs/jaseci) | 144 |
+|[summarizepaper/summarizepaper](https://github.com/summarizepaper/summarizepaper) | 142 |
+|[peterw/StoryStorm](https://github.com/peterw/StoryStorm) | 141 |
+|[Aggregate-Intellect/practical-llms](https://github.com/Aggregate-Intellect/practical-llms) | 140 |
+|[streamlit/llm-examples](https://github.com/streamlit/llm-examples) | 140 |
+|[hirokidaichi/wanna](https://github.com/hirokidaichi/wanna) | 140 |
+|[Chainlit/cookbook](https://github.com/Chainlit/cookbook) | 139 |
+|[alphasecio/langchain-examples](https://github.com/alphasecio/langchain-examples) | 139 |
+|[flurb18/AgentOoba](https://github.com/flurb18/AgentOoba) | 139 |
+|[Teahouse-Studios/akari-bot](https://github.com/Teahouse-Studios/akari-bot) | 138 |
+|[yasyf/summ](https://github.com/yasyf/summ) | 138 |
+|[kulltc/chatgpt-sql](https://github.com/kulltc/chatgpt-sql) | 137 |
+|[v7labs/benchllm](https://github.com/v7labs/benchllm) | 135 |
+|[ray-project/langchain-ray](https://github.com/ray-project/langchain-ray) | 134 |
+|[petehunt/langchain-github-bot](https://github.com/petehunt/langchain-github-bot) | 134 |
+|[peterwnjenga/aigent](https://github.com/peterwnjenga/aigent) | 133 |
+|[jina-ai/fastapi-serve](https://github.com/jina-ai/fastapi-serve) | 133 |
+|[retr0reg/Ret2GPT](https://github.com/retr0reg/Ret2GPT) | 132 |
+|[agenthubdev/agenthub_operators](https://github.com/agenthubdev/agenthub_operators) | 131 |
+|[eunomia-bpf/GPTtrace](https://github.com/eunomia-bpf/GPTtrace) | 131 |
+|[solana-labs/chatgpt-plugin](https://github.com/solana-labs/chatgpt-plugin) | 130 |
+|[aurelio-labs/arxiv-bot](https://github.com/aurelio-labs/arxiv-bot) | 130 |
+|[ChuloAI/BrainChulo](https://github.com/ChuloAI/BrainChulo) | 128 |
+|[ssheng/BentoChain](https://github.com/ssheng/BentoChain) | 128 |
+|[mallahyari/drqa](https://github.com/mallahyari/drqa) | 127 |
+|[fixie-ai/fixie-examples](https://github.com/fixie-ai/fixie-examples) | 127 |
+|[davila7/file-gpt](https://github.com/davila7/file-gpt) | 127 |
+|[showlab/UniVTG](https://github.com/showlab/UniVTG) | 125 |
+|[zenml-io/zenml-projects](https://github.com/zenml-io/zenml-projects) | 125 |
+|[RedisVentures/redis-openai-qna](https://github.com/RedisVentures/redis-openai-qna) | 124 |
+|[PJLab-ADG/DriveLikeAHuman](https://github.com/PJLab-ADG/DriveLikeAHuman) | 122 |
+|[prof-frink-lab/slangchain](https://github.com/prof-frink-lab/slangchain) | 122 |
+|[Coding-Crashkurse/Langchain-Full-Course](https://github.com/Coding-Crashkurse/Langchain-Full-Course) | 121 |
+|[ciare-robotics/world-creator](https://github.com/ciare-robotics/world-creator) | 120 |
+|[blob42/Instrukt](https://github.com/blob42/Instrukt) | 120 |
+|[langchain-ai/langsmith-cookbook](https://github.com/langchain-ai/langsmith-cookbook) | 119 |
+|[OpenPluginACI/openplugin](https://github.com/OpenPluginACI/openplugin) | 118 |
+|[defenseunicorns/leapfrogai](https://github.com/defenseunicorns/leapfrogai) | 118 |
+|[sdaaron/QueryGPT](https://github.com/sdaaron/QueryGPT) | 117 |
+|[grumpyp/chroma-langchain-tutorial](https://github.com/grumpyp/chroma-langchain-tutorial) | 117 |
+|[3Alan/DocsMind](https://github.com/3Alan/DocsMind) | 116 |
+|[CodeAlchemyAI/ViLT-GPT](https://github.com/CodeAlchemyAI/ViLT-GPT) | 114 |
+|[emarco177/ice_breaker](https://github.com/emarco177/ice_breaker) | 113 |
+|[nftblackmagic/flask-langchain](https://github.com/nftblackmagic/flask-langchain) | 113 |
+|[log1stics/voice-generator-webui](https://github.com/log1stics/voice-generator-webui) | 112 |
+|[nrl-ai/pautobot](https://github.com/nrl-ai/pautobot) | 110 |
+|[Azure/business-process-automation](https://github.com/Azure/business-process-automation) | 110 |
+|[MedalCollector/Orator](https://github.com/MedalCollector/Orator) | 109 |
+|[wombyz/HormoziGPT](https://github.com/wombyz/HormoziGPT) | 108 |
+|[afaqueumer/DocQA](https://github.com/afaqueumer/DocQA) | 106 |
+|[mortium91/langchain-assistant](https://github.com/mortium91/langchain-assistant) | 106 |
+|[Azure/azure-sdk-tools](https://github.com/Azure/azure-sdk-tools) | 105 |
+|[yeagerai/genworlds](https://github.com/yeagerai/genworlds) | 105 |
+|[AmineDiro/cria](https://github.com/AmineDiro/cria) | 104 |
+|[langchain-ai/text-split-explorer](https://github.com/langchain-ai/text-split-explorer) | 104 |
+|[luisroque/large_laguage_models](https://github.com/luisroque/large_laguage_models) | 104 |
+|[xuwenhao/mactalk-ai-course](https://github.com/xuwenhao/mactalk-ai-course) | 104 |
+|[Open-Swarm-Net/GPT-Swarm](https://github.com/Open-Swarm-Net/GPT-Swarm) | 104 |
+|[langchain-ai/langchain-aws-template](https://github.com/langchain-ai/langchain-aws-template) | 104 |
+|[aws-samples/aws-genai-llm-chatbot](https://github.com/aws-samples/aws-genai-llm-chatbot) | 103 |
+|[crosleythomas/MirrorGPT](https://github.com/crosleythomas/MirrorGPT) | 103 |
+|[Dicklesworthstone/llama2_aided_tesseract](https://github.com/Dicklesworthstone/llama2_aided_tesseract) | 101 |
+
+
+
+_Generated by [github-dependents-info](https://github.com/nvuillam/github-dependents-info)_
+
+`github-dependents-info --repo langchain-ai/langchain --markdownfile dependents.md --minstars 100 --sort stars`

docs/extras/additional_resources/tutorials.mdx

@@ -1,15 +1,15 @@
 # Tutorials
 
-Below are links to video tutorials and courses on LangChain. For written guides on common use cases for LangChain, check out the [use cases guides](/docs/use_cases).
+Below are links to tutorials and courses on LangChain. For written guides on common use cases for LangChain, check out the [use cases guides](/docs/use_cases).
 
-⛓ icon marks a new addition [last update 2023-07-05]
+⛓ icon marks a new addition [last update 2023-08-20]
 
 ---------------------
 
 ### DeepLearning.AI courses
  by [Harrison Chase](https://github.com/hwchase17) and [Andrew Ng](https://en.wikipedia.org/wiki/Andrew_Ng)
 - [LangChain for LLM Application Development](https://learn.deeplearning.ai/langchain)
-- ⛓ [LangChain Chat with Your Data](https://learn.deeplearning.ai/langchain-chat-with-your-data)
+- [LangChain Chat with Your Data](https://learn.deeplearning.ai/langchain-chat-with-your-data)
 
 ### Handbook
 [LangChain AI Handbook](https://www.pinecone.io/learn/langchain/) By **James Briggs** and **Francisco Ingham**
@@ -36,14 +36,14 @@ Below are links to video tutorials and courses on LangChain. For written guides
 - #8 [Create Custom Tools for Chatbots in LangChain](https://youtu.be/q-HNphrWsDE)
 - #9 [Build Conversational Agents with Vector DBs](https://youtu.be/H6bCqqw9xyI)
 - [Using NEW `MPT-7B` in Hugging Face and LangChain](https://youtu.be/DXpk9K7DgMo)
-- ⛓ [`MPT-30B` Chatbot with LangChain](https://youtu.be/pnem-EhT6VI)
+- [`MPT-30B` Chatbot with LangChain](https://youtu.be/pnem-EhT6VI)
 
 
 ### [LangChain 101](https://www.youtube.com/playlist?list=PLqZXAkvF1bPNQER9mLmDbntNfSpzdDIU5) by [Greg Kamradt (Data Indy)](https://www.youtube.com/@DataIndependent)
 - [What Is LangChain? - LangChain + `ChatGPT` Overview](https://youtu.be/_v_fgW2SkkQ)
 - [Quickstart Guide](https://youtu.be/kYRB-vJFy38)
-- [Beginner Guide To 7 Essential Concepts](https://youtu.be/2xxziIWmaSA)
-- [Beginner Guide To 9 Use Cases](https://youtu.be/vGP4pQdCocw)
+- [Beginner's Guide To 7 Essential Concepts](https://youtu.be/2xxziIWmaSA)
+- [Beginner's Guide To 9 Use Cases](https://youtu.be/vGP4pQdCocw)
 - [Agents Overview + Google Searches](https://youtu.be/Jq9Sf68ozk0)
 - [`OpenAI` + `Wolfram Alpha`](https://youtu.be/UijbzCIJ99g)
 - [Ask Questions On Your Custom (or Private) Files](https://youtu.be/EnT-ZTrcPrg)
@@ -63,7 +63,7 @@ Below are links to video tutorials and courses on LangChain. For written guides
 - [Build Your Own `AI Twitter Bot` Using LLMs](https://youtu.be/yLWLDjT01q8)
 - [ChatGPT made my interview questions for me (`Streamlit` + LangChain)](https://youtu.be/zvoAMx0WKkw)
 - [Function Calling via ChatGPT API - First Look With LangChain](https://youtu.be/0-zlUy7VUjg)
-- ⛓ [Extract Topics From Video/Audio With LLMs (Topic Modeling w/ LangChain)](https://youtu.be/pEkxRQFNAs4)
+- [Extract Topics From Video/Audio With LLMs (Topic Modeling w/ LangChain)](https://youtu.be/pEkxRQFNAs4)
 
 
 ### [LangChain How to and guides](https://www.youtube.com/playlist?list=PL8motc6AQftk1Bs42EW45kwYbyJ4jOdiZ) by [Sam Witteveen](https://www.youtube.com/@samwitteveenai)
@@ -73,7 +73,7 @@ Below are links to video tutorials and courses on LangChain. For written guides
 - [Conversations with Memory (explanation & code walkthrough)](https://youtu.be/X550Zbz_ROE)
 - [Chat with `Flan20B`](https://youtu.be/VW5LBavIfY4)
 - [Using `Hugging Face Models` locally (code walkthrough)](https://youtu.be/Kn7SX2Mx_Jk)
-- [`PAL` : Program-aided Language Models with LangChain code](https://youtu.be/dy7-LvDu-3s)
+- [`PAL`: Program-aided Language Models with LangChain code](https://youtu.be/dy7-LvDu-3s)
 - [Building a Summarization System with LangChain and `GPT-3` - Part 1](https://youtu.be/LNq_2s_H01Y)
 - [Building a Summarization System with LangChain and `GPT-3` - Part 2](https://youtu.be/d-yeHDLgKHw)
 - [Microsoft's `Visual ChatGPT` using LangChain](https://youtu.be/7YEiEyfPF5U)
@@ -85,7 +85,7 @@ Below are links to video tutorials and courses on LangChain. For written guides
 - [`BabyAGI`: Discover the Power of Task-Driven Autonomous Agents!](https://youtu.be/QBcDLSE2ERA)
 - [Improve your `BabyAGI` with LangChain](https://youtu.be/DRgPyOXZ-oE)
 - [Master `PDF` Chat with LangChain - Your essential guide to queries on documents](https://youtu.be/ZzgUqFtxgXI)
-- [Using LangChain with `DuckDuckGO` `Wikipedia` & `PythonREPL` Tools](https://youtu.be/KerHlb8nuVc)
+- [Using LangChain with `DuckDuckGO`, `Wikipedia` & `PythonREPL` Tools](https://youtu.be/KerHlb8nuVc)
 - [Building Custom Tools and Agents with LangChain (gpt-3.5-turbo)](https://youtu.be/biS8G8x8DdA)
 - [LangChain Retrieval QA Over Multiple Files with `ChromaDB`](https://youtu.be/3yPBVii7Ct0)
 - [LangChain Retrieval QA with Instructor Embeddings & `ChromaDB` for PDFs](https://youtu.be/cFCGUjc33aU)
@@ -99,7 +99,7 @@ Below are links to video tutorials and courses on LangChain. For written guides
 - [`OpenAI Functions` + LangChain : Building a Multi Tool Agent](https://youtu.be/4KXK6c6TVXQ)
 - [What can you do with 16K tokens in LangChain?](https://youtu.be/z2aCZBAtWXs)
 - [Tagging and Extraction - Classification using `OpenAI Functions`](https://youtu.be/a8hMgIcUEnE)
-- ⛓ [HOW to Make Conversational Form with LangChain](https://youtu.be/IT93On2LB5k)
+- [HOW to Make Conversational Form with LangChain](https://youtu.be/IT93On2LB5k)
 
 
 ### [LangChain](https://www.youtube.com/playlist?list=PLVEEucA9MYhOu89CX8H3MBZqayTbcCTMr) by [Prompt Engineering](https://www.youtube.com/@engineerprompt)
@@ -107,7 +107,7 @@ Below are links to video tutorials and courses on LangChain. For written guides
 - [Working with MULTIPLE `PDF` Files in LangChain: `ChatGPT` for your Data](https://youtu.be/s5LhRdh5fu4)
 - [`ChatGPT` for YOUR OWN `PDF` files with LangChain](https://youtu.be/TLf90ipMzfE)
 - [Talk to YOUR DATA without OpenAI APIs: LangChain](https://youtu.be/wrD-fZvT6UI)
-- [Langchain: PDF Chat App (GUI) | ChatGPT for Your PDF FILES](https://youtu.be/RIWbalZ7sTo)
+- [LangChain: PDF Chat App (GUI) | ChatGPT for Your PDF FILES](https://youtu.be/RIWbalZ7sTo)
 - [LangFlow: Build Chatbots without Writing Code](https://youtu.be/KJ-ux3hre4s)
 - [LangChain: Giving Memory to LLMs](https://youtu.be/dxO6pzlgJiY)
 - [BEST OPEN Alternative to `OPENAI's EMBEDDINGs` for Retrieval QA: LangChain](https://youtu.be/ogEalPMUCSY)
@@ -121,5 +121,9 @@ Below are links to video tutorials and courses on LangChain. For written guides
 - [LangChain Agents: Build Personal Assistants For Your Data (Q&A with Harrison Chase and Mayo Oshin)](https://youtu.be/gVkF8cwfBLI)
 
 
+### Codebase Analysis
+- ⛓ [Codebase Analysis: Langchain Agents](https://carbonated-yacht-2c5.notion.site/Codebase-Analysis-Langchain-Agents-0b0587acd50647ca88aaae7cff5df1f2)
+
+
 ---------------------
-⛓ icon marks a new addition [last update 2023-07-05]
+⛓ icon marks a new addition [last update 2023-08-20]

docs/extras/ecosystem/dependents.mdx

@@ -1,265 +0,0 @@
-# Dependents
-
-Dependents stats for `hwchase17/langchain`
-
-[![](https://img.shields.io/static/v1?label=Used%20by&message=9941&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-[![](https://img.shields.io/static/v1?label=Used%20by%20(public)&message=244&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-[![](https://img.shields.io/static/v1?label=Used%20by%20(private)&message=9697&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-[![](https://img.shields.io/static/v1?label=Used%20by%20(stars)&message=19827&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-
-
-[update: 2023-07-07; only dependent repositories with Stars > 100]
-
-
-| Repository | Stars  |
-| :--------  | -----: |
-|[openai/openai-cookbook](https://github.com/openai/openai-cookbook) | 41047 |
-|[LAION-AI/Open-Assistant](https://github.com/LAION-AI/Open-Assistant) | 33983 |
-|[microsoft/TaskMatrix](https://github.com/microsoft/TaskMatrix) | 33375 |
-|[imartinez/privateGPT](https://github.com/imartinez/privateGPT) | 31114 |
-|[hpcaitech/ColossalAI](https://github.com/hpcaitech/ColossalAI) | 30369 |
-|[reworkd/AgentGPT](https://github.com/reworkd/AgentGPT) | 24116 |
-|[OpenBB-finance/OpenBBTerminal](https://github.com/OpenBB-finance/OpenBBTerminal) | 22565 |
-|[openai/chatgpt-retrieval-plugin](https://github.com/openai/chatgpt-retrieval-plugin) | 18375 |
-|[jerryjliu/llama_index](https://github.com/jerryjliu/llama_index) | 17723 |
-|[mindsdb/mindsdb](https://github.com/mindsdb/mindsdb) | 16958 |
-|[mlflow/mlflow](https://github.com/mlflow/mlflow) | 14632 |
-|[GaiZhenbiao/ChuanhuChatGPT](https://github.com/GaiZhenbiao/ChuanhuChatGPT) | 11273 |
-|[openai/evals](https://github.com/openai/evals) | 10745 |
-|[databrickslabs/dolly](https://github.com/databrickslabs/dolly) | 10298 |
-|[imClumsyPanda/langchain-ChatGLM](https://github.com/imClumsyPanda/langchain-ChatGLM) | 9838 |
-|[logspace-ai/langflow](https://github.com/logspace-ai/langflow) | 9247 |
-|[AIGC-Audio/AudioGPT](https://github.com/AIGC-Audio/AudioGPT) | 8768 |
-|[PromtEngineer/localGPT](https://github.com/PromtEngineer/localGPT) | 8651 |
-|[StanGirard/quivr](https://github.com/StanGirard/quivr) | 8119 |
-|[go-skynet/LocalAI](https://github.com/go-skynet/LocalAI) | 7418 |
-|[gventuri/pandas-ai](https://github.com/gventuri/pandas-ai) | 7301 |
-|[PipedreamHQ/pipedream](https://github.com/PipedreamHQ/pipedream) | 6636 |
-|[arc53/DocsGPT](https://github.com/arc53/DocsGPT) | 5849 |
-|[e2b-dev/e2b](https://github.com/e2b-dev/e2b) | 5129 |
-|[langgenius/dify](https://github.com/langgenius/dify) | 4804 |
-|[serge-chat/serge](https://github.com/serge-chat/serge) | 4448 |
-|[csunny/DB-GPT](https://github.com/csunny/DB-GPT) | 4350 |
-|[wenda-LLM/wenda](https://github.com/wenda-LLM/wenda) | 4268 |
-|[zauberzeug/nicegui](https://github.com/zauberzeug/nicegui) | 4244 |
-|[intitni/CopilotForXcode](https://github.com/intitni/CopilotForXcode) | 4232 |
-|[GreyDGL/PentestGPT](https://github.com/GreyDGL/PentestGPT) | 4154 |
-|[madawei2699/myGPTReader](https://github.com/madawei2699/myGPTReader) | 4080 |
-|[zilliztech/GPTCache](https://github.com/zilliztech/GPTCache) | 3949 |
-|[gkamradt/langchain-tutorials](https://github.com/gkamradt/langchain-tutorials) | 3920 |
-|[bentoml/OpenLLM](https://github.com/bentoml/OpenLLM) | 3481 |
-|[MineDojo/Voyager](https://github.com/MineDojo/Voyager) | 3453 |
-|[mmabrouk/chatgpt-wrapper](https://github.com/mmabrouk/chatgpt-wrapper) | 3355 |
-|[postgresml/postgresml](https://github.com/postgresml/postgresml) | 3328 |
-|[marqo-ai/marqo](https://github.com/marqo-ai/marqo) | 3100 |
-|[kyegomez/tree-of-thoughts](https://github.com/kyegomez/tree-of-thoughts) | 3049 |
-|[PrefectHQ/marvin](https://github.com/PrefectHQ/marvin) | 2844 |
-|[project-baize/baize-chatbot](https://github.com/project-baize/baize-chatbot) | 2833 |
-|[h2oai/h2ogpt](https://github.com/h2oai/h2ogpt) | 2809 |
-|[hwchase17/chat-langchain](https://github.com/hwchase17/chat-langchain) | 2809 |
-|[whitead/paper-qa](https://github.com/whitead/paper-qa) | 2664 |
-|[Azure-Samples/azure-search-openai-demo](https://github.com/Azure-Samples/azure-search-openai-demo) | 2650 |
-|[OpenGVLab/InternGPT](https://github.com/OpenGVLab/InternGPT) | 2525 |
-|[GerevAI/gerev](https://github.com/GerevAI/gerev) | 2372 |
-|[ParisNeo/lollms-webui](https://github.com/ParisNeo/lollms-webui) | 2287 |
-|[OpenBMB/BMTools](https://github.com/OpenBMB/BMTools) | 2265 |
-|[SamurAIGPT/privateGPT](https://github.com/SamurAIGPT/privateGPT) | 2084 |
-|[Chainlit/chainlit](https://github.com/Chainlit/chainlit) | 1912 |
-|[Farama-Foundation/PettingZoo](https://github.com/Farama-Foundation/PettingZoo) | 1869 |
-|[OpenGVLab/Ask-Anything](https://github.com/OpenGVLab/Ask-Anything) | 1864 |
-|[IntelligenzaArtificiale/Free-Auto-GPT](https://github.com/IntelligenzaArtificiale/Free-Auto-GPT) | 1849 |
-|[Unstructured-IO/unstructured](https://github.com/Unstructured-IO/unstructured) | 1766 |
-|[yanqiangmiffy/Chinese-LangChain](https://github.com/yanqiangmiffy/Chinese-LangChain) | 1745 |
-|[NVIDIA/NeMo-Guardrails](https://github.com/NVIDIA/NeMo-Guardrails) | 1732 |
-|[hwchase17/notion-qa](https://github.com/hwchase17/notion-qa) | 1716 |
-|[paulpierre/RasaGPT](https://github.com/paulpierre/RasaGPT) | 1619 |
-|[pinterest/querybook](https://github.com/pinterest/querybook) | 1468 |
-|[vocodedev/vocode-python](https://github.com/vocodedev/vocode-python) | 1446 |
-|[thomas-yanxin/LangChain-ChatGLM-Webui](https://github.com/thomas-yanxin/LangChain-ChatGLM-Webui) | 1430 |
-|[Mintplex-Labs/anything-llm](https://github.com/Mintplex-Labs/anything-llm) | 1419 |
-|[Kav-K/GPTDiscord](https://github.com/Kav-K/GPTDiscord) | 1416 |
-|[lunasec-io/lunasec](https://github.com/lunasec-io/lunasec) | 1327 |
-|[psychic-api/psychic](https://github.com/psychic-api/psychic) | 1307 |
-|[jina-ai/thinkgpt](https://github.com/jina-ai/thinkgpt) | 1242 |
-|[agiresearch/OpenAGI](https://github.com/agiresearch/OpenAGI) | 1239 |
-|[ttengwang/Caption-Anything](https://github.com/ttengwang/Caption-Anything) | 1203 |
-|[jina-ai/dev-gpt](https://github.com/jina-ai/dev-gpt) | 1179 |
-|[keephq/keep](https://github.com/keephq/keep) | 1169 |
-|[greshake/llm-security](https://github.com/greshake/llm-security) | 1156 |
-|[richardyc/Chrome-GPT](https://github.com/richardyc/Chrome-GPT) | 1090 |
-|[jina-ai/langchain-serve](https://github.com/jina-ai/langchain-serve) | 1088 |
-|[mmz-001/knowledge_gpt](https://github.com/mmz-001/knowledge_gpt) | 1074 |
-|[juncongmoo/chatllama](https://github.com/juncongmoo/chatllama) | 1057 |
-|[noahshinn024/reflexion](https://github.com/noahshinn024/reflexion) | 1045 |
-|[visual-openllm/visual-openllm](https://github.com/visual-openllm/visual-openllm) | 1036 |
-|[101dotxyz/GPTeam](https://github.com/101dotxyz/GPTeam) | 999 |
-|[poe-platform/api-bot-tutorial](https://github.com/poe-platform/api-bot-tutorial) | 989 |
-|[irgolic/AutoPR](https://github.com/irgolic/AutoPR) | 974 |
-|[homanp/superagent](https://github.com/homanp/superagent) | 970 |
-|[microsoft/X-Decoder](https://github.com/microsoft/X-Decoder) | 941 |
-|[peterw/Chat-with-Github-Repo](https://github.com/peterw/Chat-with-Github-Repo) | 896 |
-|[SamurAIGPT/Camel-AutoGPT](https://github.com/SamurAIGPT/Camel-AutoGPT) | 856 |
-|[cirediatpl/FigmaChain](https://github.com/cirediatpl/FigmaChain) | 840 |
-|[chatarena/chatarena](https://github.com/chatarena/chatarena) | 829 |
-|[rlancemartin/auto-evaluator](https://github.com/rlancemartin/auto-evaluator) | 816 |
-|[seanpixel/Teenage-AGI](https://github.com/seanpixel/Teenage-AGI) | 816 |
-|[hashintel/hash](https://github.com/hashintel/hash) | 806 |
-|[corca-ai/EVAL](https://github.com/corca-ai/EVAL) | 790 |
-|[eyurtsev/kor](https://github.com/eyurtsev/kor) | 752 |
-|[cheshire-cat-ai/core](https://github.com/cheshire-cat-ai/core) | 713 |
-|[e-johnstonn/BriefGPT](https://github.com/e-johnstonn/BriefGPT) | 686 |
-|[run-llama/llama-lab](https://github.com/run-llama/llama-lab) | 685 |
-|[refuel-ai/autolabel](https://github.com/refuel-ai/autolabel) | 673 |
-|[griptape-ai/griptape](https://github.com/griptape-ai/griptape) | 617 |
-|[billxbf/ReWOO](https://github.com/billxbf/ReWOO) | 616 |
-|[Anil-matcha/ChatPDF](https://github.com/Anil-matcha/ChatPDF) | 609 |
-|[NimbleBoxAI/ChainFury](https://github.com/NimbleBoxAI/ChainFury) | 592 |
-|[getmetal/motorhead](https://github.com/getmetal/motorhead) | 581 |
-|[ajndkr/lanarky](https://github.com/ajndkr/lanarky) | 574 |
-|[namuan/dr-doc-search](https://github.com/namuan/dr-doc-search) | 572 |
-|[kreneskyp/ix](https://github.com/kreneskyp/ix) | 564 |
-|[akshata29/chatpdf](https://github.com/akshata29/chatpdf) | 540 |
-|[hwchase17/chat-your-data](https://github.com/hwchase17/chat-your-data) | 540 |
-|[whyiyhw/chatgpt-wechat](https://github.com/whyiyhw/chatgpt-wechat) | 537 |
-|[khoj-ai/khoj](https://github.com/khoj-ai/khoj) | 531 |
-|[SamurAIGPT/ChatGPT-Developer-Plugins](https://github.com/SamurAIGPT/ChatGPT-Developer-Plugins) | 528 |
-|[microsoft/PodcastCopilot](https://github.com/microsoft/PodcastCopilot) | 526 |
-|[ruoccofabrizio/azure-open-ai-embeddings-qna](https://github.com/ruoccofabrizio/azure-open-ai-embeddings-qna) | 515 |
-|[alexanderatallah/window.ai](https://github.com/alexanderatallah/window.ai) | 494 |
-|[StevenGrove/GPT4Tools](https://github.com/StevenGrove/GPT4Tools) | 483 |
-|[jina-ai/agentchain](https://github.com/jina-ai/agentchain) | 472 |
-|[mckaywrigley/repo-chat](https://github.com/mckaywrigley/repo-chat) | 465 |
-|[yeagerai/yeagerai-agent](https://github.com/yeagerai/yeagerai-agent) | 464 |
-|[langchain-ai/langchain-aiplugin](https://github.com/langchain-ai/langchain-aiplugin) | 464 |
-|[mpaepper/content-chatbot](https://github.com/mpaepper/content-chatbot) | 455 |
-|[michaelthwan/searchGPT](https://github.com/michaelthwan/searchGPT) | 455 |
-|[freddyaboulton/gradio-tools](https://github.com/freddyaboulton/gradio-tools) | 450 |
-|[amosjyng/langchain-visualizer](https://github.com/amosjyng/langchain-visualizer) | 446 |
-|[msoedov/langcorn](https://github.com/msoedov/langcorn) | 445 |
-|[plastic-labs/tutor-gpt](https://github.com/plastic-labs/tutor-gpt) | 426 |
-|[poe-platform/poe-protocol](https://github.com/poe-platform/poe-protocol) | 426 |
-|[jonra1993/fastapi-alembic-sqlmodel-async](https://github.com/jonra1993/fastapi-alembic-sqlmodel-async) | 418 |
-|[langchain-ai/auto-evaluator](https://github.com/langchain-ai/auto-evaluator) | 416 |
-|[steamship-core/steamship-langchain](https://github.com/steamship-core/steamship-langchain) | 401 |
-|[xuwenhao/geektime-ai-course](https://github.com/xuwenhao/geektime-ai-course) | 400 |
-|[continuum-llms/chatgpt-memory](https://github.com/continuum-llms/chatgpt-memory) | 386 |
-|[mtenenholtz/chat-twitter](https://github.com/mtenenholtz/chat-twitter) | 382 |
-|[explosion/spacy-llm](https://github.com/explosion/spacy-llm) | 368 |
-|[showlab/VLog](https://github.com/showlab/VLog) | 363 |
-|[yvann-hub/Robby-chatbot](https://github.com/yvann-hub/Robby-chatbot) | 363 |
-|[daodao97/chatdoc](https://github.com/daodao97/chatdoc) | 361 |
-|[opentensor/bittensor](https://github.com/opentensor/bittensor) | 360 |
-|[alejandro-ao/langchain-ask-pdf](https://github.com/alejandro-ao/langchain-ask-pdf) | 355 |
-|[logan-markewich/llama_index_starter_pack](https://github.com/logan-markewich/llama_index_starter_pack) | 351 |
-|[jupyterlab/jupyter-ai](https://github.com/jupyterlab/jupyter-ai) | 348 |
-|[alejandro-ao/ask-multiple-pdfs](https://github.com/alejandro-ao/ask-multiple-pdfs) | 321 |
-|[andylokandy/gpt-4-search](https://github.com/andylokandy/gpt-4-search) | 314 |
-|[mosaicml/examples](https://github.com/mosaicml/examples) | 313 |
-|[personoids/personoids-lite](https://github.com/personoids/personoids-lite) | 306 |
-|[itamargol/openai](https://github.com/itamargol/openai) | 304 |
-|[Anil-matcha/Website-to-Chatbot](https://github.com/Anil-matcha/Website-to-Chatbot) | 299 |
-|[momegas/megabots](https://github.com/momegas/megabots) | 299 |
-|[BlackHC/llm-strategy](https://github.com/BlackHC/llm-strategy) | 289 |
-|[daveebbelaar/langchain-experiments](https://github.com/daveebbelaar/langchain-experiments) | 283 |
-|[wandb/weave](https://github.com/wandb/weave) | 279 |
-|[Cheems-Seminar/grounded-segment-any-parts](https://github.com/Cheems-Seminar/grounded-segment-any-parts) | 273 |
-|[jerlendds/osintbuddy](https://github.com/jerlendds/osintbuddy) | 271 |
-|[OpenBMB/AgentVerse](https://github.com/OpenBMB/AgentVerse) | 270 |
-|[MagnivOrg/prompt-layer-library](https://github.com/MagnivOrg/prompt-layer-library) | 269 |
-|[sullivan-sean/chat-langchainjs](https://github.com/sullivan-sean/chat-langchainjs) | 259 |
-|[Azure-Samples/openai](https://github.com/Azure-Samples/openai) | 252 |
-|[bborn/howdoi.ai](https://github.com/bborn/howdoi.ai) | 248 |
-|[hnawaz007/pythondataanalysis](https://github.com/hnawaz007/pythondataanalysis) | 247 |
-|[conceptofmind/toolformer](https://github.com/conceptofmind/toolformer) | 243 |
-|[truera/trulens](https://github.com/truera/trulens) | 239 |
-|[ur-whitelab/exmol](https://github.com/ur-whitelab/exmol) | 238 |
-|[intel/intel-extension-for-transformers](https://github.com/intel/intel-extension-for-transformers) | 237 |
-|[monarch-initiative/ontogpt](https://github.com/monarch-initiative/ontogpt) | 236 |
-|[wandb/edu](https://github.com/wandb/edu) | 231 |
-|[recalign/RecAlign](https://github.com/recalign/RecAlign) | 229 |
-|[alvarosevilla95/autolang](https://github.com/alvarosevilla95/autolang) | 223 |
-|[kaleido-lab/dolphin](https://github.com/kaleido-lab/dolphin) | 221 |
-|[JohnSnowLabs/nlptest](https://github.com/JohnSnowLabs/nlptest) | 220 |
-|[paolorechia/learn-langchain](https://github.com/paolorechia/learn-langchain) | 219 |
-|[Safiullah-Rahu/CSV-AI](https://github.com/Safiullah-Rahu/CSV-AI) | 215 |
-|[Haste171/langchain-chatbot](https://github.com/Haste171/langchain-chatbot) | 215 |
-|[steamship-packages/langchain-agent-production-starter](https://github.com/steamship-packages/langchain-agent-production-starter) | 214 |
-|[airobotlab/KoChatGPT](https://github.com/airobotlab/KoChatGPT) | 213 |
-|[filip-michalsky/SalesGPT](https://github.com/filip-michalsky/SalesGPT) | 211 |
-|[marella/chatdocs](https://github.com/marella/chatdocs) | 207 |
-|[su77ungr/CASALIOY](https://github.com/su77ungr/CASALIOY) | 200 |
-|[shaman-ai/agent-actors](https://github.com/shaman-ai/agent-actors) | 195 |
-|[plchld/InsightFlow](https://github.com/plchld/InsightFlow) | 189 |
-|[jbrukh/gpt-jargon](https://github.com/jbrukh/gpt-jargon) | 186 |
-|[hwchase17/langchain-streamlit-template](https://github.com/hwchase17/langchain-streamlit-template) | 185 |
-|[huchenxucs/ChatDB](https://github.com/huchenxucs/ChatDB) | 179 |
-|[benthecoder/ClassGPT](https://github.com/benthecoder/ClassGPT) | 178 |
-|[hwchase17/chroma-langchain](https://github.com/hwchase17/chroma-langchain) | 178 |
-|[radi-cho/datasetGPT](https://github.com/radi-cho/datasetGPT) | 177 |
-|[jiran214/GPT-vup](https://github.com/jiran214/GPT-vup) | 176 |
-|[rsaryev/talk-codebase](https://github.com/rsaryev/talk-codebase) | 174 |
-|[edreisMD/plugnplai](https://github.com/edreisMD/plugnplai) | 174 |
-|[gia-guar/JARVIS-ChatGPT](https://github.com/gia-guar/JARVIS-ChatGPT) | 172 |
-|[hardbyte/qabot](https://github.com/hardbyte/qabot) | 171 |
-|[shamspias/customizable-gpt-chatbot](https://github.com/shamspias/customizable-gpt-chatbot) | 165 |
-|[gustavz/DataChad](https://github.com/gustavz/DataChad) | 164 |
-|[yasyf/compress-gpt](https://github.com/yasyf/compress-gpt) | 163 |
-|[SamPink/dev-gpt](https://github.com/SamPink/dev-gpt) | 161 |
-|[yuanjie-ai/ChatLLM](https://github.com/yuanjie-ai/ChatLLM) | 161 |
-|[pablomarin/GPT-Azure-Search-Engine](https://github.com/pablomarin/GPT-Azure-Search-Engine) | 160 |
-|[jondurbin/airoboros](https://github.com/jondurbin/airoboros) | 157 |
-|[fengyuli-dev/multimedia-gpt](https://github.com/fengyuli-dev/multimedia-gpt) | 157 |
-|[PradipNichite/Youtube-Tutorials](https://github.com/PradipNichite/Youtube-Tutorials) | 156 |
-|[nicknochnack/LangchainDocuments](https://github.com/nicknochnack/LangchainDocuments) | 155 |
-|[ethanyanjiali/minChatGPT](https://github.com/ethanyanjiali/minChatGPT) | 155 |
-|[ccurme/yolopandas](https://github.com/ccurme/yolopandas) | 154 |
-|[chakkaradeep/pyCodeAGI](https://github.com/chakkaradeep/pyCodeAGI) | 153 |
-|[preset-io/promptimize](https://github.com/preset-io/promptimize) | 150 |
-|[onlyphantom/llm-python](https://github.com/onlyphantom/llm-python) | 148 |
-|[Azure-Samples/azure-search-power-skills](https://github.com/Azure-Samples/azure-search-power-skills) | 146 |
-|[realminchoi/babyagi-ui](https://github.com/realminchoi/babyagi-ui) | 144 |
-|[microsoft/azure-openai-in-a-day-workshop](https://github.com/microsoft/azure-openai-in-a-day-workshop) | 144 |
-|[jmpaz/promptlib](https://github.com/jmpaz/promptlib) | 143 |
-|[shauryr/S2QA](https://github.com/shauryr/S2QA) | 142 |
-|[handrew/browserpilot](https://github.com/handrew/browserpilot) | 141 |
-|[Jaseci-Labs/jaseci](https://github.com/Jaseci-Labs/jaseci) | 140 |
-|[Klingefjord/chatgpt-telegram](https://github.com/Klingefjord/chatgpt-telegram) | 140 |
-|[WongSaang/chatgpt-ui-server](https://github.com/WongSaang/chatgpt-ui-server) | 139 |
-|[ibiscp/LLM-IMDB](https://github.com/ibiscp/LLM-IMDB) | 139 |
-|[menloparklab/langchain-cohere-qdrant-doc-retrieval](https://github.com/menloparklab/langchain-cohere-qdrant-doc-retrieval) | 138 |
-|[hirokidaichi/wanna](https://github.com/hirokidaichi/wanna) | 137 |
-|[steamship-core/vercel-examples](https://github.com/steamship-core/vercel-examples) | 137 |
-|[deeppavlov/dream](https://github.com/deeppavlov/dream) | 136 |
-|[miaoshouai/miaoshouai-assistant](https://github.com/miaoshouai/miaoshouai-assistant) | 135 |
-|[sugarforever/LangChain-Tutorials](https://github.com/sugarforever/LangChain-Tutorials) | 135 |
-|[yasyf/summ](https://github.com/yasyf/summ) | 135 |
-|[peterw/StoryStorm](https://github.com/peterw/StoryStorm) | 134 |
-|[vaibkumr/prompt-optimizer](https://github.com/vaibkumr/prompt-optimizer) | 132 |
-|[ju-bezdek/langchain-decorators](https://github.com/ju-bezdek/langchain-decorators) | 130 |
-|[homanp/vercel-langchain](https://github.com/homanp/vercel-langchain) | 128 |
-|[Teahouse-Studios/akari-bot](https://github.com/Teahouse-Studios/akari-bot) | 127 |
-|[petehunt/langchain-github-bot](https://github.com/petehunt/langchain-github-bot) | 125 |
-|[eunomia-bpf/GPTtrace](https://github.com/eunomia-bpf/GPTtrace) | 122 |
-|[fixie-ai/fixie-examples](https://github.com/fixie-ai/fixie-examples) | 122 |
-|[Aggregate-Intellect/practical-llms](https://github.com/Aggregate-Intellect/practical-llms) | 120 |
-|[davila7/file-gpt](https://github.com/davila7/file-gpt) | 120 |
-|[Azure-Samples/azure-search-openai-demo-csharp](https://github.com/Azure-Samples/azure-search-openai-demo-csharp) | 119 |
-|[prof-frink-lab/slangchain](https://github.com/prof-frink-lab/slangchain) | 117 |
-|[aurelio-labs/arxiv-bot](https://github.com/aurelio-labs/arxiv-bot) | 117 |
-|[zenml-io/zenml-projects](https://github.com/zenml-io/zenml-projects) | 116 |
-|[flurb18/AgentOoba](https://github.com/flurb18/AgentOoba) | 114 |
-|[kaarthik108/snowChat](https://github.com/kaarthik108/snowChat) | 112 |
-|[RedisVentures/redis-openai-qna](https://github.com/RedisVentures/redis-openai-qna) | 111 |
-|[solana-labs/chatgpt-plugin](https://github.com/solana-labs/chatgpt-plugin) | 111 |
-|[kulltc/chatgpt-sql](https://github.com/kulltc/chatgpt-sql) | 109 |
-|[summarizepaper/summarizepaper](https://github.com/summarizepaper/summarizepaper) | 109 |
-|[Azure-Samples/miyagi](https://github.com/Azure-Samples/miyagi) | 106 |
-|[ssheng/BentoChain](https://github.com/ssheng/BentoChain) | 106 |
-|[voxel51/voxelgpt](https://github.com/voxel51/voxelgpt) | 105 |
-|[mallahyari/drqa](https://github.com/mallahyari/drqa) | 103 |
-
-
-
-_Generated by [github-dependents-info](https://github.com/nvuillam/github-dependents-info)_
-
-[github-dependents-info --repo hwchase17/langchain --markdownfile dependents.md --minstars 100 --sort stars]

docs/extras/expression_language/cookbook.ipynb

@@ -1318,7 +1318,7 @@
    "source": [
     "template = \"\"\"Write some python code to solve the user's problem. \n",
     "\n",
-    "Return only python code in Markdown format, eg:\n",
+    "Return only python code in Markdown format, e.g.:\n",
     "\n",
     "```python\n",
     "....\n",

docs/extras/expression_language/interface.ipynb

@@ -62,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "id": "d1850a1f",
    "metadata": {},
    "outputs": [],
@@ -72,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "id": "56d0669f",
    "metadata": {},
    "outputs": [],
@@ -170,6 +170,36 @@
     "chain.batch([{\"topic\": \"bears\"}, {\"topic\": \"cats\"}])"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "2434ab15",
+   "metadata": {},
+   "source": [
+    "You can set the number of concurrent requests by using the `max_concurrency` parameter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a08522f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[AIMessage(content=\"Why don't bears wear shoes?\\n\\nBecause they have bear feet!\", additional_kwargs={}, example=False),\n",
+       " AIMessage(content=\"Why don't cats play poker in the wild?\\n\\nToo many cheetahs!\", additional_kwargs={}, example=False)]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.batch([{\"topic\": \"bears\"}, {\"topic\": \"cats\"}], config={\"max_concurrency\": 5})"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "b960cbfe",

docs/extras/guides/debugging.md

@@ -8,7 +8,7 @@ Here's a few different tools and functionalities to aid in debugging.
 
 ## Tracing
 
-Platforms with tracing capabilities like [LangSmith](/docs/guides/langsmith/) and [WandB](/docs/ecosystem/integrations/agent_with_wandb_tracing) are the most comprehensive solutions for debugging. These platforms make it easy to not only log and visualize LLM apps, but also to actively debug, test and refine them.
+Platforms with tracing capabilities like [LangSmith](/docs/guides/langsmith/) and [WandB](/docs/integrations/providers/wandb_tracing) are the most comprehensive solutions for debugging. These platforms make it easy to not only log and visualize LLM apps, but also to actively debug, test and refine them.
 
 For anyone building production-grade LLM applications, we highly recommend using a platform like this.
 

docs/extras/guides/deployments/template_repos.mdx

@@ -14,7 +14,7 @@ It also contains instructions for how to deploy this app on the Streamlit platfo
 
 ## [Gradio (on Hugging Face)](https://github.com/hwchase17/langchain-gradio-template)
 
-This repo serves as a template for how deploy a LangChain with Gradio.
+This repo serves as a template for how to deploy a LangChain with Gradio.
 It implements a chatbot interface, with a "Bring-Your-Own-Token" approach (nice for not wracking up big bills).
 It also contains instructions for how to deploy this app on the Hugging Face platform.
 This is heavily influenced by James Weaver's [excellent examples](https://huggingface.co/JavaFXpert).
@@ -27,7 +27,7 @@ Chainlit [doc](https://docs.chainlit.io/langchain) on the integration with LangC
 
 ## [Beam](https://github.com/slai-labs/get-beam/tree/main/examples/langchain-question-answering)
 
-This repo serves as a template for how deploy a LangChain with [Beam](https://beam.cloud).
+This repo serves as a template for how to deploy a LangChain with [Beam](https://beam.cloud).
 
 It implements a Question Answering app and contains instructions for deploying the app as a serverless REST API.
 
@@ -49,7 +49,7 @@ A minimal example of how to deploy LangChain to [Fly.io](https://fly.io/) using
 
 ## [Digitalocean App Platform](https://github.com/homanp/digitalocean-langchain)
 
-A minimal example on how to deploy LangChain to DigitalOcean App Platform.
+A minimal example of how to deploy LangChain to DigitalOcean App Platform.
 
 ## [CI/CD Google Cloud Build + Dockerfile + Serverless Google Cloud Run](https://github.com/g-emarco/github-assistant)
 
@@ -57,7 +57,7 @@ Boilerplate LangChain project on how to deploy to Google Cloud Run using Docker
 
 ## [Google Cloud Run](https://github.com/homanp/gcp-langchain)
 
-A minimal example on how to deploy LangChain to Google Cloud Run.
+A minimal example of how to deploy LangChain to Google Cloud Run.
 
 ## [SteamShip](https://github.com/steamship-core/steamship-langchain/)
 
@@ -79,3 +79,7 @@ See OpenLLM's [integration doc](https://github.com/bentoml/OpenLLM#%EF%B8%8F-int
 ## [Databutton](https://databutton.com/home?new-data-app=true)
 
 These templates serve as examples of how to build, deploy, and share LangChain applications using Databutton. You can create user interfaces with Streamlit, automate tasks by scheduling Python code, and store files and data in the built-in store. Examples include a Chatbot interface with conversational memory, a Personal search engine, and a starter template for LangChain apps. Deploying and sharing is just one click away.
+
+## [AzureML Online Endpoint](https://github.com/Azure/azureml-examples/blob/main/sdk/python/endpoints/online/llm/langchain/1_langchain_basic_deploy.ipynb)
+
+A minimal example of how to deploy LangChain to an Azure Machine Learning Online Endpoint. 

docs/extras/guides/fallbacks.ipynb

@@ -19,9 +19,9 @@
    "source": [
     "## Handling LLM API Errors\n",
     "\n",
-    "This is maybe the most common use case for fallbacks. A request to an LLM API can fail for a variety of reasons - the API could be down, you could have hit rate limits, any number of things. Therefor, using fallbacks can help protect against these types of things.\n",
+    "This is maybe the most common use case for fallbacks. A request to an LLM API can fail for a variety of reasons - the API could be down, you could have hit rate limits, any number of things. Therefore, using fallbacks can help protect against these types of things.\n",
     "\n",
-    "IMPORTANT: By default, a lot of the LLM wrappers catch errors and retry. You will most likely want to turn those off when working with fallbacks. Otherwise the first wrapper will keep on retying and not failing."
+    "IMPORTANT: By default, a lot of the LLM wrappers catch errors and retry. You will most likely want to turn those off when working with fallbacks. Otherwise the first wrapper will keep on retrying and not failing."
    ]
   },
   {
@@ -84,7 +84,7 @@
     "# Let's use just the OpenAI LLm first, to show that we run into an error\n",
     "with patch('openai.ChatCompletion.create', side_effect=RateLimitError()):\n",
     "    try:\n",
-    "         print(openai_llm.invoke(\"Why did the the chicken cross the road?\"))\n",
+    "         print(openai_llm.invoke(\"Why did the chicken cross the road?\"))\n",
     "    except:\n",
     "        print(\"Hit error\")"
    ]

docs/extras/guides/local_llms.ipynb

@@ -0,0 +1,601 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b8982428",
+   "metadata": {},
+   "source": [
+    "# Run LLMs locally\n",
+    "\n",
+    "## Use case\n",
+    "\n",
+    "The popularity of projects like [PrivateGPT](https://github.com/imartinez/privateGPT), [llama.cpp](https://github.com/ggerganov/llama.cpp), and [GPT4All](https://github.com/nomic-ai/gpt4all) underscore the demand to run LLMs locally (on your own device).\n",
+    "\n",
+    "This has at least two important benefits:\n",
+    "\n",
+    "1. `Privacy`: Your data is not sent to a third party, and it is not subject to the terms of service of a commercial service\n",
+    "2. `Cost`: There is no inference fee, which is important for token-intensive applications (e.g., [long-running simulations](https://twitter.com/RLanceMartin/status/1691097659262820352?s=20), summarization)\n",
+    "\n",
+    "## Overview\n",
+    "\n",
+    "Running an LLM locally requires a few things:\n",
+    "\n",
+    "1. `Open source LLM`: An open source LLM that can be freely modified and shared \n",
+    "2. `Inference`: Ability to run this LLM on your device w/ acceptable latency\n",
+    "\n",
+    "### Open Source LLMs\n",
+    "\n",
+    "Users can now gain access to a rapidly growing set of [open source LLMs](https://cameronrwolfe.substack.com/p/the-history-of-open-source-llms-better). \n",
+    "\n",
+    "These LLMs can be assessed across at least two dimentions (see figure):\n",
+    " \n",
+    "1. `Base model`: What is the base-model and how was it trained?\n",
+    "2. `Fine-tuning approach`: Was the base-model fine-tuned and, if so, what [set of instructions](https://cameronrwolfe.substack.com/p/beyond-llama-the-power-of-open-llms#%C2%A7alpaca-an-instruction-following-llama-model) was used?\n",
+    "\n",
+    "![Image description](/img/OSS_LLM_overview.png)\n",
+    "\n",
+    "The relative performance of these models can be assessed using several leaderboards, including:\n",
+    "\n",
+    "1. [LmSys](https://chat.lmsys.org/?arena)\n",
+    "2. [GPT4All](https://gpt4all.io/index.html)\n",
+    "3. [HuggingFace](https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard)\n",
+    "\n",
+    "### Inference\n",
+    "\n",
+    "A few frameworks for this have emerged to support inference of open source LLMs on various devices:\n",
+    "\n",
+    "1. [`llama.cpp`](https://github.com/ggerganov/llama.cpp): C++ implementation of llama inference code with [weight optimization / quantization](https://finbarr.ca/how-is-llama-cpp-possible/)\n",
+    "2. [`gpt4all`](https://docs.gpt4all.io/index.html): Optimized C backend for inference\n",
+    "3. [`Ollama`](https://ollama.ai/): Bundles model weights and environment into an app that runs on device and serves the LLM \n",
+    "\n",
+    "In general, these frameworks will do a few things:\n",
+    "\n",
+    "1. `Quantization`: Reduce the memory footprint of the raw model weights\n",
+    "2. `Efficient implementation for inference`: Support inference on consumer hardware (e.g., CPU or laptop GPU)\n",
+    "\n",
+    "In particular, see [this excellent post](https://finbarr.ca/how-is-llama-cpp-possible/) on the importance of quantization.\n",
+    "\n",
+    "![Image description](/img/llama-memory-weights.png)\n",
+    "\n",
+    "With less precision, we radically decrease the memory needed to store the LLM in memory.\n",
+    "\n",
+    "In addition, we can see the importance of GPU memory bandwidth [sheet](https://docs.google.com/spreadsheets/d/1OehfHHNSn66BP2h3Bxp2NJTVX97icU0GmCXF6pK23H8/edit#gid=0)!\n",
+    "\n",
+    "A Mac M2 Max is 5-6x faster than a M1 for inference due to the larger GPU memory bandwidth.\n",
+    "\n",
+    "![Image description](/img/llama_t_put.png)\n",
+    "\n",
+    "## Quickstart\n",
+    "\n",
+    "[`Ollama`](https://ollama.ai/) is one way to easily run inference on macOS.\n",
+    " \n",
+    "The instructions [here](docs/integrations/llms/ollama) provide details, which we summarize:\n",
+    " \n",
+    "* [Download and run](https://ollama.ai/download) the app\n",
+    "* From command line, fetch a model from this [list of options](https://github.com/jmorganca/ollama): e.g., `ollama pull llama2`\n",
+    "* When the app is running, all models are automatically served on `localhost:11434`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "86178adb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' The first man on the moon was Neil Armstrong, who landed on the moon on July 20, 1969 as part of the Apollo 11 mission. obviously.'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import Ollama\n",
+    "llm = Ollama(model=\"llama2\")\n",
+    "llm(\"The first man on the moon was ...\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "343ab645",
+   "metadata": {},
+   "source": [
+    "Stream tokens as they are being generated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "9cd83603",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " The first man to walk on the moon was Neil Armstrong, an American astronaut who was part of the Apollo 11 mission in 1969. февруари 20, 1969, Armstrong stepped out of the lunar module Eagle and onto the moon's surface, famously declaring \"That's one small step for man, one giant leap for mankind\" as he took his first steps. He was followed by fellow astronaut Edwin \"Buzz\" Aldrin, who also walked on the moon during the mission."
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "' The first man to walk on the moon was Neil Armstrong, an American astronaut who was part of the Apollo 11 mission in 1969. февруари 20, 1969, Armstrong stepped out of the lunar module Eagle and onto the moon\\'s surface, famously declaring \"That\\'s one small step for man, one giant leap for mankind\" as he took his first steps. He was followed by fellow astronaut Edwin \"Buzz\" Aldrin, who also walked on the moon during the mission.'"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.callbacks.manager import CallbackManager\n",
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler \n",
+    "llm = Ollama(model=\"llama2\", \n",
+    "             callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]))\n",
+    "llm(\"The first man on the moon was ...\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5cb27414",
+   "metadata": {},
+   "source": [
+    "## Environment\n",
+    "\n",
+    "Inference speed is a challenge when running models locally (see above).\n",
+    "\n",
+    "To minimize latency, it is desiable to run models locally on GPU, which ships with many consumer laptops [e.g., Apple devices](https://www.apple.com/newsroom/2022/06/apple-unveils-m2-with-breakthrough-performance-and-capabilities/).\n",
+    "\n",
+    "And even with GPU, the available GPU memory bandwidth (as noted above) is important.\n",
+    "\n",
+    "### Running Apple silicon GPU\n",
+    "\n",
+    "`Ollama` will automatically utilize the GPU on Apple devices.\n",
+    " \n",
+    "Other frameworks require the user to set up the environment to utilize the Apple GPU.\n",
+    "\n",
+    "For example, `llama.cpp` python bindings can be configured to use the GPU via [Metal](https://developer.apple.com/metal/).\n",
+    "\n",
+    "Metal is a graphics and compute API created by Apple providing near-direct access to the GPU. \n",
+    "\n",
+    "See the [`llama.cpp`](docs/integrations/llms/llamacpp) setup [here](https://github.com/abetlen/llama-cpp-python/blob/main/docs/install/macos.md) to enable this.\n",
+    "\n",
+    "In particular, ensure that conda is using the correct virtual enviorment that you created (`miniforge3`).\n",
+    "\n",
+    "E.g., for me:\n",
+    "\n",
+    "```\n",
+    "conda activate /Users/rlm/miniforge3/envs/llama\n",
+    "```\n",
+    "\n",
+    "With the above confirmed, then:\n",
+    "\n",
+    "```\n",
+    "CMAKE_ARGS=\"-DLLAMA_METAL=on\" FORCE_CMAKE=1 pip install -U llama-cpp-python --no-cache-dir\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c382e79a",
+   "metadata": {},
+   "source": [
+    "## LLMs\n",
+    "\n",
+    "There are various ways to gain access to quantized model weights.\n",
+    "\n",
+    "1. [`HuggingFace`](https://huggingface.co/TheBloke) - Many quantized model are available for download and can be run with framework such as [`llama.cpp`](https://github.com/ggerganov/llama.cpp)\n",
+    "2. [`gpt4all`](https://gpt4all.io/index.html) - The model explorer offers a leaderboard of metrics and associated quantized models available for download \n",
+    "3. [`Ollama`](https://github.com/jmorganca/ollama) - Several models can be accessed directly via `pull`\n",
+    "\n",
+    "### Ollama\n",
+    "\n",
+    "With [Ollama](docs/integrations/llms/ollama), fetch a model via `ollama pull <model family>:<tag>`:\n",
+    "\n",
+    "* E.g., for Llama-7b: `ollama pull llama2` will download the most basic version of the model (e.g., smallest # parameters and 4 bit quantization)\n",
+    "* We can also specify a particular version from the [model list](https://github.com/jmorganca/ollama), e.g., `ollama pull llama2:13b`\n",
+    "* See the full set of parameters on the [API reference page](https://api.python.langchain.com/en/latest/llms/langchain.llms.ollama.Ollama.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "8ecd2f78",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' Sure! Here\\'s the answer, broken down step by step:\\n\\nThe first man on the moon was... Neil Armstrong.\\n\\nHere\\'s how I arrived at that answer:\\n\\n1. The first manned mission to land on the moon was Apollo 11.\\n2. The mission included three astronauts: Neil Armstrong, Edwin \"Buzz\" Aldrin, and Michael Collins.\\n3. Neil Armstrong was the mission commander and the first person to set foot on the moon.\\n4. On July 20, 1969, Armstrong stepped out of the lunar module Eagle and onto the moon\\'s surface, famously declaring \"That\\'s one small step for man, one giant leap for mankind.\"\\n\\nSo, the first man on the moon was Neil Armstrong!'"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import Ollama\n",
+    "llm = Ollama(model=\"llama2:13b\")\n",
+    "llm(\"The first man on the moon was ... think step by step\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "07c8c0d1",
+   "metadata": {},
+   "source": [
+    "### Llama.cpp\n",
+    "\n",
+    "Llama.cpp is compatible with a [broad set of models](https://github.com/ggerganov/llama.cpp).\n",
+    "\n",
+    "For example, below we run inference on `llama2-13b` with 4 bit quantization downloaded from [HuggingFace](https://huggingface.co/TheBloke/Llama-2-13B-GGML/tree/main).\n",
+    "\n",
+    "As noted above, see the [API reference](https://api.python.langchain.com/en/latest/llms/langchain.llms.llamacpp.LlamaCpp.html?highlight=llamacpp#langchain.llms.llamacpp.LlamaCpp) for the full set of parameters. \n",
+    "\n",
+    "From the [llama.cpp docs](https://python.langchain.com/docs/integrations/llms/llamacpp), a few are worth commenting on:\n",
+    "\n",
+    "`n_gpu_layers`: number of layers to be loaded into GPU memory\n",
+    "\n",
+    "* Value: 1\n",
+    "* Meaning: Only one layer of the model will be loaded into GPU memory (1 is often sufficient).\n",
+    "\n",
+    "`n_batch`: number of tokens the model should process in parallel \n",
+    "* Value: n_batch\n",
+    "* Meaning: It's recommended to choose a value between 1 and n_ctx (which in this case is set to 2048)\n",
+    "\n",
+    "`n_ctx`: Token context window .\n",
+    "* Value: 2048\n",
+    "* Meaning: The model will consider a window of 2048 tokens at a time\n",
+    "\n",
+    "`f16_kv`: whether the model should use half-precision for the key/value cache\n",
+    "* Value: True\n",
+    "* Meaning: The model will use half-precision, which can be more memory efficient; Metal only support True."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5eba38dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CMAKE_ARGS=\"-DLLAMA_METAL=on\" FORCE_CMAKE=1 pip install -U llama-cpp-python --no-cache-dirclear"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a88bf0c8-e989-4bcd-bcb7-4d7757e684f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import LlamaCpp\n",
+    "llm = LlamaCpp(\n",
+    "    model_path=\"/Users/rlm/Desktop/Code/llama.cpp/models/openorca-platypus2-13b.gguf.q4_0.bin\",\n",
+    "    n_gpu_layers=1,\n",
+    "    n_batch=512,\n",
+    "    n_ctx=2048,\n",
+    "    f16_kv=True,  \n",
+    "    callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]),\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f56f5168",
+   "metadata": {},
+   "source": [
+    "The console log will show the the below to indicate Metal was enabled properly from steps above:\n",
+    "```\n",
+    "ggml_metal_init: allocating\n",
+    "ggml_metal_init: using MPS\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "7890a077",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Llama.generate: prefix-match hit\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " and use logical reasoning to figure out who the first man on the moon was.\n",
+      "\n",
+      "Here are some clues:\n",
+      "\n",
+      "1. The first man on the moon was an American.\n",
+      "2. He was part of the Apollo 11 mission.\n",
+      "3. He stepped out of the lunar module and became the first person to set foot on the moon's surface.\n",
+      "4. His last name is Armstrong.\n",
+      "\n",
+      "Now, let's use our reasoning skills to figure out who the first man on the moon was. Based on clue #1, we know that the first man on the moon was an American. Clue #2 tells us that he was part of the Apollo 11 mission. Clue #3 reveals that he was the first person to set foot on the moon's surface. And finally, clue #4 gives us his last name: Armstrong.\n",
+      "Therefore, the first man on the moon was Neil Armstrong!"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "llama_print_timings:        load time =  9623.21 ms\n",
+      "llama_print_timings:      sample time =   143.77 ms /   203 runs   (    0.71 ms per token,  1412.01 tokens per second)\n",
+      "llama_print_timings: prompt eval time =   485.94 ms /     7 tokens (   69.42 ms per token,    14.40 tokens per second)\n",
+      "llama_print_timings:        eval time =  6385.16 ms /   202 runs   (   31.61 ms per token,    31.64 tokens per second)\n",
+      "llama_print_timings:       total time =  7279.28 ms\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" and use logical reasoning to figure out who the first man on the moon was.\\n\\nHere are some clues:\\n\\n1. The first man on the moon was an American.\\n2. He was part of the Apollo 11 mission.\\n3. He stepped out of the lunar module and became the first person to set foot on the moon's surface.\\n4. His last name is Armstrong.\\n\\nNow, let's use our reasoning skills to figure out who the first man on the moon was. Based on clue #1, we know that the first man on the moon was an American. Clue #2 tells us that he was part of the Apollo 11 mission. Clue #3 reveals that he was the first person to set foot on the moon's surface. And finally, clue #4 gives us his last name: Armstrong.\\nTherefore, the first man on the moon was Neil Armstrong!\""
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm(\"The first man on the moon was ... Let's think step by step\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "831ddf7c",
+   "metadata": {},
+   "source": [
+    "### GPT4All\n",
+    "\n",
+    "We can use model weights downloaded from [GPT4All](https://python.langchain.com/docs/integrations/llms/gpt4all) model explorer.\n",
+    "\n",
+    "Similar to what is shown above, we can run inference and use [the API reference](https://api.python.langchain.com/en/latest/llms/langchain.llms.gpt4all.GPT4All.html?highlight=gpt4all#langchain.llms.gpt4all.GPT4All) to set parameters of interest."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e27baf6e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pip install gpt4all"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "915ecd4c-8f6b-4de3-a787-b64cb7c682b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import GPT4All\n",
+    "llm = GPT4All(model=\"/Users/rlm/Desktop/Code/gpt4all/models/nous-hermes-13b.ggmlv3.q4_0.bin\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "e3d4526f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\".\\n1) The United States decides to send a manned mission to the moon.2) They choose their best astronauts and train them for this specific mission.3) They build a spacecraft that can take humans to the moon, called the Lunar Module (LM).4) They also create a larger spacecraft, called the Saturn V rocket, which will launch both the LM and the Command Service Module (CSM), which will carry the astronauts into orbit.5) The mission is planned down to the smallest detail: from the trajectory of the rockets to the exact movements of the astronauts during their moon landing.6) On July 16, 1969, the Saturn V rocket launches from Kennedy Space Center in Florida, carrying the Apollo 11 mission crew into space.7) After one and a half orbits around the Earth, the LM separates from the CSM and begins its descent to the moon's surface.8) On July 20, 1969, at 2:56 pm EDT (GMT-4), Neil Armstrong becomes the first man on the moon. He speaks these\""
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm(\"The first man on the moon was ... Let's think step by step\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b84e543",
+   "metadata": {},
+   "source": [
+    "## Prompts\n",
+    "\n",
+    "Some LLMs will benefit from specific prompts.\n",
+    "\n",
+    "For example, LLaMA will use [special tokens](https://twitter.com/RLanceMartin/status/1681879318493003776?s=20).\n",
+    "\n",
+    "We can use `ConditionalPromptSelector` to set prompt based on the model type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16759b7c-7903-4269-b7b4-f83b313d8091",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set our LLM\n",
+    "llm = LlamaCpp(\n",
+    "    model_path=\"/Users/rlm/Desktop/Code/llama.cpp/models/openorca-platypus2-13b.gguf.q4_0.bin\",\n",
+    "    n_gpu_layers=1,\n",
+    "    n_batch=512,\n",
+    "    n_ctx=2048,\n",
+    "    f16_kv=True,  \n",
+    "    callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]),\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66656084",
+   "metadata": {},
+   "source": [
+    "Set the associated prompt based upon the model version."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "8555f5bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PromptTemplate(input_variables=['question'], output_parser=None, partial_variables={}, template='<<SYS>> \\n You are an assistant tasked with improving Google search results. \\n <</SYS>> \\n\\n [INST] Generate THREE Google search queries that are similar to this question. The output should be a numbered list of questions and each should have a question mark at the end: \\n\\n {question} [/INST]', template_format='f-string', validate_template=True)"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain import PromptTemplate, LLMChain\n",
+    "from langchain.chains.prompt_selector import ConditionalPromptSelector\n",
+    "\n",
+    "DEFAULT_LLAMA_SEARCH_PROMPT = PromptTemplate(\n",
+    "    input_variables=[\"question\"],\n",
+    "    template=\"\"\"<<SYS>> \\n You are an assistant tasked with improving Google search \\\n",
+    "results. \\n <</SYS>> \\n\\n [INST] Generate THREE Google search queries that \\\n",
+    "are similar to this question. The output should be a numbered list of questions \\\n",
+    "and each should have a question mark at the end: \\n\\n {question} [/INST]\"\"\",\n",
+    ")\n",
+    "\n",
+    "DEFAULT_SEARCH_PROMPT = PromptTemplate(\n",
+    "    input_variables=[\"question\"],\n",
+    "    template=\"\"\"You are an assistant tasked with improving Google search \\\n",
+    "results. Generate THREE Google search queries that are similar to \\\n",
+    "this question. The output should be a numbered list of questions and each \\\n",
+    "should have a question mark at the end: {question}\"\"\",\n",
+    ")\n",
+    "\n",
+    "QUESTION_PROMPT_SELECTOR = ConditionalPromptSelector(\n",
+    "                default_prompt=DEFAULT_SEARCH_PROMPT,\n",
+    "                conditionals=[\n",
+    "                    (lambda llm: isinstance(llm, LlamaCpp), DEFAULT_LLAMA_SEARCH_PROMPT)\n",
+    "                ],\n",
+    "            )\n",
+    "\n",
+    "prompt = QUESTION_PROMPT_SELECTOR.get_prompt(llm)\n",
+    "prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "d0aedfd2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  Sure! Here are three similar search queries with a question mark at the end:\n",
+      "\n",
+      "1. Which NBA team did LeBron James lead to a championship in the year he was drafted?\n",
+      "2. Who won the Grammy Awards for Best New Artist and Best Female Pop Vocal Performance in the same year that Lady Gaga was born?\n",
+      "3. What MLB team did Babe Ruth play for when he hit 60 home runs in a single season?"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "llama_print_timings:        load time = 14943.19 ms\n",
+      "llama_print_timings:      sample time =    72.93 ms /   101 runs   (    0.72 ms per token,  1384.87 tokens per second)\n",
+      "llama_print_timings: prompt eval time = 14942.95 ms /    93 tokens (  160.68 ms per token,     6.22 tokens per second)\n",
+      "llama_print_timings:        eval time =  3430.85 ms /   100 runs   (   34.31 ms per token,    29.15 tokens per second)\n",
+      "llama_print_timings:       total time = 18578.26 ms\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'  Sure! Here are three similar search queries with a question mark at the end:\\n\\n1. Which NBA team did LeBron James lead to a championship in the year he was drafted?\\n2. Who won the Grammy Awards for Best New Artist and Best Female Pop Vocal Performance in the same year that Lady Gaga was born?\\n3. What MLB team did Babe Ruth play for when he hit 60 home runs in a single season?'"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Chain\n",
+    "llm_chain = LLMChain(prompt=prompt,llm=llm)\n",
+    "question = \"What NFL team won the Super Bowl in the year that Justin Bieber was born?\"\n",
+    "llm_chain.run({\"question\":question})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e0d37e7-f1d9-4848-bf2c-c22392ee141f",
+   "metadata": {},
+   "source": [
+    "We also can use the LangChain Prompt Hub to fetch and / or store prompts that are model specific.\n",
+    "\n",
+    "This will work with your [LangSmith API key](https://docs.smith.langchain.com/).\n",
+    "\n",
+    "For example, [here](https://smith.langchain.com/hub/rlm/rag-prompt-llama) is a prompt for RAG with LLaMA-specific tokens."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6ba66260",
+   "metadata": {},
+   "source": [
+    "## Use cases\n",
+    "\n",
+    "Given an `llm` created from one of the models above, you can use it for [many use cases](docs/use_cases).\n",
+    "\n",
+    "For example, here is a guide to [RAG](docs/use_cases/question_answering/how_to/local_retrieval_qa) with local LLMs.\n",
+    "\n",
+    "In general, use cases for local LLMs can be driven by at least two factors:\n",
+    "\n",
+    "* `Privacy`: private data (e.g., journals, etc) that a user does not want to share \n",
+    "* `Cost`: text preprocessing (extraction/tagging), summarization, and agent simulations are token-use-intensive tasks\n",
+    "\n",
+    "In addition, [here](https://blog.langchain.dev/using-langsmith-to-support-fine-tuning-of-open-source-llms/) is an overview on fine-tuning, which can utilize open source LLMs."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/guides/privacy/_category_.yml

@@ -0,0 +1 @@
+label: 'Privacy'

docs/extras/guides/privacy/presidio_data_anonymization.ipynb

@@ -0,0 +1,451 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data anonymization with Microsoft Presidio\n",
+    "\n",
+    "[![Open In Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/extras/guides/privacy/presidio_data_anonymization.ipynb)\n",
+    "\n",
+    "## Use case\n",
+    "\n",
+    "Data anonymization is crucial before passing information to a language model like GPT-4 because it helps protect privacy and maintain confidentiality. If data is not anonymized, sensitive information such as names, addresses, contact numbers, or other identifiers linked to specific individuals could potentially be learned and misused. Hence, by obscuring or removing this personally identifiable information (PII), data can be used freely without compromising individuals' privacy rights or breaching data protection laws and regulations.\n",
+    "\n",
+    "## Overview\n",
+    "\n",
+    "Anonynization consists of two steps:\n",
+    "\n",
+    "1. **Identification:** Identify all data fields that contain personally identifiable information (PII).\n",
+    "2. **Replacement**: Replace all PIIs with pseudo values or codes that do not reveal any personal information about the individual but can be used for reference. We're not using regular encryption, because the language model won't be able to understand the meaning or context of the encrypted data.\n",
+    "\n",
+    "We use *Microsoft Presidio* together with *Faker* framework for anonymization purposes because of the wide range of functionalities they provide. The full implementation is available in `PresidioAnonymizer`.\n",
+    "\n",
+    "## Quickstart\n",
+    "\n",
+    "Below you will find the use case on how to leverage anonymization in LangChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install necessary packages\n",
+    "# ! pip install langchain langchain-experimental openai presidio-analyzer presidio-anonymizer spacy Faker\n",
+    "# ! python -m spacy download en_core_web_lg"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "Let's see how PII anonymization works using a sample sentence:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'My name is Mrs. Rachel Chen DDS, call me at 849-829-7628x073 or email me at christopherfrey@example.org'"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain_experimental.data_anonymizer import PresidioAnonymizer\n",
+    "\n",
+    "anonymizer = PresidioAnonymizer()\n",
+    "\n",
+    "anonymizer.anonymize(\n",
+    "    \"My name is Slim Shady, call me at 313-666-7440 or email me at real.slim.shady@gmail.com\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using with LangChain Expression Language\n",
+    "\n",
+    "With LCEL we can easily chain together anonymization with the rest of our application."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set env var OPENAI_API_KEY or load from a .env file:\n",
+    "# import dotenv\n",
+    "\n",
+    "# dotenv.load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='You can find our super secret data at https://www.ross.com/', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.prompts.prompt import PromptTemplate\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "\n",
+    "template = \"\"\"According to this text, where can you find our super secret data?\n",
+    "\n",
+    "{anonymized_text}\n",
+    "\n",
+    "Answer:\"\"\"\n",
+    "prompt = PromptTemplate.from_template(template)\n",
+    "llm = ChatOpenAI()\n",
+    "\n",
+    "chain = {\"anonymized_text\": anonymizer.anonymize} | prompt | llm\n",
+    "chain.invoke(\"You can find our super secret data at https://supersecretdata.com\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Customization\n",
+    "We can specify ``analyzed_fields`` to only anonymize particular types of data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'My name is Gabrielle Edwards, call me at 313-666-7440 or email me at real.slim.shady@gmail.com'"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "anonymizer = PresidioAnonymizer(analyzed_fields=[\"PERSON\"])\n",
+    "\n",
+    "anonymizer.anonymize(\n",
+    "    \"My name is Slim Shady, call me at 313-666-7440 or email me at real.slim.shady@gmail.com\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As can be observed, the name was correctly identified and replaced with another. The `analyzed_fields` attribute is responsible for what values are to be detected and substituted. We can add *PHONE_NUMBER* to the list:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'My name is Victoria Mckinney, call me at 713-549-8623 or email me at real.slim.shady@gmail.com'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "anonymizer = PresidioAnonymizer(analyzed_fields=[\"PERSON\", \"PHONE_NUMBER\"])\n",
+    "anonymizer.anonymize(\n",
+    "    \"My name is Slim Shady, call me at 313-666-7440 or email me at real.slim.shady@gmail.com\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "If no analyzed_fields are specified, by default the anonymizer will detect all supported formats. Below is the full list of them:\n",
+    "\n",
+    "`['PERSON', 'EMAIL_ADDRESS', 'PHONE_NUMBER', 'IBAN_CODE', 'CREDIT_CARD', 'CRYPTO', 'IP_ADDRESS', 'LOCATION', 'DATE_TIME', 'NRP', 'MEDICAL_LICENSE', 'URL', 'US_BANK_NUMBER', 'US_DRIVER_LICENSE', 'US_ITIN', 'US_PASSPORT', 'US_SSN']`\n",
+    "\n",
+    "**Disclaimer:** We suggest carefully defining the private data to be detected - Presidio doesn't work perfectly and it sometimes makes mistakes, so it's better to have more control over the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'My name is Billy Russo, call me at 970-996-9453x038 or email me at jamie80@example.org'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "anonymizer = PresidioAnonymizer()\n",
+    "anonymizer.anonymize(\n",
+    "    \"My name is Slim Shady, call me at 313-666-7440 or email me at real.slim.shady@gmail.com\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "It may be that the above list of detected fields is not sufficient. For example, the already available *PHONE_NUMBER* field does not support polish phone numbers and confuses it with another field:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'My polish phone number is EVIA70648911396944'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "anonymizer = PresidioAnonymizer()\n",
+    "anonymizer.anonymize(\"My polish phone number is 666555444\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "You can then write your own recognizers and add them to the pool of those present. How exactly to create recognizers is described in the [Presidio documentation](https://microsoft.github.io/presidio/samples/python/customizing_presidio_analyzer/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the regex pattern in a Presidio `Pattern` object:\n",
+    "from presidio_analyzer import Pattern, PatternRecognizer\n",
+    "\n",
+    "\n",
+    "polish_phone_numbers_pattern = Pattern(\n",
+    "    name=\"polish_phone_numbers_pattern\",\n",
+    "    regex=\"(?<!\\w)(\\(?(\\+|00)?48\\)?)?[ -]?\\d{3}[ -]?\\d{3}[ -]?\\d{3}(?!\\w)\",\n",
+    "    score=1,\n",
+    ")\n",
+    "\n",
+    "# Define the recognizer with one or more patterns\n",
+    "polish_phone_numbers_recognizer = PatternRecognizer(\n",
+    "    supported_entity=\"POLISH_PHONE_NUMBER\", patterns=[polish_phone_numbers_pattern]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "Now, we can add recognizer by calling `add_recognizer` method on the anonymizer:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "anonymizer.add_recognizer(polish_phone_numbers_recognizer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "And voilà! With the added pattern-based recognizer, the anonymizer now handles polish phone numbers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "My polish phone number is <POLISH_PHONE_NUMBER>\n",
+      "My polish phone number is <POLISH_PHONE_NUMBER>\n",
+      "My polish phone number is <POLISH_PHONE_NUMBER>\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(anonymizer.anonymize(\"My polish phone number is 666555444\"))\n",
+    "print(anonymizer.anonymize(\"My polish phone number is 666 555 444\"))\n",
+    "print(anonymizer.anonymize(\"My polish phone number is +48 666 555 444\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "The problem is - even though we recognize polish phone numbers now, we don't have a method (operator) that would tell how to substitute a given field - because of this, in the outpit we only provide string `<POLISH_PHONE_NUMBER>` We need to create a method to replace it correctly: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'+48 533 220 543'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from faker import Faker\n",
+    "\n",
+    "fake = Faker(locale=\"pl_PL\")\n",
+    "\n",
+    "\n",
+    "def fake_polish_phone_number(_=None):\n",
+    "    return fake.phone_number()\n",
+    "\n",
+    "\n",
+    "fake_polish_phone_number()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\\n",
+    "We used Faker to create pseudo data. Now we can create an operator and add it to the anonymizer. For complete information about operators and their creation, see the Presidio documentation for [simple](https://microsoft.github.io/presidio/tutorial/10_simple_anonymization/) and [custom](https://microsoft.github.io/presidio/tutorial/11_custom_anonymization/) anonymization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from presidio_anonymizer.entities import OperatorConfig\n",
+    "\n",
+    "new_operators = {\n",
+    "    \"POLISH_PHONE_NUMBER\": OperatorConfig(\n",
+    "        \"custom\", {\"lambda\": fake_polish_phone_number}\n",
+    "    )\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "anonymizer.add_operators(new_operators)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'My polish phone number is +48 692 715 636'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "anonymizer.anonymize(\"My polish phone number is 666555444\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Future works\n",
+    "\n",
+    "- **deanonymization** - add the ability to reverse anonymization. For example, the workflow could look like this: `anonymize -> LLMChain -> deanonymize`. By doing this, we will retain anonymity in requests to, for example, OpenAI, and then be able restore the original data.\n",
+    "- **instance anonymization** - at this point, each occurrence of PII is treated as a separate entity and separately anonymized. Therefore, two occurrences of the name John Doe in the text will be changed to two different names. It is therefore worth introducing support for full instance detection, so that repeated occurrences are treated as a single object."
+   ]
+  }
+ ],
+ "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": 4
+}

docs/extras/guides/pydantic_compatibility.md

@@ -0,0 +1,105 @@
+# Pydantic compatibility
+
+- Pydantic v2 was released in June, 2023 (https://docs.pydantic.dev/2.0/blog/pydantic-v2-final/)
+- v2 contains has a number of breaking changes (https://docs.pydantic.dev/2.0/migration/)
+- Pydantic v2 and v1 are under the same package name, so both versions cannot be installed at the same time
+
+## LangChain Pydantic migration plan
+
+As of `langchain>=0.0.267`, LangChain will allow users to install either Pydantic V1 or V2. 
+   * Internally LangChain will continue to [use V1](https://docs.pydantic.dev/latest/migration/#continue-using-pydantic-v1-features).
+   * During this time, users can pin their pydantic version to v1 to avoid breaking changes, or start a partial
+   migration using pydantic v2 throughout their code, but avoiding mixing v1 and v2 code for LangChain (see below).
+
+User can either pin to pydantic v1, and upgrade their code in one go once LangChain has migrated to v2 internally, or they can start a partial migration to v2, but must avoid mixing v1 and v2 code for LangChain.
+
+Below are two examples of showing how to avoid mixing pydantic v1 and v2 code in
+the case of inheritance and in the case of passing objects to LangChain.
+
+**Example 1: Extending via inheritance**
+
+**YES** 
+
+```python
+from pydantic.v1 import root_validator, validator
+
+class CustomTool(BaseTool): # BaseTool is v1 code
+    x: int = Field(default=1)
+
+    def _run(*args, **kwargs):
+        return "hello"
+
+    @validator('x') # v1 code
+    @classmethod
+    def validate_x(cls, x: int) -> int:
+        return 1
+    
+
+CustomTool(
+    name='custom_tool',
+    description="hello",
+    x=1,
+)
+```
+
+Mixing Pydantic v2 primitives with Pydantic v1 primitives can raise cryptic errors
+
+**NO** 
+
+```python
+from pydantic import Field, field_validator # pydantic v2
+
+class CustomTool(BaseTool): # BaseTool is v1 code
+    x: int = Field(default=1)
+
+    def _run(*args, **kwargs):
+        return "hello"
+
+    @field_validator('x') # v2 code
+    @classmethod
+    def validate_x(cls, x: int) -> int:
+        return 1
+    
+
+CustomTool( 
+    name='custom_tool',
+    description="hello",
+    x=1,
+)
+```
+
+**Example 2: Passing objects to LangChain**
+
+**YES**
+
+```python
+from langchain.tools.base import Tool
+from pydantic.v1 import BaseModel, Field # <-- Uses v1 namespace
+
+class CalculatorInput(BaseModel):
+    question: str = Field()
+
+Tool.from_function( # <-- tool uses v1 namespace
+    func=lambda question: 'hello',
+    name="Calculator",
+    description="useful for when you need to answer questions about math",
+    args_schema=CalculatorInput
+)
+```
+
+**NO**
+
+```python
+from langchain.tools.base import Tool
+from pydantic import BaseModel, Field # <-- Uses v2 namespace
+
+class CalculatorInput(BaseModel):
+    question: str = Field()
+
+Tool.from_function( # <-- tool uses v1 namespace
+    func=lambda question: 'hello',
+    name="Calculator",
+    description="useful for when you need to answer questions about math",
+    args_schema=CalculatorInput
+)
+```

docs/extras/integrations/callbacks/context.ipynb

@@ -93,7 +93,7 @@
    "metadata": {},
    "source": [
     "## Usage\n",
-    "### Using the Context callback within a Chat Model\n",
+    "### Using the Context callback within a chat model\n",
     "\n",
     "The Context callback handler can be used to directly record transcripts between users and AI assistants.\n",
     "\n",

docs/extras/integrations/callbacks/llmonitor.md

@@ -0,0 +1,63 @@
+# LLMonitor
+
+[LLMonitor](https://llmonitor.com) is an open-source observability platform that provides cost tracking, user tracking and powerful agent tracing.
+
+<video controls width='100%' >
+  <source src='https://llmonitor.com/videos/demo-annotated.mp4'/>
+</video>
+
+## Setup
+Create an account on [llmonitor.com](https://llmonitor.com), create an `App`, and then copy the associated `tracking id`.
+Once you have it, set it as an environment variable by running:
+```bash
+export LLMONITOR_APP_ID="..."
+```
+
+If you'd prefer not to set an environment variable, you can pass the key directly when initializing the callback handler:
+```python
+from langchain.callbacks import LLMonitorCallbackHandler
+
+handler = LLMonitorCallbackHandler(app_id="...")
+```
+
+## Usage with LLM/Chat models
+```python
+from langchain.llms import OpenAI
+from langchain.chat_models import ChatOpenAI
+from langchain.callbacks import LLMonitorCallbackHandler
+
+handler = LLMonitorCallbackHandler(app_id="...")
+
+llm = OpenAI(
+    callbacks=[handler],
+)
+
+chat = ChatOpenAI(
+    callbacks=[handler],
+    metadata={"userId": "123"},  # you can assign user ids to models in the metadata
+)
+```
+
+
+## Usage with agents
+```python
+from langchain.agents import load_tools, initialize_agent, AgentType
+from langchain.llms import OpenAI
+from langchain.callbacks import LLMonitorCallbackHandler
+
+handler = LLMonitorCallbackHandler(app_id="...")
+
+llm = OpenAI(temperature=0)
+tools = load_tools(["serpapi", "llm-math"], llm=llm)
+agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
+agent.run(
+    "Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?",
+    callbacks=[handler],
+    metadata={
+        "agentName": "Leo DiCaprio's girlfriend",  # you can assign a custom agent in the metadata
+    },
+)
+```
+
+## Support
+For any question or issue with integration you can reach out to the LLMonitor team on [Discord](http://discord.com/invite/8PafSG58kK) or via [email](mailto:vince@llmonitor.com).