x

.devcontainer/Dockerfile

@@ -0,0 +1,42 @@
+# This is a Dockerfile for Developer Container
+
+# Use the Python base image
+ARG VARIANT="3.11-bullseye"
+FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT} AS langchain-dev-base
+
+USER vscode
+
+# Define the version of Poetry to install (default is 1.4.2)
+# Define the directory of python virtual environment
+ARG PYTHON_VIRTUALENV_HOME=/home/vscode/langchain-py-env \
+    POETRY_VERSION=1.4.2 
+
+ENV POETRY_VIRTUALENVS_IN_PROJECT=false \
+    POETRY_NO_INTERACTION=true 
+
+# Create a Python virtual environment for Poetry and install it
+RUN python3 -m venv ${PYTHON_VIRTUALENV_HOME} && \
+    $PYTHON_VIRTUALENV_HOME/bin/pip install --upgrade pip && \
+    $PYTHON_VIRTUALENV_HOME/bin/pip install poetry==${POETRY_VERSION}
+
+ENV PATH="$PYTHON_VIRTUALENV_HOME/bin:$PATH" \
+    VIRTUAL_ENV=$PYTHON_VIRTUALENV_HOME
+
+# Setup for bash
+RUN poetry completions bash >> /home/vscode/.bash_completion && \
+    echo "export PATH=$PYTHON_VIRTUALENV_HOME/bin:$PATH" >> ~/.bashrc
+
+# Set the working directory for the app
+WORKDIR /workspaces/langchain
+
+# Use a multi-stage build to install dependencies
+FROM langchain-dev-base AS langchain-dev-dependencies
+
+ARG PYTHON_VIRTUALENV_HOME
+
+# Copy only the dependency files for installation
+COPY pyproject.toml poetry.lock poetry.toml ./
+
+# Install the Poetry dependencies (this layer will be cached as long as the dependencies don't change)
+RUN poetry install --no-interaction --no-ansi --with dev,test,docs
+

.devcontainer/README.md

@@ -1,41 +0,0 @@
-# Dev container
-
-This project includes a [dev container](https://containers.dev/), which lets you use a container as a full-featured dev environment.
-
-You can use the dev container configuration in this folder to build and run the app without needing to install any of its tools locally! You can use it in [GitHub Codespaces](https://github.com/features/codespaces) or the [VS Code Dev Containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers).
-
-## GitHub Codespaces
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/hwchase17/langchain)
-
-You may use the button above, or follow these steps to open this repo in a Codespace:
-1. Click the **Code** drop-down menu at the top of https://github.com/hwchase17/langchain.
-1. Click on the **Codespaces** tab.
-1. Click **Create codespace on master** .
-
-For more info, check out the [GitHub documentation](https://docs.github.com/en/free-pro-team@latest/github/developing-online-with-codespaces/creating-a-codespace#creating-a-codespace).
-  
-## VS Code Dev Containers
-[![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchain)
-
-Note: If you click this link you will open the main repo and not your local cloned repo, you can use this link and replace with your username and cloned repo name: 
-https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/<yourusername>/<yourclonedreponame>
-
-
-If you already have VS Code and Docker installed, you can use the button above to get started. This will cause VS Code to automatically install the Dev Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use.
-
-You can also follow these steps to open this repo in a container using the VS Code Dev Containers extension:
-
-1. If this is your first time using a development container, please ensure your system meets the pre-reqs (i.e. have Docker installed) in the [getting started steps](https://aka.ms/vscode-remote/containers/getting-started).
-
-2. Open a locally cloned copy of the code:
-
-   - Fork and Clone this repository to your local filesystem.
-   - Press <kbd>F1</kbd> and select the **Dev Containers: Open Folder in Container...** command.
-   - Select the cloned copy of this folder, wait for the container to start, and try things out!
-
-You can learn more in the [Dev Containers documentation](https://code.visualstudio.com/docs/devcontainers/containers).
-
-## Tips and tricks
-
-* If you are working with the same repository folder in a container and Windows, you'll want consistent line endings (otherwise you may see hundreds of changes in the SCM view). The `.gitattributes` file in the root of this repo will disable line ending conversion and should prevent this. See [tips and tricks](https://code.visualstudio.com/docs/devcontainers/tips-and-tricks#_resolving-git-line-ending-issues-in-containers-resulting-in-many-modified-files) for more info.
-* If you'd like to review the contents of the image used in this dev container, you can check it out in the [devcontainers/images](https://github.com/devcontainers/images/tree/main/src/python) repo.

.devcontainer/devcontainer.json

@@ -1,26 +1,24 @@
 // For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-dockerfile
 {
-	// Name for the dev container
-	"name": "langchain",
-
-	// Point to a Docker Compose file
 	"dockerComposeFile": "./docker-compose.yaml",
-
-	// Required when using Docker Compose. The name of the service to connect to once running
 	"service": "langchain",
+	"workspaceFolder": "/workspaces/langchain",
+	"name": "langchain",
+	"customizations": {
+		"vscode": {
+			"extensions": [   
+				"ms-python.python"
+			],
+			"settings": {
+				"python.defaultInterpreterPath": "/home/vscode/langchain-py-env/bin/python3.11"
+			}
+		}
+		
+	},
 
-	// The optional 'workspaceFolder' property is the path VS Code should open by default when
-	// connected. This is typically a file mount in .devcontainer/docker-compose.yml
-	"workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
-
-	// Prevent the container from shutting down
-	"overrideCommand": true
-
-	// Features to add to the dev container. More info: https://containers.dev/features
-	// "features": {
-	// 	"ghcr.io/devcontainers-contrib/features/poetry:2": {}
-	// }
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	"features": {},
 
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	// "forwardPorts": [],
@@ -28,9 +26,8 @@
 	// Uncomment the next line to run commands after the container is created.
 	// "postCreateCommand": "cat /etc/os-release",
 
-	// Configure tool-specific properties.
-	// "customizations": {},
-
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
+	// Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "devcontainer"
+	"remoteUser": "vscode",
+	"overrideCommand": true
 }

.devcontainer/docker-compose.yaml

@@ -2,11 +2,10 @@ version: '3'
 services:
   langchain:
     build:
-      dockerfile: libs/langchain/dev.Dockerfile
-      context: ..
+      dockerfile: .devcontainer/Dockerfile
+      context: ../ 
     volumes:
-   # Update this to wherever you want VS Code to mount the folder of your project
-      - ..:/workspaces:cached
+      - ../:/workspaces/langchain
     networks:
       - langchain-network 
   #   environment:

.gitattributes

@@ -1,3 +0,0 @@
-* text=auto eol=lf
-*.{cmd,[cC][mM][dD]} text eol=crlf
-*.{bat,[bB][aA][tT]} text eol=crlf

.github/CONTRIBUTING.md

@@ -59,8 +59,6 @@ we do not want these to get in the way of getting good code into the codebase.
 
 ## 🚀 Quick Start
 
-> **Note:** You can run this repository locally (which is described below) or in a [development container](https://containers.dev/) (which is described in the [.devcontainer folder](https://github.com/hwchase17/langchain/tree/master/.devcontainer)).
-
 This 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.
 
 ❗Note: If you use `Conda` or `Pyenv` as your environment / package manager, avoid dependency conflicts by doing the following first:
@@ -69,14 +67,6 @@ This project uses [Poetry](https://python-poetry.org/) as a dependency manager.
 3. Tell Poetry to use the virtualenv python environment (`poetry config virtualenvs.prefer-active-python true`)
 4. Continue with the following steps.
 
-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. 
-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
@@ -103,14 +93,6 @@ To run formatting for this project:
 make format
 ```
 
-Additionally, you can run the formatter only on the files that have been modified in your current branch as compared to the master branch using the format_diff command:
-
-```bash
-make format_diff
-```
-
-This is especially useful when you have made changes to a subset of the project and want to ensure your changes are properly formatted without affecting the rest of the codebase.
-
 ### Linting
 
 Linting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/), [isort](https://pycqa.github.io/isort/), [flake8](https://flake8.pycqa.org/en/latest/), and [mypy](http://mypy-lang.org/).
@@ -121,42 +103,8 @@ To run linting for this project:
 make lint
 ```
 
-In addition, you can run the linter only on the files that have been modified in your current branch as compared to the master branch using the lint_diff command:
-
-```bash
-make lint_diff
-```
-
-This can be very helpful when you've made changes to only certain parts of the project and want to ensure your changes meet the linting standards without having to check the entire codebase.
-
 We recognize linting can be annoying - if you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
 
-### Spellcheck
-
-Spellchecking for this project is done via [codespell](https://github.com/codespell-project/codespell).
-Note that `codespell` finds common typos, so could have false-positive (correctly spelled but rarely used) and false-negatives (not finding misspelled) words.
-
-To check spelling for this project:
-
-```bash
-make spell_check
-```
-
-To fix spelling in place:
-
-```bash
-make spell_fix
-```
-
-If codespell is incorrectly flagging a word, you can skip spellcheck for that word by adding it to the codespell config in the `pyproject.toml` file.
-
-```python
-[tool.codespell]
-...
-# Add here:
-ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogyny,unsecure'
-```
-
 ### Coverage
 
 Code coverage (i.e. the amount of code that is covered by unit tests) helps identify areas of the code that are potentially more or less brittle.
@@ -256,43 +204,32 @@ When you run `poetry install`, the `langchain` package is installed as editable
 
 ## Documentation
 
-While the code is split between `langchain` and `langchain.experimental`, the documentation is one holistic thing.
-This covers how to get started contributing to documentation.
-
 ### Contribute Documentation
 
-The docs directory contains Documentation and API Reference.
+Docs are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
 
-Documentation is built using [Docusaurus 2](https://docusaurus.io/).
-
-API Reference are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
 For that reason, we ask that you add good documentation to all classes and methods.
 
 Similar to linting, we recognize documentation can be annoying. If you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
 
 ### Build Documentation Locally
 
-In the following commands, the prefix `api_` indicates that those are operations for the API Reference.
-
 Before building the documentation, it is always a good idea to clean the build directory:
 
 ```bash
 make docs_clean
-make api_docs_clean
 ```
 
-Next, you can build the documentation as outlined below:
-
-```bash
-make docs_build
-make api_docs_build
-```
-
-Finally, you can run the linkchecker to make sure all links are valid:
+Next, you can run the linkchecker to make sure all links are valid:
 
 ```bash
 make docs_linkcheck
-make api_docs_linkcheck
+```
+
+Finally, you can build the documentation as outlined below:
+
+```bash
+make docs_build
 ```
 
 ## 🏭 Release Process

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -46,7 +46,7 @@ body:
         - @agola11
 
         Tools / Toolkits
-        - ...
+        - @vowelparrot
 
       placeholder: "@Username ..."
 

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,28 +1,56 @@
-<!-- Thank you for contributing to LangChain!
+<!--
+Thank you for contributing to LangChain! Your PR will appear in our release under the title you set. Please make sure it highlights your valuable contribution.
 
-Replace this comment with:
-  - Description: a description of the change, 
-  - Issue: the issue # it fixes (if applicable),
-  - Dependencies: any dependencies required for this change,
-  - Tag maintainer: for a quicker response, tag the relevant maintainer (see below),
-  - Twitter handle: we announce bigger features on Twitter. If your PR gets announced and you'd like a mention, we'll gladly shout you out!
+Replace this with a description of the change, the issue it fixes (if applicable), and relevant context. List any dependencies required for this change.
 
-Please make sure you're PR is passing linting and testing before submitting. Run `make format`, `make lint` and `make test` to check this locally.
+After you're done, someone will review your PR. They may suggest improvements. If no one reviews your PR within a few days, feel free to @-mention the same people again, as notifications can get lost.
 
-If you're adding a new integration, please include:
-  1. a test for the integration, preferably unit tests that do not rely on network access,
-  2. an example notebook showing its use.
+Finally, we'd love to show appreciation for your contribution - if you'd like us to shout you out on Twitter, please also include your handle!
+-->
 
-Maintainer responsibilities:
-  - General / Misc / if you don't know who to tag: @baskaryan
-  - DataLoaders / VectorStores / Retrievers: @rlancemartin, @eyurtsev
-  - Models / Prompts: @hwchase17, @baskaryan
-  - Memory: @hwchase17
-  - Agents / Tools / Toolkits: @hinthornw
-  - Tracing / Callbacks: @agola11
-  - Async: @agola11
+<!-- Remove if not applicable -->
 
-If no one reviews your PR within a few days, feel free to @-mention the same people again.
+Fixes # (issue)
+
+#### Before submitting
+
+<!-- If you're adding a new integration, please include:
+
+1. a test for the integration - favor unit tests that does not rely on network access.
+2. an example notebook showing its use
+
+
+See contribution guidelines for more information on how to write tests, lint
+etc:
+
+https://github.com/hwchase17/langchain/blob/master/.github/CONTRIBUTING.md
+-->
+
+#### Who can review?
+
+Tag maintainers/contributors who might be interested:
+
+<!-- For a quicker response, figure out the right person to tag with @
+
+  @hwchase17 - project lead
+
+  Tracing / Callbacks
+  - @agola11
+
+  Async
+  - @agola11
+
+  DataLoaders
+  - @eyurtsev
+
+  Models
+  - @hwchase17
+  - @agola11
+
+  Agents / Tools / Toolkits
+  - @vowelparrot
+
+  VectorStores / Retrievers / Memory
+  - @dev2049
 
-See contribution guidelines for more information on how to write/run tests, lint, etc: https://github.com/hwchase17/langchain/blob/master/.github/CONTRIBUTING.md
  -->

.github/actions/poetry_setup/action.yml

@@ -52,13 +52,11 @@ runs:
 
     - 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
 

.github/workflows/_lint.yml

@@ -1,46 +0,0 @@
-name: lint
-
-on:
-  workflow_call:
-    inputs:
-      working-directory:
-        required: true
-        type: string
-        description: "From which folder this pipeline executes"
-
-env:
-  POETRY_VERSION: "1.4.2"
-
-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"
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install poetry
-        run: |
-          pipx install poetry==$POETRY_VERSION
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: poetry
-      - name: Install dependencies
-        run: |
-          poetry install
-      - name: Install langchain editable
-        if: ${{ inputs.working-directory != 'langchain' }}
-        run: |
-          pip install -e ../langchain
-      - name: Analysing the code with our lint
-        run: |
-          make lint

.github/workflows/_release.yml

@@ -1,52 +0,0 @@
-name: release
-
-on:
-  workflow_call:
-    inputs:
-      working-directory:
-        required: true
-        type: string
-        description: "From which folder this pipeline executes"
-
-env:
-  POETRY_VERSION: "1.4.2"
-
-jobs:
-  if_release:
-    if: |
-        ${{ github.event.pull_request.merged == true }}
-        && ${{ contains(github.event.pull_request.labels.*.name, 'release') }}
-    runs-on: ubuntu-latest
-    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
-        with:
-          python-version: "3.10"
-          cache: "poetry"
-      - name: Build project for distribution
-        run: poetry build
-      - name: Check Version
-        id: check-version
-        run: |
-          echo version=$(poetry version --short) >> $GITHUB_OUTPUT
-      - name: Create Release
-        uses: ncipollo/release-action@v1
-        if: ${{ inputs.working-directory == 'libs/langchain' }}
-        with:
-          artifacts: "dist/*"
-          token: ${{ secrets.GITHUB_TOKEN }}
-          draft: false
-          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

.github/workflows/_test.yml

@@ -1,61 +0,0 @@
-name: test
-
-on:
-  workflow_call:
-    inputs:
-      working-directory:
-        required: true
-        type: string
-        description: "From which folder this pipeline executes"
-      test_type:
-        type: string
-        description: "Test types to run"
-        default: '["core", "extended"]'
-
-env:
-  POETRY_VERSION: "1.4.2"
-
-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"
-        test_type: ${{ fromJSON(inputs.test_type) }}
-    name: Python ${{ matrix.python-version }} ${{ matrix.test_type }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: "./.github/actions/poetry_setup"
-        with:
-          python-version: ${{ matrix.python-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
-              else
-                echo "Running extended tests, installing dependencies with poetry..."
-                poetry install -E extended_testing
-              fi
-      - name: Install langchain editable
-        if: ${{ inputs.working-directory != 'langchain' }}
-        run: |
-          pip install -e ../langchain
-      - name: Run ${{matrix.test_type}} tests
-        run: |
-          if [ "${{ matrix.test_type }}" == "core" ]; then
-            make test
-          else
-            make extended_tests
-          fi
-        shell: bash

.github/workflows/codespell.yml

@@ -1,24 +0,0 @@
----
-name: Codespell
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-
-permissions:
-  contents: read
-
-jobs:
-  codespell:
-    name: Check for spelling errors
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Codespell
-        uses: codespell-project/actions-codespell@v2
-        with:
-          skip: guide_imports.json

.github/workflows/langchain_ci.yml

@@ -1,27 +0,0 @@
----
-name: libs/langchain CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    paths:
-      - '.github/workflows/_lint.yml'
-      - '.github/workflows/_test.yml'
-      - '.github/workflows/langchain_ci.yml'
-      - 'libs/langchain/**'
-  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
-
-jobs:
-  lint:
-    uses:
-      ./.github/workflows/_lint.yml
-    with:
-      working-directory: libs/langchain
-    secrets: inherit
-  test:
-    uses:
-      ./.github/workflows/_test.yml
-    with:
-      working-directory: libs/langchain
-    secrets: inherit

.github/workflows/langchain_experimental_ci.yml

@@ -1,29 +0,0 @@
----
-name: libs/langchain-experimental CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    paths:
-      - '.github/workflows/_lint.yml'
-      - '.github/workflows/_test.yml'
-      - '.github/workflows/langchain_experimental_ci.yml'
-      - 'libs/langchain/**'
-      - 'libs/experimental/**'
-  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
-
-jobs:
-  lint:
-    uses:
-      ./.github/workflows/_lint.yml
-    with:
-      working-directory: libs/experimental
-    secrets: inherit
-  test:
-    uses:
-      ./.github/workflows/_test.yml
-    with:
-      working-directory: libs/experimental
-      test_type: '["core"]'
-    secrets: inherit

.github/workflows/langchain_experimental_release.yml

@@ -1,20 +0,0 @@
----
-name: libs/langchain-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:
-  release:
-    uses:
-      ./.github/workflows/_release.yml
-    with:
-      working-directory: libs/experimental
-    secrets: inherit

.github/workflows/langchain_release.yml

@@ -1,20 +0,0 @@
----
-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:
-  release:
-    uses:
-      ./.github/workflows/_release.yml
-    with:
-      working-directory: libs/langchain
-    secrets: inherit

.github/workflows/linkcheck.yml

@@ -0,0 +1,38 @@
+name: linkcheck
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    paths:
+      - 'docs/**'
+
+env:
+  POETRY_VERSION: "1.4.2"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install poetry
+        run: |
+          pipx install poetry==$POETRY_VERSION
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: poetry
+      - name: Install dependencies
+        run: |
+          poetry install --with docs
+      - name: Build the docs
+        run: |
+          make docs_build
+      - name: Analyzing the docs with linkcheck
+        run: |
+          make docs_linkcheck

.github/workflows/lint.yml

@@ -0,0 +1,36 @@
+name: lint
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+env:
+  POETRY_VERSION: "1.4.2"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install poetry
+        run: |
+          pipx install poetry==$POETRY_VERSION
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: poetry
+      - name: Install dependencies
+        run: |
+          poetry install
+      - name: Analysing the code with our lint
+        run: |
+          make lint

.github/workflows/release.yml

@@ -0,0 +1,49 @@
+name: release
+
+on:
+  pull_request:
+    types:
+      - closed
+    branches:
+      - master
+    paths:
+      - 'pyproject.toml'
+
+env:
+  POETRY_VERSION: "1.4.2"
+
+jobs:
+  if_release:
+    if: |
+        ${{ github.event.pull_request.merged == true }}
+        && ${{ contains(github.event.pull_request.labels.*.name, 'release') }}
+    runs-on: ubuntu-latest
+    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
+        with:
+          python-version: "3.10"
+          cache: "poetry"
+      - name: Build project for distribution
+        run: poetry build
+      - name: Check Version
+        id: check-version
+        run: |
+          echo version=$(poetry version --short) >> $GITHUB_OUTPUT
+      - name: Create Release
+        uses: ncipollo/release-action@v1
+        with:
+          artifacts: "dist/*"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          draft: false
+          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

.github/workflows/test.yml

@@ -0,0 +1,49 @@
+name: test
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+  workflow_dispatch:
+
+env:
+  POETRY_VERSION: "1.4.2"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+        test_type:
+          - "core"
+          - "extended"
+    name: Python ${{ matrix.python-version }} ${{ matrix.test_type }}
+    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"
+          cache-key: ${{ matrix.test_type }}
+          install-command: |
+              if [ "${{ matrix.test_type }}" == "core" ]; then
+                echo "Running core tests, installing dependencies with poetry..."
+                poetry install
+              else
+                echo "Running extended tests, installing dependencies with poetry..."
+                poetry install -E extended_testing
+              fi
+      - name: Run ${{matrix.test_type}} tests
+        run: |
+          if [ "${{ matrix.test_type }}" == "core" ]; then
+            make test
+          else
+            make extended_tests
+          fi
+        shell: bash

.gitignore

@@ -73,7 +73,6 @@ instance/
 
 # Sphinx documentation
 docs/_build/
-docs/docs/_build/
 
 # PyBuilder
 target/
@@ -153,21 +152,4 @@ data_map*
 \[('_type', 'fake'), ('stop', None)]
 
 # Replit files
-*replit*
-
-node_modules
-docs/.yarn/
-docs/node_modules/
-docs/.docusaurus/
-docs/.cache-loader/
-docs/_dist
-docs/api_reference/api_reference.rst
-docs/api_reference/experimental_api_reference.rst
-docs/api_reference/_build
-docs/api_reference/*/
-!docs/api_reference/_static/
-!docs/api_reference/templates/
-!docs/api_reference/themes/
-docs/docs_skeleton/build
-docs/docs_skeleton/node_modules
-docs/docs_skeleton/yarn.lock
+*replit*

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "docs/_docs_skeleton"]
-	path = docs/_docs_skeleton
-	url = https://github.com/langchain-ai/langchain-shared-docs
-	branch = main

.readthedocs.yaml

@@ -9,13 +9,10 @@ build:
   os: ubuntu-22.04
   tools:
     python: "3.11"
-  jobs:
-    pre_build:
-      - python docs/api_reference/create_api_rst.py
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
-   configuration: docs/api_reference/conf.py
+   configuration: docs/conf.py
 
 # If using Sphinx, optionally build your docs in additional formats such as PDF
 # formats:
@@ -24,6 +21,6 @@ sphinx:
 # Optionally declare the Python requirements required to build your docs
 python:
    install:
-   - requirements: docs/api_reference/requirements.txt
+   - requirements: docs/requirements.txt
    - method: pip
-     path: .
+     path: .

MIGRATE.md

@@ -1,61 +0,0 @@
-# Migrating to `langchain_experimental`
-
-We are moving any experimental components of LangChain, or components with vulnerability issues, into `langchain_experimental`.
-This guide covers how to migrate.
-
-## Installation
-
-Previously:
-
-`pip install -U langchain`
-
-Now (only if you want to access things in experimental):
-
-`pip install -U langchain langchain_experimental`
-
-## Things in `langchain.experimental`
-
-Previously:
-
-`from langchain.experimental import ...`
-
-Now:
-
-`from langchain_experimental import ...`
-
-## PALChain
-
-Previously:
-
-`from langchain.chains import PALChain`
-
-Now:
-
-`from langchain_experimental.pal_chain import PALChain`
-
-## SQLDatabaseChain
-
-Previously:
-
-`from langchain.chains import SQLDatabaseChain`
-
-Now:
-
-`from langchain_experimental.sql import SQLDatabaseChain`
-
-Alternatively, if you are just interested in using the query generation part of the SQL chain, you can check out [`create_sql_query_chain`](https://github.com/langchain-ai/langchain/blob/master/docs/extras/use_cases/tabular/sql_query.ipynb)
-
-`from langchain.chains import create_sql_query_chain`
-
-## `load_prompt` for Python files
-
-Note: this only applies if you want to load Python files as prompts.
-If you want to load json/yaml files, no change is needed.
-
-Previously:
-
-`from langchain.prompts import load_prompt`
-
-Now:
-
-`from langchain_experimental.prompts import load_prompt`

Makefile

@@ -1,54 +1,70 @@
-.PHONY: all clean docs_build docs_clean docs_linkcheck api_docs_build api_docs_clean api_docs_linkcheck
+.PHONY: all clean format lint test tests test_watch integration_tests docker_tests help extended_tests
 
-# Default target executed when no arguments are given to make.
 all: help
 
+coverage:
+	poetry run pytest --cov \
+		--cov-config=.coveragerc \
+		--cov-report xml \
+		--cov-report term-missing:skip-covered
 
-######################
-# DOCUMENTATION
-######################
-
-clean: docs_clean api_docs_clean
-
+clean: docs_clean
 
 docs_build:
-	docs/.local_build.sh
+	cd docs && poetry run make html
 
 docs_clean:
-	rm -r docs/_dist
+	cd docs && poetry run make clean
 
 docs_linkcheck:
-	poetry run linkchecker docs/_dist/docs_skeleton/ --ignore-url node_modules
+	poetry run linkchecker docs/_build/html/index.html
 
-api_docs_build:
-	poetry run python docs/api_reference/create_api_rst.py
-	cd docs/api_reference && poetry run make html
+format:
+	poetry run black .
+	poetry run ruff --select I --fix .
 
-api_docs_clean:
-	rm -f docs/api_reference/api_reference.rst
-	cd docs/api_reference && poetry run make clean
+PYTHON_FILES=.
+lint: PYTHON_FILES=.
+lint_diff: PYTHON_FILES=$(shell git diff --name-only --diff-filter=d master | grep -E '\.py$$')
 
-api_docs_linkcheck:
-	poetry run linkchecker docs/api_reference/_build/html/index.html
+lint lint_diff:
+	poetry run mypy $(PYTHON_FILES)
+	poetry run black $(PYTHON_FILES) --check
+	poetry run ruff .
 
-spell_check:
-	poetry run codespell --toml pyproject.toml
+TEST_FILE ?= tests/unit_tests/
 
-spell_fix:
-	poetry run codespell --toml pyproject.toml -w
+test:
+	poetry run pytest --disable-socket --allow-unix-socket $(TEST_FILE)
 
-######################
-# HELP
-######################
+tests: 
+	poetry run pytest --disable-socket --allow-unix-socket $(TEST_FILE)
+
+extended_tests:
+	poetry run pytest --disable-socket --allow-unix-socket --only-extended tests/unit_tests
+
+test_watch:
+	poetry run ptw --now . -- tests/unit_tests
+
+integration_tests:
+	poetry run pytest tests/integration_tests
+
+docker_tests:
+	docker build -t my-langchain-image:test .
+	docker run --rm my-langchain-image:test
 
 help:
 	@echo '----'
-	@echo 'clean                        - run docs_clean and api_docs_clean'
+	@echo 'coverage                     - run unit tests and generate coverage report'
 	@echo 'docs_build                   - build the documentation'
 	@echo 'docs_clean                   - clean the documentation build artifacts'
 	@echo 'docs_linkcheck               - run linkchecker on the documentation'
-	@echo 'api_docs_build               - build the API Reference documentation'
-	@echo 'api_docs_clean               - clean the API Reference documentation build artifacts'
-	@echo 'api_docs_linkcheck           - run linkchecker on the API Reference documentation'
-	@echo 'spell_check               	- run codespell on the project'
-	@echo 'spell_fix               		- run codespell on the project and fix the errors'
+	@echo 'format                       - run code formatters'
+	@echo 'lint                         - run linters'
+	@echo 'test                         - run unit tests'
+	@echo 'tests                        - run unit tests'
+	@echo 'test TEST_FILE=<test_file>   - run all tests in file'
+	@echo 'extended_tests               - run only extended unit tests'
+	@echo 'test_watch                   - run unit tests in watch mode'
+	@echo 'integration_tests            - run integration tests'
+	@echo 'docker_tests                 - run unit tests in docker'

README.md

@@ -3,8 +3,9 @@
 ⚡ 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)
+[![lint](https://github.com/hwchase17/langchain/actions/workflows/lint.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/lint.yml)
+[![test](https://github.com/hwchase17/langchain/actions/workflows/test.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/test.yml)
+[![linkcheck](https://github.com/hwchase17/langchain/actions/workflows/linkcheck.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/linkcheck.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)
@@ -12,28 +13,20 @@
 [![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)
-[![Dependency Status](https://img.shields.io/librariesio/github/langchain-ai/langchain)](https://libraries.io/github/langchain-ai/langchain)
+[![Dependency Status](https://img.shields.io/librariesio/github/hwchase17/langchain)](https://libraries.io/github/hwchase17/langchain)
 [![Open Issues](https://img.shields.io/github/issues-raw/hwchase17/langchain)](https://github.com/hwchase17/langchain/issues)
 
 
 Looking for the JS/TS version? Check out [LangChain.js](https://github.com/hwchase17/langchainjs).
 
-**Production Support:** As you move your LangChains into production, we'd love to offer more hands-on support.
-Fill out [this form](https://airtable.com/appwQzlErAS2qiP0L/shrGtGaVBVAz7NcV2) to share more about what you're building, and our team will get in touch.
-
-## 🚨Breaking Changes for select chains (SQLDatabase) on 7/28
-
-In an effort to make `langchain` leaner and safer, we are moving select chains to `langchain_experimental`.
-This migration has already started, but we are remaining backwards compatible until 7/28.
-On that date, we will remove functionality from `langchain`.
-Read more about the motivation and the progress [here](https://github.com/hwchase17/langchain/discussions/8043).
-Read how to migrate your code [here](MIGRATE.md).
+**Production Support:** As you move your LangChains into production, we'd love to offer more comprehensive support.
+Please fill out [this form](https://forms.gle/57d8AmXBYp8PP8tZA) and we'll set up a dedicated support Slack channel.
 
 ## Quick Install
 
 `pip install langchain`
 or
-`pip install langsmith && conda install langchain -c conda-forge`
+`conda install langchain -c conda-forge`
 
 ## 🤔 What is this?
 
@@ -43,22 +36,22 @@ This library aims to assist in the development of those types of applications. C
 
 **❓ Question Answering over specific documents**
 
-- [Documentation](https://python.langchain.com/docs/use_cases/question_answering/)
+- [Documentation](https://langchain.readthedocs.io/en/latest/use_cases/question_answering.html)
 - End-to-end Example: [Question Answering over Notion Database](https://github.com/hwchase17/notion-qa)
 
 **💬 Chatbots**
 
-- [Documentation](https://python.langchain.com/docs/use_cases/chatbots/)
+- [Documentation](https://langchain.readthedocs.io/en/latest/use_cases/chatbots.html)
 - End-to-end Example: [Chat-LangChain](https://github.com/hwchase17/chat-langchain)
 
 **🤖 Agents**
 
-- [Documentation](https://python.langchain.com/docs/modules/agents/)
+- [Documentation](https://langchain.readthedocs.io/en/latest/modules/agents.html)
 - End-to-end Example: [GPT+WolframAlpha](https://huggingface.co/spaces/JavaFXpert/Chat-GPT-LangChain)
 
 ## 📖 Documentation
 
-Please see [here](https://python.langchain.com) for full documentation on:
+Please see [here](https://langchain.readthedocs.io/en/latest/?) for full documentation on:
 
 - Getting started (installation, setting up the environment, simple examples)
 - How-To examples (demos, integrations, helper functions)
@@ -94,7 +87,7 @@ Memory refers to persisting state between calls of a chain/agent. LangChain prov
 
 [BETA] Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.
 
-For more information on these concepts, please see our [full documentation](https://python.langchain.com).
+For more information on these concepts, please see our [full documentation](https://langchain.readthedocs.io/en/latest/).
 
 ## 💁 Contributing
 

docs/.local_build.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-
-set -o errexit
-set -o nounset
-set -o pipefail
-set -o xtrace
-
-SCRIPT_DIR="$(cd "$(dirname "$0")"; pwd)"
-cd "${SCRIPT_DIR}"
-
-mkdir -p _dist/docs_skeleton
-cp -r {docs_skeleton,snippets} _dist
-cp -r extras/* _dist/docs_skeleton/docs
-cd _dist/docs_skeleton
-poetry run nbdoc_build
-poetry run python generate_api_reference_links.py
-yarn install
-yarn start

docs/additional_resources/deploy_llms.rst

@@ -0,0 +1,137 @@
+
+===========================
+Deploying LLMs in Production
+===========================
+
+In today's fast-paced technological landscape, the use of Large Language Models (LLMs) is rapidly expanding. As a result, it's crucial for developers to understand how to effectively deploy these models in production environments. LLM interfaces typically fall into two categories:
+
+- **Case 1: Utilizing External LLM Providers (OpenAI, Anthropic, etc.)**
+    In this scenario, most of the computational burden is handled by the LLM providers, while LangChain simplifies the implementation of business logic around these services. This approach includes features such as prompt templating, chat message generation, caching, vector embedding database creation, preprocessing, etc.
+
+- **Case 2: Self-hosted Open-Source Models**
+    Alternatively, developers can opt to use smaller, yet comparably capable, self-hosted open-source LLM models. This approach can significantly decrease costs, latency, and privacy concerns associated with transferring data to external LLM providers.
+
+Regardless of the framework that forms the backbone of your product, deploying LLM applications comes with its own set of challenges. It's vital to understand the trade-offs and key considerations when evaluating serving frameworks.
+
+Outline
+=======
+
+This guide aims to provide a comprehensive overview of the requirements for deploying LLMs in a production setting, focusing on:
+
+- `Designing a Robust LLM Application Service <#robust>`_
+- `Maintaining Cost-Efficiency <#cost>`_
+- `Ensuring Rapid Iteration <#iteration>`_
+
+Understanding these components is crucial when assessing serving systems. LangChain integrates with several open-source projects designed to tackle these issues, providing a robust framework for productionizing your LLM applications. Some notable frameworks include:
+
+- `Ray Serve <../../../ecosystem/ray_serve.html>`_
+- `BentoML <https://github.com/ssheng/BentoChain>`_
+- `Modal <../../../ecosystem/modal.html>`_
+
+These links will provide further information on each ecosystem, assisting you in finding the best fit for your LLM deployment needs.
+
+Designing a Robust LLM Application Service
+===========================================
+.. _robust:
+
+When deploying an LLM service in production, it's imperative to provide a seamless user experience free from outages. Achieving 24/7 service availability involves creating and maintaining several sub-systems surrounding your application.
+
+Monitoring
+----------
+
+Monitoring forms an integral part of any system running in a production environment. In the context of LLMs, it is essential to monitor both performance and quality metrics.
+
+**Performance Metrics:** These metrics provide insights into the efficiency and capacity of your model. Here are some key examples:
+
+- Query per second (QPS): This measures the number of queries your model processes in a second, offering insights into its utilization.
+- Latency: This metric quantifies the delay from when your client sends a request to when they receive a response.
+- Tokens Per Second (TPS): This represents the number of tokens your model can generate in a second.
+
+**Quality Metrics:** These metrics are typically customized according to the business use-case. For instance, how does the output of your system compare to a baseline, such as a previous version? Although these metrics can be calculated offline, you need to log the necessary data to use them later.
+
+Fault tolerance
+---------------
+
+Your application may encounter errors such as exceptions in your model inference or business logic code, causing failures and disrupting traffic. Other potential issues could arise from the machine running your application, such as unexpected hardware breakdowns or loss of spot-instances during high-demand periods. One way to mitigate these risks is by increasing redundancy through replica scaling and implementing recovery mechanisms for failed replicas. However, model replicas aren't the only potential points of failure. It's essential to build resilience against various failures that could occur at any point in your stack.
+
+
+Zero down time upgrade
+----------------------
+
+System upgrades are often necessary but can result in service disruptions if not handled correctly. One way to prevent downtime during upgrades is by implementing a smooth transition process from the old version to the new one. Ideally, the new version of your LLM service is deployed, and traffic gradually shifts from the old to the new version, maintaining a constant QPS throughout the process.
+
+
+Load balancing
+--------------
+
+Load balancing, in simple terms, is a technique to distribute work evenly across multiple computers, servers, or other resources to optimize the utilization of the system, maximize throughput, minimize response time, and avoid overload of any single resource. Think of it as a traffic officer directing cars (requests) to different roads (servers) so that no single road becomes too congested.
+
+There are several strategies for load balancing. For example, one common method is the *Round Robin* strategy, where each request is sent to the next server in line, cycling back to the first when all servers have received a request. This works well when all servers are equally capable. However, if some servers are more powerful than others, you might use a *Weighted Round Robin* or *Least Connections* strategy, where more requests are sent to the more powerful servers, or to those currently handling the fewest active requests. Let's imagine you're running a LLM chain. If your application becomes popular, you could have hundreds or even thousands of users asking questions at the same time. If one server gets too busy (high load), the load balancer would direct new requests to another server that is less busy. This way, all your users get a timely response and the system remains stable.
+
+
+
+Maintaining Cost-Efficiency and Scalability
+============================================
+.. _cost:
+
+Deploying LLM services can be costly, especially when you're handling a large volume of user interactions. Charges by LLM providers are usually based on tokens used, making a chat system inference on these models potentially expensive. However, several strategies can help manage these costs without compromising the quality of the service.
+
+
+Self-hosting models
+-------------------
+
+Several smaller and open-source LLMs are emerging to tackle the issue of reliance on LLM providers. Self-hosting allows you to maintain similar quality to LLM provider models while managing costs. The challenge lies in building a reliable, high-performing LLM serving system on your own machines. 
+
+Resource Management and Auto-Scaling
+------------------------------------
+
+Computational logic within your application requires precise resource allocation. For instance, if part of your traffic is served by an OpenAI endpoint and another part by a self-hosted model, it's crucial to allocate suitable resources for each. Auto-scaling—adjusting resource allocation based on traffic—can significantly impact the cost of running your application. This strategy requires a balance between cost and responsiveness, ensuring neither resource over-provisioning nor compromised application responsiveness.
+
+Utilizing Spot Instances
+------------------------
+
+On platforms like AWS, spot instances offer substantial cost savings, typically priced at about a third of on-demand instances. The trade-off is a higher crash rate, necessitating a robust fault-tolerance mechanism for effective use.
+
+Independent Scaling
+-------------------
+
+When self-hosting your models, you should consider independent scaling. For example, if you have two translation models, one fine-tuned for French and another for Spanish, incoming requests might necessitate different scaling requirements for each.
+
+Batching requests
+-----------------
+
+In the context of Large Language Models, batching requests can enhance efficiency by better utilizing your GPU resources. GPUs are inherently parallel processors, designed to handle multiple tasks simultaneously. If you send individual requests to the model, the GPU might not be fully utilized as it's only working on a single task at a time. On the other hand, by batching requests together, you're allowing the GPU to work on multiple tasks at once, maximizing its utilization and improving inference speed. This not only leads to cost savings but can also improve the overall latency of your LLM service.
+
+
+In summary, managing costs while scaling your LLM services requires a strategic approach. Utilizing self-hosting models, managing resources effectively, employing auto-scaling, using spot instances, independently scaling models, and batching requests are key strategies to consider. Open-source libraries such as Ray Serve and BentoML are designed to deal with these complexities. 
+
+
+
+Ensuring Rapid Iteration
+========================
+
+.. _iteration:
+
+The LLM landscape is evolving at an unprecedented pace, with new libraries and model architectures being introduced constantly. Consequently, it's crucial to avoid tying yourself to a solution specific to one particular framework. This is especially relevant in serving, where changes to your infrastructure can be time-consuming, expensive, and risky. Strive for infrastructure that is not locked into any specific machine learning library or framework, but instead offers a general-purpose, scalable serving layer. Here are some aspects where flexibility plays a key role:
+
+Model composition
+-----------------
+
+Deploying systems like LangChain demands the ability to piece together different models and connect them via logic. Take the example of building a natural language input SQL query engine. Querying an LLM and obtaining the SQL command is only part of the system. You need to extract metadata from the connected database, construct a prompt for the LLM, run the SQL query on an engine, collect and feed back the response to the LLM as the query runs, and present the results to the user. This demonstrates the need to seamlessly integrate various complex components built in Python into a dynamic chain of logical blocks that can be served together.
+
+Cloud providers
+---------------
+
+Many hosted solutions are restricted to a single cloud provider, which can limit your options in today's multi-cloud world. Depending on where your other infrastructure components are built, you might prefer to stick with your chosen cloud provider.
+
+
+Infrastructure as Code (IaC)
+---------------------------
+
+Rapid iteration also involves the ability to recreate your infrastructure quickly and reliably. This is where Infrastructure as Code (IaC) tools like Terraform, CloudFormation, or Kubernetes YAML files come into play. They allow you to define your infrastructure in code files, which can be version controlled and quickly deployed, enabling faster and more reliable iterations.
+
+
+CI/CD
+-----
+
+In a fast-paced environment, implementing CI/CD pipelines can significantly speed up the iteration process. They help automate the testing and deployment of your LLM applications, reducing the risk of errors and enabling faster feedback and iteration.

docs/additional_resources/model_laboratory.ipynb

@@ -5,7 +5,7 @@
    "id": "920a3c1a",
    "metadata": {},
    "source": [
-    "# Model comparison\n",
+    "# Model Comparison\n",
     "\n",
     "Constructing your language model application will likely involved choosing between many different options of prompts, models, and even chains to use. When doing so, you will want to compare these different options on different inputs in an easy, flexible, and intuitive way. \n",
     "\n",
@@ -31,9 +31,9 @@
    "outputs": [],
    "source": [
     "llms = [\n",
-    "    OpenAI(temperature=0),\n",
-    "    Cohere(model=\"command-xlarge-20221108\", max_tokens=20, temperature=0),\n",
-    "    HuggingFaceHub(repo_id=\"google/flan-t5-xl\", model_kwargs={\"temperature\": 1}),\n",
+    "    OpenAI(temperature=0), \n",
+    "    Cohere(model=\"command-xlarge-20221108\", max_tokens=20, temperature=0), \n",
+    "    HuggingFaceHub(repo_id=\"google/flan-t5-xl\", model_kwargs={\"temperature\":1})\n",
     "]"
    ]
   },
@@ -90,9 +90,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "prompt = PromptTemplate(\n",
-    "    template=\"What is the capital of {state}?\", input_variables=[\"state\"]\n",
-    ")\n",
+    "prompt = PromptTemplate(template=\"What is the capital of {state}?\", input_variables=[\"state\"])\n",
     "model_lab_with_prompt = ModelLaboratory.from_llms(llms, prompt=prompt)"
    ]
   },
@@ -143,15 +141,11 @@
     "\n",
     "open_ai_llm = OpenAI(temperature=0)\n",
     "search = SerpAPIWrapper()\n",
-    "self_ask_with_search_openai = SelfAskWithSearchChain(\n",
-    "    llm=open_ai_llm, search_chain=search, verbose=True\n",
-    ")\n",
+    "self_ask_with_search_openai = SelfAskWithSearchChain(llm=open_ai_llm, search_chain=search, verbose=True)\n",
     "\n",
     "cohere_llm = Cohere(temperature=0, model=\"command-xlarge-20221108\")\n",
     "search = SerpAPIWrapper()\n",
-    "self_ask_with_search_cohere = SelfAskWithSearchChain(\n",
-    "    llm=cohere_llm, search_chain=search, verbose=True\n",
-    ")"
+    "self_ask_with_search_cohere = SelfAskWithSearchChain(llm=cohere_llm, search_chain=search, verbose=True)"
    ]
   },
   {
@@ -254,7 +248,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

docs/additional_resources/tracing.md

@@ -0,0 +1,57 @@
+# Tracing
+
+By enabling tracing in your LangChain runs, you’ll be able to more effectively visualize, step through, and debug your chains and agents.
+
+First, you should install tracing and set up your environment properly.
+You can use either a locally hosted version of this (uses Docker) or a cloud hosted version (in closed alpha).
+If you're interested in using the hosted platform, please fill out the form [here](https://forms.gle/tRCEMSeopZf6TE3b6).
+
+- [Locally Hosted Setup](../tracing/local_installation.md)
+- [Cloud Hosted Setup](../tracing/hosted_installation.md)
+
+## Tracing Walkthrough
+
+When you first access the UI, you should see a page with your tracing sessions.
+An initial one "default" should already be created for you.
+A session is just a way to group traces together.
+If you click on a session, it will take you to a page with no recorded traces that says "No Runs."
+You can create a new session with the new session form.
+
+![](../tracing/homepage.png)
+
+If we click on the `default` session, we can see that to start we have no traces stored.
+
+![](../tracing/default_empty.png)
+
+If we now start running chains and agents with tracing enabled, we will see data show up here.
+To do so, we can run [this notebook](../tracing/agent_with_tracing.ipynb) as an example.
+After running it, we will see an initial trace show up.
+
+![](../tracing/first_trace.png)
+
+From here we can explore the trace at a high level by clicking on the arrow to show nested runs.
+We can keep on clicking further and further down to explore deeper and deeper.
+
+![](../tracing/explore.png)
+
+We can also click on the "Explore" button of the top level run to dive even deeper.
+Here, we can see the inputs and outputs in full, as well as all the nested traces.
+
+![](../tracing/explore_trace.png)
+
+We can keep on exploring each of these nested traces in more detail.
+For example, here is the lowest level trace with the exact inputs/outputs to the LLM.
+
+![](../tracing/explore_llm.png)
+
+## Changing Sessions
+
+1. To initially record traces to a session other than `"default"`, you can set the `LANGCHAIN_SESSION` environment variable to the name of the session you want to record to:
+
+```python
+import os
+os.environ["LANGCHAIN_TRACING"] = "true"
+os.environ["LANGCHAIN_SESSION"] = "my_session" # Make sure this session actually exists. You can create a new session in the UI.
+```
+
+2. To switch sessions mid-script or mid-notebook, do NOT set the `LANGCHAIN_SESSION` environment variable. Instead: `langchain.set_tracing_callback_manager(session_name="my_session")`

docs/additional_resources/youtube.md

@@ -0,0 +1,90 @@
+# YouTube
+
+This is a collection of `LangChain` videos on `YouTube`.
+
+### ⛓️[Official LangChain YouTube channel](https://www.youtube.com/@LangChain)⛓️
+
+### Introduction to LangChain with Harrison Chase, creator of LangChain
+- [Building the Future with LLMs, `LangChain`, & `Pinecone`](https://youtu.be/nMniwlGyX-c) by [Pinecone](https://www.youtube.com/@pinecone-io)
+- [LangChain and Weaviate with Harrison Chase and Bob van Luijt - Weaviate Podcast #36](https://youtu.be/lhby7Ql7hbk) by [Weaviate • Vector Database](https://www.youtube.com/@Weaviate)
+- [LangChain Demo + Q&A with Harrison Chase](https://youtu.be/zaYTXQFR0_s?t=788) by [Full Stack Deep Learning](https://www.youtube.com/@FullStackDeepLearning)
+- [LangChain Agents: Build Personal Assistants For Your Data (Q&A with Harrison Chase and Mayo Oshin)](https://youtu.be/gVkF8cwfBLI) by [Chat with data](https://www.youtube.com/@chatwithdata)
+- ⛓️ [LangChain "Agents in Production" Webinar](https://youtu.be/k8GNCCs16F4) by [LangChain](https://www.youtube.com/@LangChain)
+
+## Videos (sorted by views)
+
+- [Building AI LLM Apps with LangChain (and more?) - LIVE STREAM](https://www.youtube.com/live/M-2Cj_2fzWI?feature=share) by [Nicholas Renotte](https://www.youtube.com/@NicholasRenotte)
+- [First look - `ChatGPT` + `WolframAlpha` (`GPT-3.5` and Wolfram|Alpha via LangChain by James Weaver)](https://youtu.be/wYGbY811oMo) by [Dr Alan D. Thompson](https://www.youtube.com/@DrAlanDThompson) 
+- [LangChain explained - The hottest new Python framework](https://youtu.be/RoR4XJw8wIc) by [AssemblyAI](https://www.youtube.com/@AssemblyAI)
+- [Chatbot with INFINITE MEMORY using `OpenAI` & `Pinecone` - `GPT-3`, `Embeddings`, `ADA`, `Vector DB`, `Semantic`](https://youtu.be/2xNzB7xq8nk) by [David Shapiro ~ AI](https://www.youtube.com/@DavidShapiroAutomator)
+- [LangChain for LLMs is... basically just an Ansible playbook](https://youtu.be/X51N9C-OhlE) by [David Shapiro ~ AI](https://www.youtube.com/@DavidShapiroAutomator)
+- [Build your own LLM Apps with LangChain & `GPT-Index`](https://youtu.be/-75p09zFUJY) by [1littlecoder](https://www.youtube.com/@1littlecoder)
+- [`BabyAGI` - New System of Autonomous AI Agents with LangChain](https://youtu.be/lg3kJvf1kXo) by [1littlecoder](https://www.youtube.com/@1littlecoder)
+- [Run `BabyAGI` with Langchain Agents (with Python Code)](https://youtu.be/WosPGHPObx8) by [1littlecoder](https://www.youtube.com/@1littlecoder)
+- [How to Use Langchain With `Zapier` | Write and Send Email with GPT-3 | OpenAI API Tutorial](https://youtu.be/p9v2-xEa9A0) by [StarMorph AI](https://www.youtube.com/@starmorph)
+- [Use Your Locally Stored Files To Get Response From GPT - `OpenAI` | Langchain | Python](https://youtu.be/NC1Ni9KS-rk) by [Shweta Lodha](https://www.youtube.com/@shweta-lodha)
+- [`Langchain JS` | How to Use GPT-3, GPT-4 to Reference your own Data | `OpenAI Embeddings` Intro](https://youtu.be/veV2I-NEjaM) by [StarMorph AI](https://www.youtube.com/@starmorph)
+- [The easiest way to work with large language models | Learn LangChain in 10min](https://youtu.be/kmbS6FDQh7c) by [Sophia Yang](https://www.youtube.com/@SophiaYangDS)
+- [4 Autonomous AI Agents: “Westworld” simulation `BabyAGI`, `AutoGPT`, `Camel`, `LangChain`](https://youtu.be/yWbnH6inT_U) by [Sophia Yang](https://www.youtube.com/@SophiaYangDS)
+- [AI CAN SEARCH THE INTERNET? Langchain Agents + OpenAI ChatGPT](https://youtu.be/J-GL0htqda8) by [tylerwhatsgood](https://www.youtube.com/@tylerwhatsgood)
+- [Query Your Data with GPT-4 | Embeddings, Vector Databases | Langchain JS Knowledgebase](https://youtu.be/jRnUPUTkZmU) by [StarMorph AI](https://www.youtube.com/@starmorph)
+- [`Weaviate` + LangChain for LLM apps presented by Erika Cardenas](https://youtu.be/7AGj4Td5Lgw) by [`Weaviate` • Vector Database](https://www.youtube.com/@Weaviate)
+- [Langchain Overview — How to Use Langchain & `ChatGPT`](https://youtu.be/oYVYIq0lOtI) by [Python In Office](https://www.youtube.com/@pythoninoffice6568)
+- [Langchain Overview - How to Use Langchain & `ChatGPT`](https://youtu.be/oYVYIq0lOtI) by [Python In Office](https://www.youtube.com/@pythoninoffice6568)
+- [Custom langchain Agent & Tools with memory. Turn any `Python function` into langchain tool with Gpt 3](https://youtu.be/NIG8lXk0ULg) by [echohive](https://www.youtube.com/@echohive)
+- [LangChain: Run Language Models Locally - `Hugging Face Models`](https://youtu.be/Xxxuw4_iCzw) by [Prompt Engineering](https://www.youtube.com/@engineerprompt)
+- [`ChatGPT` with any `YouTube` video using langchain and `chromadb`](https://youtu.be/TQZfB2bzVwU) by [echohive](https://www.youtube.com/@echohive)
+- [How to Talk to a `PDF` using LangChain and `ChatGPT`](https://youtu.be/v2i1YDtrIwk) by [Automata Learning Lab](https://www.youtube.com/@automatalearninglab)
+- [Langchain Document Loaders Part 1: Unstructured Files](https://youtu.be/O5C0wfsen98) by [Merk](https://www.youtube.com/@merksworld) 
+- [LangChain - Prompt Templates (what all the best prompt engineers use)](https://youtu.be/1aRu8b0XNOQ) by [Nick Daigler](https://www.youtube.com/@nick_daigs)
+- [LangChain. Crear aplicaciones Python impulsadas por GPT](https://youtu.be/DkW_rDndts8) by [Jesús Conde](https://www.youtube.com/@0utKast)
+- [Easiest Way to Use GPT In Your Products | LangChain Basics Tutorial](https://youtu.be/fLy0VenZyGc) by [Rachel Woods](https://www.youtube.com/@therachelwoods)
+- [`BabyAGI` + `GPT-4` Langchain Agent with Internet Access](https://youtu.be/wx1z_hs5P6E) by [tylerwhatsgood](https://www.youtube.com/@tylerwhatsgood)
+- [Learning LLM Agents. How does it actually work? LangChain, AutoGPT & OpenAI](https://youtu.be/mb_YAABSplk) by [Arnoldas Kemeklis](https://www.youtube.com/@processusAI)
+- [Get Started with LangChain in `Node.js`](https://youtu.be/Wxx1KUWJFv4) by [Developers Digest](https://www.youtube.com/@DevelopersDigest)
+- [LangChain + `OpenAI` tutorial: Building a Q&A system w/ own text data](https://youtu.be/DYOU_Z0hAwo) by [Samuel Chan](https://www.youtube.com/@SamuelChan)
+- [Langchain + `Zapier` Agent](https://youtu.be/yribLAb-pxA) by [Merk](https://www.youtube.com/@merksworld)
+- [Connecting the Internet with `ChatGPT` (LLMs) using Langchain And Answers Your Questions](https://youtu.be/9Y0TBC63yZg) by [Kamalraj M M](https://www.youtube.com/@insightbuilder)
+- [Build More Powerful LLM Applications for Business’s with LangChain (Beginners Guide)](https://youtu.be/sp3-WLKEcBg) by[ No Code Blackbox](https://www.youtube.com/@nocodeblackbox)
+- ⛓️ [LangFlow LLM Agent Demo for 🦜🔗LangChain](https://youtu.be/zJxDHaWt-6o) by [Cobus Greyling](https://www.youtube.com/@CobusGreylingZA)
+- ⛓️ [Chatbot Factory: Streamline Python Chatbot Creation with LLMs and Langchain](https://youtu.be/eYer3uzrcuM) by [Finxter](https://www.youtube.com/@CobusGreylingZA)
+- ⛓️ [LangChain Tutorial - ChatGPT mit eigenen Daten](https://youtu.be/0XDLyY90E2c) by [Coding Crashkurse](https://www.youtube.com/@codingcrashkurse6429)
+- ⛓️ [Chat with a `CSV` | LangChain Agents Tutorial (Beginners)](https://youtu.be/tjeti5vXWOU) by [GoDataProf](https://www.youtube.com/@godataprof)
+- ⛓️ [Introdução ao Langchain - #Cortes - Live DataHackers](https://youtu.be/fw8y5VRei5Y) by [Prof. João Gabriel Lima](https://www.youtube.com/@profjoaogabriellima)
+- ⛓️ [LangChain: Level up `ChatGPT` !? | LangChain Tutorial Part 1](https://youtu.be/vxUGx8aZpDE) by [Code Affinity](https://www.youtube.com/@codeaffinitydev)
+- ⛓️ [KI schreibt krasses Youtube Skript 😲😳 | LangChain Tutorial Deutsch](https://youtu.be/QpTiXyK1jus) by [SimpleKI](https://www.youtube.com/@simpleki)
+- ⛓️ [Chat with Audio: Langchain, `Chroma DB`, OpenAI, and `Assembly AI`](https://youtu.be/Kjy7cx1r75g) by [AI Anytime](https://www.youtube.com/@AIAnytime)
+- ⛓️ [QA over documents with Auto vector index selection with Langchain router chains](https://youtu.be/9G05qybShv8) by [echohive](https://www.youtube.com/@echohive)
+- ⛓️ [Build your own custom LLM application with `Bubble.io` & Langchain (No Code & Beginner friendly)](https://youtu.be/O7NhQGu1m6c) by [No Code Blackbox](https://www.youtube.com/@nocodeblackbox)
+- ⛓️ [Simple App to Question Your Docs: Leveraging `Streamlit`, `Hugging Face Spaces`, LangChain, and `Claude`!](https://youtu.be/X4YbNECRr7o) by [Chris Alexiuk](https://www.youtube.com/@chrisalexiuk)
+- ⛓️ [LANGCHAIN AI- `ConstitutionalChainAI` + Databutton AI ASSISTANT Web App](https://youtu.be/5zIU6_rdJCU) by [Avra](https://www.youtube.com/@Avra_b)
+- ⛓️ [LANGCHAIN AI AUTONOMOUS AGENT WEB APP - 👶 `BABY AGI` 🤖 with EMAIL AUTOMATION using `DATABUTTON`](https://youtu.be/cvAwOGfeHgw) by [Avra](https://www.youtube.com/@Avra_b)
+- ⛓️ [The Future of Data Analysis: Using A.I. Models in Data Analysis (LangChain)](https://youtu.be/v_LIcVyg5dk) by [Absent Data](https://www.youtube.com/@absentdata)
+- ⛓️ [Memory in LangChain | Deep dive (python)](https://youtu.be/70lqvTFh_Yg) by [Eden Marco](https://www.youtube.com/@EdenMarco)
+- ⛓️ [9 LangChain UseCases | Beginner's Guide | 2023](https://youtu.be/zS8_qosHNMw) by [Data Science Basics](https://www.youtube.com/@datasciencebasics)
+- ⛓️ [Use Large Language Models in Jupyter Notebook | LangChain | Agents & Indexes](https://youtu.be/JSe11L1a_QQ) by [Abhinaw Tiwari](https://www.youtube.com/@AbhinawTiwariAT)
+- ⛓️ [How to Talk to Your Langchain Agent | `11 Labs` + `Whisper`](https://youtu.be/N4k459Zw2PU) by [VRSEN](https://www.youtube.com/@vrsen)
+- ⛓️ [LangChain Deep Dive: 5 FUN AI App Ideas To Build Quickly and Easily](https://youtu.be/mPYEPzLkeks) by [James NoCode](https://www.youtube.com/@jamesnocode)
+- ⛓️ [BEST OPEN Alternative to OPENAI's EMBEDDINGs for Retrieval QA: LangChain](https://youtu.be/ogEalPMUCSY) by [Prompt Engineering](https://www.youtube.com/@engineerprompt)
+- ⛓️ [LangChain 101: Models](https://youtu.be/T6c_XsyaNSQ) by [Mckay Wrigley](https://www.youtube.com/@realmckaywrigley)
+- ⛓️ [LangChain with JavaScript Tutorial #1 | Setup & Using LLMs](https://youtu.be/W3AoeMrg27o) by [Leon van Zyl](https://www.youtube.com/@leonvanzyl)
+- ⛓️ [LangChain Overview & Tutorial for Beginners: Build Powerful AI Apps Quickly & Easily (ZERO CODE)](https://youtu.be/iI84yym473Q) by [James NoCode](https://www.youtube.com/@jamesnocode)
+- ⛓️ [LangChain In Action: Real-World Use Case With Step-by-Step Tutorial](https://youtu.be/UO699Szp82M) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
+- ⛓️ [Summarizing and Querying Multiple Papers with LangChain](https://youtu.be/p_MQRWH5Y6k) by [Automata Learning Lab](https://www.youtube.com/@automatalearninglab)
+- ⛓️ [Using Langchain (and `Replit`) through `Tana`, ask `Google`/`Wikipedia`/`Wolfram Alpha` to fill out a table](https://youtu.be/Webau9lEzoI) by [Stian Håklev](https://www.youtube.com/@StianHaklev)
+- ⛓️ [Langchain PDF App (GUI) | Create a ChatGPT For Your `PDF` in Python](https://youtu.be/wUAUdEw5oxM) by [Alejandro AO - Software & Ai](https://www.youtube.com/@alejandro_ao)
+- ⛓️ [Auto-GPT with LangChain 🔥 | Create Your Own Personal AI Assistant](https://youtu.be/imDfPmMKEjM) by [Data Science Basics](https://www.youtube.com/@datasciencebasics)
+- ⛓️ [Create Your OWN Slack AI Assistant with Python & LangChain](https://youtu.be/3jFXRNn2Bu8) by [Dave Ebbelaar](https://www.youtube.com/@daveebbelaar)
+- ⛓️ [How to Create LOCAL Chatbots with GPT4All and LangChain [Full Guide]](https://youtu.be/4p1Fojur8Zw) by [Liam Ottley](https://www.youtube.com/@LiamOttley)
+- ⛓️ [Build a `Multilingual PDF` Search App with LangChain, `Cohere` and `Bubble`](https://youtu.be/hOrtuumOrv8) by [Menlo Park Lab](https://www.youtube.com/@menloparklab)
+- ⛓️ [Building a LangChain Agent (code-free!) Using `Bubble` and `Flowise`](https://youtu.be/jDJIIVWTZDE) by [Menlo Park Lab](https://www.youtube.com/@menloparklab)
+- ⛓️ [Build a LangChain-based Semantic PDF Search App with No-Code Tools Bubble and Flowise](https://youtu.be/s33v5cIeqA4) by [Menlo Park Lab](https://www.youtube.com/@menloparklab)
+- ⛓️ [LangChain Memory Tutorial | Building a ChatGPT Clone in Python](https://youtu.be/Cwq91cj2Pnc) by [Alejandro AO - Software & Ai](https://www.youtube.com/@alejandro_ao)
+- ⛓️ [ChatGPT For Your DATA | Chat with Multiple Documents Using LangChain](https://youtu.be/TeDgIDqQmzs) by [Data Science Basics](https://www.youtube.com/@datasciencebasics)
+- ⛓️ [`Llama Index`: Chat with Documentation using URL Loader](https://youtu.be/XJRoDEctAwA) by [Merk](https://www.youtube.com/@merksworld)
+- ⛓️ [Using OpenAI, LangChain, and `Gradio` to Build Custom GenAI Applications](https://youtu.be/1MsmqMg3yUc) by [David Hundley](https://www.youtube.com/@dkhundley)
+
+
+
+---------------------
+⛓ icon marks a new video [last update 2023-05-15]

docs/api_reference/conf.py

@@ -1,168 +0,0 @@
-"""Configuration file for the Sphinx documentation builder."""
-# Configuration file for the Sphinx documentation builder.
-#
-# This file only contains a selection of the most common options. For a full
-# list see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Path setup --------------------------------------------------------------
-
-import json
-import os
-import sys
-from pathlib import Path
-
-import toml
-from docutils import nodes
-from sphinx.util.docutils import SphinxDirective
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-
-_DIR = Path(__file__).parent.absolute()
-sys.path.insert(0, os.path.abspath("."))
-sys.path.insert(0, os.path.abspath("../../libs/langchain"))
-sys.path.insert(0, os.path.abspath("../../libs/experimental"))
-
-with (_DIR.parents[1] / "libs" / "langchain" / "pyproject.toml").open("r") as f:
-    data = toml.load(f)
-with (_DIR / "guide_imports.json").open("r") as f:
-    imported_classes = json.load(f)
-
-
-class ExampleLinksDirective(SphinxDirective):
-    """Directive to generate a list of links to examples.
-
-    We have a script that extracts links to API reference docs
-    from our notebook examples. This directive uses that information
-    to backlink to the examples from the API reference docs."""
-
-    has_content = False
-    required_arguments = 1
-
-    def run(self):
-        """Run the directive.
-
-        Called any time :example_links:`ClassName` is used
-        in the template *.rst files."""
-        class_or_func_name = self.arguments[0]
-        links = imported_classes.get(class_or_func_name, {})
-        list_node = nodes.bullet_list()
-        for doc_name, link in links.items():
-            item_node = nodes.list_item()
-            para_node = nodes.paragraph()
-            link_node = nodes.reference()
-            link_node["refuri"] = link
-            link_node.append(nodes.Text(doc_name))
-            para_node.append(link_node)
-            item_node.append(para_node)
-            list_node.append(item_node)
-        if list_node.children:
-            title_node = nodes.title()
-            title_node.append(nodes.Text(f"Examples using {class_or_func_name}"))
-            return [title_node, list_node]
-        return [list_node]
-
-
-def setup(app):
-    app.add_directive("example_links", ExampleLinksDirective)
-
-
-# -- Project information -----------------------------------------------------
-
-project = "🦜🔗 LangChain"
-copyright = "2023, Harrison Chase"
-author = "Harrison Chase"
-
-version = data["tool"]["poetry"]["version"]
-release = version
-
-html_title = project + " " + version
-html_last_updated_fmt = "%b %d, %Y"
-
-
-# -- General configuration ---------------------------------------------------
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.autodoc.typehints",
-    "sphinx.ext.autosummary",
-    "sphinx.ext.napoleon",
-    "sphinx.ext.viewcode",
-    "sphinxcontrib.autodoc_pydantic",
-    "sphinx_copybutton",
-    "sphinx_panels",
-    "IPython.sphinxext.ipython_console_highlighting",
-]
-source_suffix = [".rst"]
-
-# some autodoc pydantic options are repeated in the actual template.
-# potentially user error, but there may be bugs in the sphinx extension
-# with options not being passed through correctly (from either the location in the code)
-autodoc_pydantic_model_show_json = False
-autodoc_pydantic_field_list_validators = False
-autodoc_pydantic_config_members = False
-autodoc_pydantic_model_show_config_summary = False
-autodoc_pydantic_model_show_validator_members = False
-autodoc_pydantic_model_show_validator_summary = False
-autodoc_pydantic_model_signature_prefix = "class"
-autodoc_pydantic_field_signature_prefix = "param"
-autodoc_member_order = "groupwise"
-autoclass_content = "both"
-autodoc_typehints_format = "short"
-
-# autodoc_typehints = "description"
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ["templates"]
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
-
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = "scikit-learn-modern"
-html_theme_path = ["themes"]
-
-# redirects dictionary maps from old links to new links
-html_additional_pages = {}
-redirects = {
-    "index": "api_reference",
-}
-for old_link in redirects:
-    html_additional_pages[old_link] = "redirects.html"
-
-html_context = {
-    "display_github": True,  # Integrate GitHub
-    "github_user": "hwchase17",  # Username
-    "github_repo": "langchain",  # Repo name
-    "github_version": "master",  # Version
-    "conf_py_path": "/docs/api_reference",  # Path in the checkout to the docs root
-    "redirects": redirects,
-}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
-
-# These paths are either relative to html_static_path
-# or fully qualified paths (eg. https://...)
-html_css_files = [
-    "css/custom.css",
-]
-html_use_index = False
-
-myst_enable_extensions = ["colon_fence"]
-
-# generate autosummary even if no references
-autosummary_generate = True

docs/api_reference/create_api_rst.py

@@ -1,277 +0,0 @@
-"""Script for auto-generating api_reference.rst."""
-import importlib
-import inspect
-import typing
-from pathlib import Path
-from typing import TypedDict, Sequence, List, Dict, Literal, Union
-from enum import Enum
-
-from pydantic import BaseModel
-
-ROOT_DIR = Path(__file__).parents[2].absolute()
-HERE = Path(__file__).parent
-
-PKG_DIR = ROOT_DIR / "libs" / "langchain" / "langchain"
-EXP_DIR = ROOT_DIR / "libs" / "experimental" / "langchain_experimental"
-WRITE_FILE = HERE / "api_reference.rst"
-EXP_WRITE_FILE = HERE / "experimental_api_reference.rst"
-
-
-ClassKind = Literal["TypedDict", "Regular", "Pydantic", "enum"]
-
-
-class ClassInfo(TypedDict):
-    """Information about a class."""
-
-    name: str
-    """The name of the class."""
-    qualified_name: str
-    """The fully qualified name of the class."""
-    kind: ClassKind
-    """The kind of the class."""
-    is_public: bool
-    """Whether the class is public or not."""
-
-
-class FunctionInfo(TypedDict):
-    """Information about a function."""
-
-    name: str
-    """The name of the function."""
-    qualified_name: str
-    """The fully qualified name of the function."""
-    is_public: bool
-    """Whether the function is public or not."""
-
-
-class ModuleMembers(TypedDict):
-    """A dictionary of module members."""
-
-    classes_: Sequence[ClassInfo]
-    functions: Sequence[FunctionInfo]
-
-
-def _load_module_members(module_path: str, namespace: str) -> ModuleMembers:
-    """Load all members of a module.
-
-    Args:
-        module_path: Path to the module.
-        namespace: the namespace of the module.
-
-    Returns:
-        list: A list of loaded module objects.
-    """
-    classes_: List[ClassInfo] = []
-    functions: List[FunctionInfo] = []
-    module = importlib.import_module(module_path)
-    for name, type_ in inspect.getmembers(module):
-        if not hasattr(type_, "__module__"):
-            continue
-        if type_.__module__ != module_path:
-            continue
-
-        if inspect.isclass(type_):
-            if type(type_) == typing._TypedDictMeta:  # type: ignore
-                kind: ClassKind = "TypedDict"
-            elif issubclass(type_, Enum):
-                kind = "enum"
-            elif issubclass(type_, BaseModel):
-                kind = "Pydantic"
-            else:
-                kind = "Regular"
-
-            classes_.append(
-                ClassInfo(
-                    name=name,
-                    qualified_name=f"{namespace}.{name}",
-                    kind=kind,
-                    is_public=not name.startswith("_"),
-                )
-            )
-        elif inspect.isfunction(type_):
-            functions.append(
-                FunctionInfo(
-                    name=name,
-                    qualified_name=f"{namespace}.{name}",
-                    is_public=not name.startswith("_"),
-                )
-            )
-        else:
-            continue
-
-    return ModuleMembers(
-        classes_=classes_,
-        functions=functions,
-    )
-
-
-def _merge_module_members(
-    module_members: Sequence[ModuleMembers],
-) -> ModuleMembers:
-    """Merge module members."""
-    classes_: List[ClassInfo] = []
-    functions: List[FunctionInfo] = []
-    for module in module_members:
-        classes_.extend(module["classes_"])
-        functions.extend(module["functions"])
-
-    return ModuleMembers(
-        classes_=classes_,
-        functions=functions,
-    )
-
-
-def _load_package_modules(
-    package_directory: Union[str, Path]
-) -> Dict[str, ModuleMembers]:
-    """Recursively load modules of a package based on the file system.
-
-    Traversal based on the file system makes it easy to determine which
-    of the modules/packages are part of the package vs. 3rd party or built-in.
-
-    Parameters:
-        package_directory: Path to the package directory.
-
-    Returns:
-        list: A list of loaded module objects.
-    """
-    package_path = (
-        Path(package_directory)
-        if isinstance(package_directory, str)
-        else package_directory
-    )
-    modules_by_namespace = {}
-
-    package_name = package_path.name
-
-    for file_path in package_path.rglob("*.py"):
-        if not file_path.name.startswith("__"):
-            relative_module_name = file_path.relative_to(package_path)
-            # Get the full namespace of the module
-            namespace = str(relative_module_name).replace(".py", "").replace("/", ".")
-            # Keep only the top level namespace
-            top_namespace = namespace.split(".")[0]
-
-            try:
-                module_members = _load_module_members(
-                    f"{package_name}.{namespace}", namespace
-                )
-                # Merge module members if the namespace already exists
-                if top_namespace in modules_by_namespace:
-                    existing_module_members = modules_by_namespace[top_namespace]
-                    _module_members = _merge_module_members(
-                        [existing_module_members, module_members]
-                    )
-                else:
-                    _module_members = module_members
-
-                modules_by_namespace[top_namespace] = _module_members
-
-            except ImportError as e:
-                print(f"Error: Unable to import module '{namespace}' with error: {e}")
-
-    return modules_by_namespace
-
-
-def _construct_doc(pkg: str, members_by_namespace: Dict[str, ModuleMembers]) -> str:
-    """Construct the contents of the reference.rst file for the given package.
-
-    Args:
-        pkg: The package name
-        members_by_namespace: The members of the package, dict organized by top level
-                              module contains a list of classes and functions
-                              inside of the top level namespace.
-
-    Returns:
-        The contents of the reference.rst file.
-    """
-    full_doc = f"""\
-=======================
-``{pkg}`` API Reference
-=======================
-
-"""
-    namespaces = sorted(members_by_namespace)
-
-    for module in namespaces:
-        _members = members_by_namespace[module]
-        classes = _members["classes_"]
-        functions = _members["functions"]
-        if not (classes or functions):
-            continue
-        section = f":mod:`{pkg}.{module}`"
-        underline = "=" * (len(section) + 1)
-        full_doc += f"""\
-{section}
-{underline}
-
-.. automodule:: {pkg}.{module}
-    :no-members:
-    :no-inherited-members:
-
-"""
-
-        if classes:
-            full_doc += f"""\
-Classes
---------------
-.. currentmodule:: {pkg}
-
-.. autosummary::
-    :toctree: {module}
-"""
-
-            for class_ in classes:
-                if not class_['is_public']:
-                    continue
-                    
-                if class_["kind"] == "TypedDict":
-                    template = "typeddict.rst"
-                elif class_["kind"] == "enum":
-                    template = "enum.rst"
-                elif class_["kind"] == "Pydantic":
-                    template = "pydantic.rst"
-                else:
-                    template = "class.rst"
-
-                full_doc += f"""\
-    :template: {template}
-    
-    {class_["qualified_name"]}
-    
-"""
-
-        if functions:
-            _functions = [f["qualified_name"] for f in functions if f["is_public"]]
-            fstring = "\n    ".join(sorted(_functions))
-            full_doc += f"""\
-Functions
---------------
-.. currentmodule:: {pkg}
-
-.. autosummary::
-    :toctree: {module}
-    :template: function.rst
-
-    {fstring}
-
-"""
-    return full_doc
-
-
-def main() -> None:
-    """Generate the reference.rst file for each package."""
-    lc_members = _load_package_modules(PKG_DIR)
-    lc_doc = ".. _api_reference:\n\n" + _construct_doc("langchain", lc_members)
-    with open(WRITE_FILE, "w") as f:
-        f.write(lc_doc)
-    exp_members = _load_package_modules(EXP_DIR)
-    exp_doc = ".. _experimental_api_reference:\n\n" + _construct_doc(
-        "langchain_experimental", exp_members
-    )
-    with open(EXP_WRITE_FILE, "w") as f:
-        f.write(exp_doc)
-
-
-if __name__ == "__main__":
-    main()

docs/api_reference/index.rst

@@ -1,8 +0,0 @@
-=============
-LangChain API
-=============
-
-.. toctree::
-    :maxdepth: 2
-
-    api_reference.rst

docs/api_reference/templates/COPYRIGHT.txt

@@ -1,27 +0,0 @@
-Copyright (c) 2007-2023 The scikit-learn developers.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

docs/api_reference/templates/class.rst

@@ -1,36 +0,0 @@
-:mod:`{{module}}`.{{objname}}
-{{ underline }}==============
-
-.. currentmodule:: {{ module }}
-
-.. autoclass:: {{ objname }}
-
-   {% block attributes %}
-   {% if attributes %}
-   .. rubric:: {{ _('Attributes') }}
-
-   .. autosummary::
-   {% for item in attributes %}
-      ~{{ name }}.{{ item }}
-   {%- endfor %}
-   {% endif %}
-   {% endblock %}
-
-   {% block methods %}
-   {% if methods %}
-   .. rubric:: {{ _('Methods') }}
-
-   .. autosummary::
-   {% for item in methods %}
-      ~{{ name }}.{{ item }}
-   {%- endfor %}
-
-   {% for item in methods %}
-   .. automethod:: {{ name }}.{{ item }}
-   {%- endfor %}
-
-   {% endif %}
-   {% endblock %}
-
-
-.. example_links:: {{ objname }}

docs/api_reference/templates/enum.rst

@@ -1,14 +0,0 @@
-:mod:`{{module}}`.{{objname}}
-{{ underline }}==============
-
-.. currentmodule:: {{ module }}
-
-.. autoclass:: {{ objname }}
-
-    {% block attributes %}
-    {% for item in attributes %}
-    .. autoattribute:: {{ item }}
-    {% endfor %}
-    {% endblock %}
-
-.. example_links:: {{ objname }}

docs/api_reference/templates/function.rst

@@ -1,8 +0,0 @@
-:mod:`{{module}}`.{{objname}}
-{{ underline }}==============
-
-.. currentmodule:: {{ module }}
-
-.. autofunction:: {{ objname }}
-
-.. example_links:: {{ objname }}

docs/api_reference/templates/pydantic.rst

@@ -1,22 +0,0 @@
-:mod:`{{module}}`.{{objname}}
-{{ underline }}==============
-
-.. currentmodule:: {{ module }}
-
-.. autopydantic_model:: {{ objname }}
-    :model-show-json: False
-    :model-show-config-summary: False
-    :model-show-validator-members: False
-    :model-show-field-summary: False
-    :field-signature-prefix: param
-    :members:
-    :undoc-members:
-    :inherited-members:
-    :member-order: groupwise
-    :show-inheritance: True
-    :special-members: __call__
-
-    {% block attributes %}
-    {% endblock %}
-
-.. example_links:: {{ objname }}

docs/api_reference/templates/redirects.html

@@ -1,15 +0,0 @@
-{% set redirect = pathto(redirects[pagename]) %}
-<!DOCTYPE html>
-<html>
-  <head>
-    <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">
-    <link rel="canonical" href="{{ redirect }}" />
-    <title>scikit-learn: machine learning in Python</title>
-  </head>
-  <body>
-    <p>You will be automatically redirected to the <a href="{{ redirect }}">new location of this page</a>.</p>
-  </body>
-</html>

docs/api_reference/templates/typeddict.rst

@@ -1,14 +0,0 @@
-:mod:`{{module}}`.{{objname}}
-{{ underline }}==============
-
-.. currentmodule:: {{ module }}
-
-.. autoclass:: {{ objname }}
-
-    {% block attributes %}
-   {% for item in attributes %}
-  .. autoattribute:: {{ item }}
-   {% endfor %}
-   {% endblock %}
-
-.. example_links:: {{ objname }}

docs/api_reference/themes/COPYRIGHT.txt

@@ -1,27 +0,0 @@
-Copyright (c) 2007-2023 The scikit-learn developers.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

@@ -1,67 +0,0 @@
-<script>
-$(document).ready(function() {
-    /* Add a [>>>] button on the top-right corner of code samples to hide
-     * the >>> and ... prompts and the output and thus make the code
-     * copyable. */
-    var div = $('.highlight-python .highlight,' +
-                '.highlight-python3 .highlight,' +
-                '.highlight-pycon .highlight,' +
-		'.highlight-default .highlight')
-    var pre = div.find('pre');
-
-    // get the styles from the current theme
-    pre.parent().parent().css('position', 'relative');
-    var hide_text = 'Hide prompts and outputs';
-    var show_text = 'Show prompts and outputs';
-
-    // create and add the button to all the code blocks that contain >>>
-    div.each(function(index) {
-        var jthis = $(this);
-        if (jthis.find('.gp').length > 0) {
-            var button = $('<span class="copybutton">&gt;&gt;&gt;</span>');
-            button.attr('title', hide_text);
-            button.data('hidden', 'false');
-            jthis.prepend(button);
-        }
-        // tracebacks (.gt) contain bare text elements that need to be
-        // wrapped in a span to work with .nextUntil() (see later)
-        jthis.find('pre:has(.gt)').contents().filter(function() {
-            return ((this.nodeType == 3) && (this.data.trim().length > 0));
-        }).wrap('<span>');
-    });
-
-    // define the behavior of the button when it's clicked
-    $('.copybutton').click(function(e){
-        e.preventDefault();
-        var button = $(this);
-        if (button.data('hidden') === 'false') {
-            // hide the code output
-            button.parent().find('.go, .gp, .gt').hide();
-            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'hidden');
-            button.css('text-decoration', 'line-through');
-            button.attr('title', show_text);
-            button.data('hidden', 'true');
-        } else {
-            // show the code output
-            button.parent().find('.go, .gp, .gt').show();
-            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'visible');
-            button.css('text-decoration', 'none');
-            button.attr('title', hide_text);
-            button.data('hidden', 'false');
-        }
-    });
-
-	/*** Add permalink buttons next to glossary terms ***/
-	$('dl.glossary > dt[id]').append(function() {
-		return ('<a class="headerlink" href="#' +
-			    this.getAttribute('id') +
-			    '" title="Permalink to this term">¶</a>');
-	});
-});
-
-</script>
-{%- if pagename != 'index' and pagename != 'documentation' %}
-    {% if theme_mathjax_path %}
-<script id="MathJax-script" async src="{{ theme_mathjax_path }}"></script>
-    {% endif %}
-{%- endif %}

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

@@ -1,142 +0,0 @@
-{# TEMPLATE VAR SETTINGS #}
-{%- set url_root = pathto('', 1) %}
-{%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
-{%- if not embedded and docstitle %}
-  {%- set titlesuffix = " — "|safe + docstitle|e %}
-{%- else %}
-  {%- set titlesuffix = "" %}
-{%- endif %}
-{%- set lang_attr = 'en' %}
-
-<!DOCTYPE html>
-<!--[if IE 8]><html class="no-js lt-ie9" lang="{{ lang_attr }}" > <![endif]-->
-<!--[if gt IE 8]><!--> <html class="no-js" lang="{{ lang_attr }}" > <!--<![endif]-->
-<head>
-  <meta charset="utf-8">
-  {{ metatags }}
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-
-  {% block htmltitle %}
-  <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
-  {% endblock %}
-  <link rel="canonical" href="https://api.python.langchain.com/en/latest/{{pagename}}.html" />
-
-  {% if favicon_url %}
-  <link rel="shortcut icon" href="{{ favicon_url|e }}"/>
-  {% endif %}
-
-  <link rel="stylesheet" href="{{ pathto('_static/css/vendor/bootstrap.min.css', 1) }}" type="text/css" />
-  {%- for css in css_files %}
-    {%- if css|attr("rel") %}
-  <link rel="{{ css.rel }}" href="{{ pathto(css.filename, 1) }}" type="text/css"{% if css.title is not none %} title="{{ css.title }}"{% endif %} />
-    {%- else %}
-  <link rel="stylesheet" href="{{ pathto(css, 1) }}" type="text/css" />
-    {%- endif %}
-  {%- endfor %}
-  <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
-<script id="documentation_options" data-url_root="{{ pathto('', 1) }}" src="{{ pathto('_static/documentation_options.js', 1) }}"></script>
-<script src="{{ pathto('_static/jquery.js', 1) }}"></script>
-{%- block extrahead %} {% endblock %}
-</head>
-<body>
-{% include "nav.html" %}
-{%- block content %}
-<div class="d-flex" id="sk-doc-wrapper">
-    <input type="checkbox" name="sk-toggle-checkbox" id="sk-toggle-checkbox">
-    <label id="sk-sidemenu-toggle" class="sk-btn-toggle-toc btn sk-btn-primary" for="sk-toggle-checkbox">Toggle Menu</label>
-    <div id="sk-sidebar-wrapper" class="border-right">
-      <div class="sk-sidebar-toc-wrapper">
-        <div class="btn-group w-100 mb-2" role="group" aria-label="rellinks">
-          {%- if prev %}
-            <a href="{{ prev.link|e }}" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="{{ prev.title|striptags }}">Prev</a>
-          {%- else %}
-            <a href="#" role="button" class="btn sk-btn-rellink py-1 disabled"">Prev</a>
-          {%- endif %}
-          {%- if parents -%}
-            <a href="{{ parents[-1].link|e }}" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="{{ parents[-1].title|striptags }}">Up</a>
-          {%- else %}
-            <a href="#" role="button" class="btn sk-btn-rellink disabled py-1">Up</a>
-          {%- endif %}
-          {%- if next %}
-            <a href="{{ next.link|e }}" role="button" class="btn sk-btn-rellink py-1" sk-rellink-tooltip="{{ next.title|striptags }}">Next</a>
-          {%- else %}
-            <a href="#" role="button" class="btn sk-btn-rellink py-1 disabled"">Next</a>
-          {%- endif %}
-        </div>
-        {%- if pagename != "install" %}
-        <div class="alert alert-warning p-1 mb-2" role="alert">
-          <p class="text-center mb-0">
-          <strong>LangChain {{ release }}</strong><br/>
-          </p>
-        </div>
-        {%- endif %}
-            {%- if meta and meta['parenttoc']|tobool %}
-            <div class="sk-sidebar-toc">
-            {% set nav = get_nav_object(maxdepth=3, collapse=True, numbered=True) %}
-              <ul>
-              {% for main_nav_item in nav %}
-              {% if main_nav_item.active %}
-              <li>
-                <a href="{{ main_nav_item.url }}" class="sk-toc-active">{{ main_nav_item.title }}</a>
-              </li>
-              <ul>
-              {% for nav_item in main_nav_item.children %}
-                <li>
-                  <a href="{{ nav_item.url }}" class="{% if nav_item.active %}sk-toc-active{% endif %}">{{ nav_item.title }}</a>
-                  {% if nav_item.children %}
-                  <ul>
-                    {% for inner_child in nav_item.children %}
-                      <li class="sk-toctree-l3">
-                        <a href="{{ inner_child.url }}">{{ inner_child.title }}</a>
-                      </li>
-                    {% endfor %}
-                  </ul>
-                  {% endif %}
-                </li>
-              {% endfor %}
-              </ul>
-              {% endif %}
-              {% endfor %}
-              </ul>
-            </div>
-            {%- elif meta and meta['globalsidebartoc']|tobool %}
-            <div class="sk-sidebar-toc sk-sidebar-global-toc">
-              {{ toctree(maxdepth=2, titles_only=True) }}
-            </div>
-            {%- else %}
-            <div class="sk-sidebar-toc">
-              {{ toc }}
-            </div>
-            {%- endif %}
-      </div>
-    </div>
-    <div id="sk-page-content-wrapper">
-      <div class="sk-page-content container-fluid body px-md-3" role="main">
-        {% block body %}{% endblock %}
-      </div>
-    <div class="container">
-      <footer class="sk-content-footer">
-        {%- if pagename != 'index' %}
-        {%- if show_copyright %}
-          {%- if hasdoc('copyright') %}
-            {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; {{ copyright }}.{% endtrans %}
-          {%- else %}
-            {% trans copyright=copyright|e %}&copy; {{ copyright }}.{% endtrans %}
-          {%- endif %}
-        {%- endif %}
-        {%- if last_updated %}
-          {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
-        {%- endif %}
-        {%- if show_source and has_source and sourcename %}
-          <a href="{{ pathto('_sources/' + sourcename, true)|e }}" rel="nofollow">{{ _('Show this page source') }}</a>
-        {%- endif %}
-        {%- endif %}
-      </footer>
-    </div>
-  </div>
-</div>
-{%- endblock %}
-<script src="{{ pathto('_static/js/vendor/bootstrap.min.js', 1) }}"></script>
-{% include "javascript.html" %}
-</body>
-</html>

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

@@ -1,61 +0,0 @@
-{%- if pagename != 'index' and pagename != 'documentation' %}
-  {%- set nav_bar_class = "sk-docs-navbar" %}
-  {%- set top_container_cls = "sk-docs-container" %}
-{%- else %}
-  {%- set nav_bar_class = "sk-landing-navbar" %}
-  {%- set top_container_cls = "sk-landing-container" %}
-{%- endif %}
-
-<nav id="navbar" class="{{ nav_bar_class }} navbar navbar-expand-md navbar-light bg-light py-0">
-  <div class="container-fluid {{ top_container_cls }} px-0">
-    {%- if logo_url %}
-      <a class="navbar-brand py-0" href="{{ pathto('index') }}">
-        <img
-          class="sk-brand-img"
-          src="{{ logo_url|e }}"
-          alt="logo"/>
-      </a>
-    {%- endif %}
-    <button
-      id="sk-navbar-toggler"
-      class="navbar-toggler"
-      type="button"
-      data-toggle="collapse"
-      data-target="#navbarSupportedContent"
-      aria-controls="navbarSupportedContent"
-      aria-expanded="false"
-      aria-label="Toggle navigation"
-    >
-      <span class="navbar-toggler-icon"></span>
-    </button>
-
-    <div class="sk-navbar-collapse collapse navbar-collapse" id="navbarSupportedContent">
-      <ul class="navbar-nav mr-auto">
-        <li class="nav-item">
-          <a class="sk-nav-link nav-link" href="{{ pathto('api_reference') }}">API</a>
-        </li>
-        <li class="nav-item">
-          <a class="sk-nav-link nav-link" href="{{ pathto('experimental_api_reference') }}">Experimental</a>
-        </li>
-        <li class="nav-item">
-          <a class="sk-nav-link nav-link" target="_blank" rel="noopener noreferrer" href="https://python.langchain.com/">Python Docs</a>
-        </li>
-        {%- for title, link, link_attrs in drop_down_navigation %}
-        <li class="nav-item">
-          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="{{ link }}" {{ link_attrs }}>{{ title }}</a>
-        </li>
-        {%- endfor %}
-      </ul>
-      {%- if pagename != "search"%}
-      <div id="searchbox" role="search">
-          <div class="searchformwrapper">
-          <form class="search" action="{{ pathto('search') }}" method="get">
-            <input class="sk-search-text-input" type="text" name="q" aria-labelledby="searchlabel" />
-            <input class="sk-search-text-btn" type="submit" value="{{ _('Go') }}" />
-          </form>
-          </div>
-      </div>
-      {%- endif %}
-    </div>
-  </div>
-</nav>

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

@@ -1,16 +0,0 @@
-{%- extends "basic/search.html" %}
-{% block extrahead %}
-  <script type="text/javascript" src="{{ pathto('_static/underscore.js', 1) }}"></script>
-  <script type="text/javascript" src="{{ pathto('searchindex.js', 1) }}" defer></script>
-  <script type="text/javascript" src="{{ pathto('_static/doctools.js', 1) }}"></script>
-  <script type="text/javascript" src="{{ pathto('_static/language_data.js', 1) }}"></script>
-  <script type="text/javascript" src="{{ pathto('_static/searchtools.js', 1) }}"></script>
-  <!-- <script type="text/javascript" src="{{ pathto('_static/sphinx_highlight.js', 1) }}"></script> -->
-  <script type="text/javascript">
-    $(document).ready(function() {
-      if (!Search.out) {
-        Search.init();
-      }
-    });
-  </script>
-{% endblock %}

docs/api_reference/themes/scikit-learn-modern/theme.conf

@@ -1,8 +0,0 @@
-[theme]
-inherit = basic
-pygments_style = default
-stylesheet = css/theme.css
-
-[options]
-link_to_live_contributing_page = false
-mathjax_path =

docs/conf.py

@@ -0,0 +1,112 @@
+"""Configuration file for the Sphinx documentation builder."""
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+import toml
+
+with open("../pyproject.toml") as f:
+    data = toml.load(f)
+
+# -- Project information -----------------------------------------------------
+
+project = "🦜🔗 LangChain"
+copyright = "2023, Harrison Chase"
+author = "Harrison Chase"
+
+version = data["tool"]["poetry"]["version"]
+release = version
+
+html_title = project + " " + version
+html_last_updated_fmt = "%b %d, %Y"
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autodoc.typehints",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+    "sphinxcontrib.autodoc_pydantic",
+    "myst_nb",
+    "sphinx_copybutton",
+    "sphinx_panels",
+    "IPython.sphinxext.ipython_console_highlighting",
+]
+source_suffix = [".ipynb", ".html", ".md", ".rst"]
+
+autodoc_pydantic_model_show_json = False
+autodoc_pydantic_field_list_validators = False
+autodoc_pydantic_config_members = False
+autodoc_pydantic_model_show_config_summary = False
+autodoc_pydantic_model_show_validator_members = False
+autodoc_pydantic_model_show_field_summary = False
+autodoc_pydantic_model_members = False
+autodoc_pydantic_model_undoc_members = False
+# autodoc_typehints = "signature"
+# autodoc_typehints = "description"
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = "sphinx_book_theme"
+
+html_theme_options = {
+    "path_to_docs": "docs",
+    "repository_url": "https://github.com/hwchase17/langchain",
+    "use_repository_button": True,
+}
+
+html_context = {
+    "display_github": True,  # Integrate GitHub
+    "github_user": "hwchase17",  # Username
+    "github_repo": "langchain",  # Repo name
+    "github_version": "master",  # Version
+    "conf_py_path": "/docs/",  # Path in the checkout to the docs root
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# These paths are either relative to html_static_path
+# or fully qualified paths (eg. https://...)
+html_css_files = [
+    "css/custom.css",
+]
+
+html_js_files = [
+    "js/mendablesearch.js",
+]
+
+nb_execution_mode = "off"
+myst_enable_extensions = ["colon_fence"]

docs/dependents.md

@@ -0,0 +1,231 @@
+# Dependents
+
+Dependents stats for `hwchase17/langchain`
+
+[![](https://img.shields.io/static/v1?label=Used%20by&message=7484&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
+[![](https://img.shields.io/static/v1?label=Used%20by%20(public)&message=212&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
+[![](https://img.shields.io/static/v1?label=Used%20by%20(private)&message=7272&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
+[![](https://img.shields.io/static/v1?label=Used%20by%20(stars)&message=19095&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
+
+[update: 2023-06-05; only dependent repositories with Stars > 100]
+
+
+| Repository | Stars  |
+| :--------  | -----: |
+|[openai/openai-cookbook](https://github.com/openai/openai-cookbook) | 38024 |
+|[LAION-AI/Open-Assistant](https://github.com/LAION-AI/Open-Assistant) | 33609 |
+|[microsoft/TaskMatrix](https://github.com/microsoft/TaskMatrix) | 33136 |
+|[hpcaitech/ColossalAI](https://github.com/hpcaitech/ColossalAI) | 30032 |
+|[imartinez/privateGPT](https://github.com/imartinez/privateGPT) | 28094 |
+|[reworkd/AgentGPT](https://github.com/reworkd/AgentGPT) | 23430 |
+|[openai/chatgpt-retrieval-plugin](https://github.com/openai/chatgpt-retrieval-plugin) | 17942 |
+|[jerryjliu/llama_index](https://github.com/jerryjliu/llama_index) | 16697 |
+|[mindsdb/mindsdb](https://github.com/mindsdb/mindsdb) | 16410 |
+|[mlflow/mlflow](https://github.com/mlflow/mlflow) | 14517 |
+|[GaiZhenbiao/ChuanhuChatGPT](https://github.com/GaiZhenbiao/ChuanhuChatGPT) | 10793 |
+|[databrickslabs/dolly](https://github.com/databrickslabs/dolly) | 10155 |
+|[openai/evals](https://github.com/openai/evals) | 10076 |
+|[AIGC-Audio/AudioGPT](https://github.com/AIGC-Audio/AudioGPT) | 8619 |
+|[logspace-ai/langflow](https://github.com/logspace-ai/langflow) | 8211 |
+|[imClumsyPanda/langchain-ChatGLM](https://github.com/imClumsyPanda/langchain-ChatGLM) | 8154 |
+|[PromtEngineer/localGPT](https://github.com/PromtEngineer/localGPT) | 6853 |
+|[StanGirard/quivr](https://github.com/StanGirard/quivr) | 6830 |
+|[PipedreamHQ/pipedream](https://github.com/PipedreamHQ/pipedream) | 6520 |
+|[go-skynet/LocalAI](https://github.com/go-skynet/LocalAI) | 6018 |
+|[arc53/DocsGPT](https://github.com/arc53/DocsGPT) | 5643 |
+|[e2b-dev/e2b](https://github.com/e2b-dev/e2b) | 5075 |
+|[langgenius/dify](https://github.com/langgenius/dify) | 4281 |
+|[nsarrazin/serge](https://github.com/nsarrazin/serge) | 4228 |
+|[zauberzeug/nicegui](https://github.com/zauberzeug/nicegui) | 4084 |
+|[madawei2699/myGPTReader](https://github.com/madawei2699/myGPTReader) | 4039 |
+|[wenda-LLM/wenda](https://github.com/wenda-LLM/wenda) | 3871 |
+|[GreyDGL/PentestGPT](https://github.com/GreyDGL/PentestGPT) | 3837 |
+|[zilliztech/GPTCache](https://github.com/zilliztech/GPTCache) | 3625 |
+|[csunny/DB-GPT](https://github.com/csunny/DB-GPT) | 3545 |
+|[gkamradt/langchain-tutorials](https://github.com/gkamradt/langchain-tutorials) | 3404 |
+|[mmabrouk/chatgpt-wrapper](https://github.com/mmabrouk/chatgpt-wrapper) | 3303 |
+|[postgresml/postgresml](https://github.com/postgresml/postgresml) | 3052 |
+|[marqo-ai/marqo](https://github.com/marqo-ai/marqo) | 3014 |
+|[MineDojo/Voyager](https://github.com/MineDojo/Voyager) | 2945 |
+|[PrefectHQ/marvin](https://github.com/PrefectHQ/marvin) | 2761 |
+|[project-baize/baize-chatbot](https://github.com/project-baize/baize-chatbot) | 2673 |
+|[hwchase17/chat-langchain](https://github.com/hwchase17/chat-langchain) | 2589 |
+|[whitead/paper-qa](https://github.com/whitead/paper-qa) | 2572 |
+|[Azure-Samples/azure-search-openai-demo](https://github.com/Azure-Samples/azure-search-openai-demo) | 2366 |
+|[GerevAI/gerev](https://github.com/GerevAI/gerev) | 2330 |
+|[OpenGVLab/InternGPT](https://github.com/OpenGVLab/InternGPT) | 2289 |
+|[ParisNeo/gpt4all-ui](https://github.com/ParisNeo/gpt4all-ui) | 2159 |
+|[OpenBMB/BMTools](https://github.com/OpenBMB/BMTools) | 2158 |
+|[guangzhengli/ChatFiles](https://github.com/guangzhengli/ChatFiles) | 2005 |
+|[h2oai/h2ogpt](https://github.com/h2oai/h2ogpt) | 1939 |
+|[Farama-Foundation/PettingZoo](https://github.com/Farama-Foundation/PettingZoo) | 1845 |
+|[OpenGVLab/Ask-Anything](https://github.com/OpenGVLab/Ask-Anything) | 1749 |
+|[IntelligenzaArtificiale/Free-Auto-GPT](https://github.com/IntelligenzaArtificiale/Free-Auto-GPT) | 1740 |
+|[Unstructured-IO/unstructured](https://github.com/Unstructured-IO/unstructured) | 1628 |
+|[hwchase17/notion-qa](https://github.com/hwchase17/notion-qa) | 1607 |
+|[NVIDIA/NeMo-Guardrails](https://github.com/NVIDIA/NeMo-Guardrails) | 1544 |
+|[SamurAIGPT/privateGPT](https://github.com/SamurAIGPT/privateGPT) | 1543 |
+|[paulpierre/RasaGPT](https://github.com/paulpierre/RasaGPT) | 1526 |
+|[yanqiangmiffy/Chinese-LangChain](https://github.com/yanqiangmiffy/Chinese-LangChain) | 1485 |
+|[Kav-K/GPTDiscord](https://github.com/Kav-K/GPTDiscord) | 1402 |
+|[vocodedev/vocode-python](https://github.com/vocodedev/vocode-python) | 1387 |
+|[Chainlit/chainlit](https://github.com/Chainlit/chainlit) | 1336 |
+|[lunasec-io/lunasec](https://github.com/lunasec-io/lunasec) | 1323 |
+|[psychic-api/psychic](https://github.com/psychic-api/psychic) | 1248 |
+|[agiresearch/OpenAGI](https://github.com/agiresearch/OpenAGI) | 1208 |
+|[jina-ai/thinkgpt](https://github.com/jina-ai/thinkgpt) | 1193 |
+|[thomas-yanxin/LangChain-ChatGLM-Webui](https://github.com/thomas-yanxin/LangChain-ChatGLM-Webui) | 1182 |
+|[ttengwang/Caption-Anything](https://github.com/ttengwang/Caption-Anything) | 1137 |
+|[jina-ai/dev-gpt](https://github.com/jina-ai/dev-gpt) | 1135 |
+|[greshake/llm-security](https://github.com/greshake/llm-security) | 1086 |
+|[keephq/keep](https://github.com/keephq/keep) | 1063 |
+|[juncongmoo/chatllama](https://github.com/juncongmoo/chatllama) | 1037 |
+|[richardyc/Chrome-GPT](https://github.com/richardyc/Chrome-GPT) | 1035 |
+|[visual-openllm/visual-openllm](https://github.com/visual-openllm/visual-openllm) | 997 |
+|[mmz-001/knowledge_gpt](https://github.com/mmz-001/knowledge_gpt) | 995 |
+|[jina-ai/langchain-serve](https://github.com/jina-ai/langchain-serve) | 949 |
+|[irgolic/AutoPR](https://github.com/irgolic/AutoPR) | 936 |
+|[microsoft/X-Decoder](https://github.com/microsoft/X-Decoder) | 908 |
+|[poe-platform/api-bot-tutorial](https://github.com/poe-platform/api-bot-tutorial) | 902 |
+|[peterw/Chat-with-Github-Repo](https://github.com/peterw/Chat-with-Github-Repo) | 875 |
+|[cirediatpl/FigmaChain](https://github.com/cirediatpl/FigmaChain) | 822 |
+|[homanp/superagent](https://github.com/homanp/superagent) | 806 |
+|[seanpixel/Teenage-AGI](https://github.com/seanpixel/Teenage-AGI) | 800 |
+|[chatarena/chatarena](https://github.com/chatarena/chatarena) | 796 |
+|[hashintel/hash](https://github.com/hashintel/hash) | 795 |
+|[SamurAIGPT/Camel-AutoGPT](https://github.com/SamurAIGPT/Camel-AutoGPT) | 786 |
+|[rlancemartin/auto-evaluator](https://github.com/rlancemartin/auto-evaluator) | 770 |
+|[corca-ai/EVAL](https://github.com/corca-ai/EVAL) | 769 |
+|[101dotxyz/GPTeam](https://github.com/101dotxyz/GPTeam) | 755 |
+|[noahshinn024/reflexion](https://github.com/noahshinn024/reflexion) | 706 |
+|[eyurtsev/kor](https://github.com/eyurtsev/kor) | 695 |
+|[cheshire-cat-ai/core](https://github.com/cheshire-cat-ai/core) | 681 |
+|[e-johnstonn/BriefGPT](https://github.com/e-johnstonn/BriefGPT) | 656 |
+|[run-llama/llama-lab](https://github.com/run-llama/llama-lab) | 635 |
+|[griptape-ai/griptape](https://github.com/griptape-ai/griptape) | 583 |
+|[namuan/dr-doc-search](https://github.com/namuan/dr-doc-search) | 555 |
+|[getmetal/motorhead](https://github.com/getmetal/motorhead) | 550 |
+|[kreneskyp/ix](https://github.com/kreneskyp/ix) | 543 |
+|[hwchase17/chat-your-data](https://github.com/hwchase17/chat-your-data) | 510 |
+|[Anil-matcha/ChatPDF](https://github.com/Anil-matcha/ChatPDF) | 501 |
+|[whyiyhw/chatgpt-wechat](https://github.com/whyiyhw/chatgpt-wechat) | 497 |
+|[SamurAIGPT/ChatGPT-Developer-Plugins](https://github.com/SamurAIGPT/ChatGPT-Developer-Plugins) | 496 |
+|[microsoft/PodcastCopilot](https://github.com/microsoft/PodcastCopilot) | 492 |
+|[debanjum/khoj](https://github.com/debanjum/khoj) | 485 |
+|[akshata29/chatpdf](https://github.com/akshata29/chatpdf) | 485 |
+|[langchain-ai/langchain-aiplugin](https://github.com/langchain-ai/langchain-aiplugin) | 462 |
+|[jina-ai/agentchain](https://github.com/jina-ai/agentchain) | 460 |
+|[alexanderatallah/window.ai](https://github.com/alexanderatallah/window.ai) | 457 |
+|[yeagerai/yeagerai-agent](https://github.com/yeagerai/yeagerai-agent) | 451 |
+|[mckaywrigley/repo-chat](https://github.com/mckaywrigley/repo-chat) | 446 |
+|[michaelthwan/searchGPT](https://github.com/michaelthwan/searchGPT) | 446 |
+|[mpaepper/content-chatbot](https://github.com/mpaepper/content-chatbot) | 441 |
+|[freddyaboulton/gradio-tools](https://github.com/freddyaboulton/gradio-tools) | 439 |
+|[ruoccofabrizio/azure-open-ai-embeddings-qna](https://github.com/ruoccofabrizio/azure-open-ai-embeddings-qna) | 429 |
+|[StevenGrove/GPT4Tools](https://github.com/StevenGrove/GPT4Tools) | 422 |
+|[jonra1993/fastapi-alembic-sqlmodel-async](https://github.com/jonra1993/fastapi-alembic-sqlmodel-async) | 407 |
+|[msoedov/langcorn](https://github.com/msoedov/langcorn) | 405 |
+|[amosjyng/langchain-visualizer](https://github.com/amosjyng/langchain-visualizer) | 395 |
+|[ajndkr/lanarky](https://github.com/ajndkr/lanarky) | 384 |
+|[mtenenholtz/chat-twitter](https://github.com/mtenenholtz/chat-twitter) | 376 |
+|[steamship-core/steamship-langchain](https://github.com/steamship-core/steamship-langchain) | 371 |
+|[langchain-ai/auto-evaluator](https://github.com/langchain-ai/auto-evaluator) | 365 |
+|[xuwenhao/geektime-ai-course](https://github.com/xuwenhao/geektime-ai-course) | 358 |
+|[continuum-llms/chatgpt-memory](https://github.com/continuum-llms/chatgpt-memory) | 357 |
+|[opentensor/bittensor](https://github.com/opentensor/bittensor) | 347 |
+|[showlab/VLog](https://github.com/showlab/VLog) | 345 |
+|[daodao97/chatdoc](https://github.com/daodao97/chatdoc) | 345 |
+|[logan-markewich/llama_index_starter_pack](https://github.com/logan-markewich/llama_index_starter_pack) | 332 |
+|[poe-platform/poe-protocol](https://github.com/poe-platform/poe-protocol) | 320 |
+|[explosion/spacy-llm](https://github.com/explosion/spacy-llm) | 312 |
+|[andylokandy/gpt-4-search](https://github.com/andylokandy/gpt-4-search) | 311 |
+|[alejandro-ao/langchain-ask-pdf](https://github.com/alejandro-ao/langchain-ask-pdf) | 310 |
+|[jupyterlab/jupyter-ai](https://github.com/jupyterlab/jupyter-ai) | 294 |
+|[BlackHC/llm-strategy](https://github.com/BlackHC/llm-strategy) | 283 |
+|[itamargol/openai](https://github.com/itamargol/openai) | 281 |
+|[momegas/megabots](https://github.com/momegas/megabots) | 279 |
+|[personoids/personoids-lite](https://github.com/personoids/personoids-lite) | 277 |
+|[yvann-hub/Robby-chatbot](https://github.com/yvann-hub/Robby-chatbot) | 267 |
+|[Anil-matcha/Website-to-Chatbot](https://github.com/Anil-matcha/Website-to-Chatbot) | 266 |
+|[Cheems-Seminar/grounded-segment-any-parts](https://github.com/Cheems-Seminar/grounded-segment-any-parts) | 260 |
+|[sullivan-sean/chat-langchainjs](https://github.com/sullivan-sean/chat-langchainjs) | 248 |
+|[bborn/howdoi.ai](https://github.com/bborn/howdoi.ai) | 245 |
+|[daveebbelaar/langchain-experiments](https://github.com/daveebbelaar/langchain-experiments) | 240 |
+|[MagnivOrg/prompt-layer-library](https://github.com/MagnivOrg/prompt-layer-library) | 237 |
+|[ur-whitelab/exmol](https://github.com/ur-whitelab/exmol) | 234 |
+|[conceptofmind/toolformer](https://github.com/conceptofmind/toolformer) | 234 |
+|[recalign/RecAlign](https://github.com/recalign/RecAlign) | 226 |
+|[OpenBMB/AgentVerse](https://github.com/OpenBMB/AgentVerse) | 220 |
+|[alvarosevilla95/autolang](https://github.com/alvarosevilla95/autolang) | 219 |
+|[JohnSnowLabs/nlptest](https://github.com/JohnSnowLabs/nlptest) | 216 |
+|[kaleido-lab/dolphin](https://github.com/kaleido-lab/dolphin) | 215 |
+|[truera/trulens](https://github.com/truera/trulens) | 208 |
+|[NimbleBoxAI/ChainFury](https://github.com/NimbleBoxAI/ChainFury) | 208 |
+|[airobotlab/KoChatGPT](https://github.com/airobotlab/KoChatGPT) | 207 |
+|[monarch-initiative/ontogpt](https://github.com/monarch-initiative/ontogpt) | 200 |
+|[paolorechia/learn-langchain](https://github.com/paolorechia/learn-langchain) | 195 |
+|[shaman-ai/agent-actors](https://github.com/shaman-ai/agent-actors) | 185 |
+|[Haste171/langchain-chatbot](https://github.com/Haste171/langchain-chatbot) | 184 |
+|[plchld/InsightFlow](https://github.com/plchld/InsightFlow) | 182 |
+|[su77ungr/CASALIOY](https://github.com/su77ungr/CASALIOY) | 180 |
+|[jbrukh/gpt-jargon](https://github.com/jbrukh/gpt-jargon) | 177 |
+|[benthecoder/ClassGPT](https://github.com/benthecoder/ClassGPT) | 174 |
+|[billxbf/ReWOO](https://github.com/billxbf/ReWOO) | 170 |
+|[filip-michalsky/SalesGPT](https://github.com/filip-michalsky/SalesGPT) | 168 |
+|[hwchase17/langchain-streamlit-template](https://github.com/hwchase17/langchain-streamlit-template) | 168 |
+|[radi-cho/datasetGPT](https://github.com/radi-cho/datasetGPT) | 164 |
+|[hardbyte/qabot](https://github.com/hardbyte/qabot) | 164 |
+|[gia-guar/JARVIS-ChatGPT](https://github.com/gia-guar/JARVIS-ChatGPT) | 158 |
+|[plastic-labs/tutor-gpt](https://github.com/plastic-labs/tutor-gpt) | 154 |
+|[yasyf/compress-gpt](https://github.com/yasyf/compress-gpt) | 154 |
+|[fengyuli-dev/multimedia-gpt](https://github.com/fengyuli-dev/multimedia-gpt) | 154 |
+|[ethanyanjiali/minChatGPT](https://github.com/ethanyanjiali/minChatGPT) | 153 |
+|[hwchase17/chroma-langchain](https://github.com/hwchase17/chroma-langchain) | 153 |
+|[edreisMD/plugnplai](https://github.com/edreisMD/plugnplai) | 148 |
+|[chakkaradeep/pyCodeAGI](https://github.com/chakkaradeep/pyCodeAGI) | 145 |
+|[ccurme/yolopandas](https://github.com/ccurme/yolopandas) | 145 |
+|[shamspias/customizable-gpt-chatbot](https://github.com/shamspias/customizable-gpt-chatbot) | 144 |
+|[realminchoi/babyagi-ui](https://github.com/realminchoi/babyagi-ui) | 143 |
+|[PradipNichite/Youtube-Tutorials](https://github.com/PradipNichite/Youtube-Tutorials) | 140 |
+|[gustavz/DataChad](https://github.com/gustavz/DataChad) | 140 |
+|[Klingefjord/chatgpt-telegram](https://github.com/Klingefjord/chatgpt-telegram) | 140 |
+|[Jaseci-Labs/jaseci](https://github.com/Jaseci-Labs/jaseci) | 139 |
+|[handrew/browserpilot](https://github.com/handrew/browserpilot) | 137 |
+|[jmpaz/promptlib](https://github.com/jmpaz/promptlib) | 137 |
+|[SamPink/dev-gpt](https://github.com/SamPink/dev-gpt) | 135 |
+|[menloparklab/langchain-cohere-qdrant-doc-retrieval](https://github.com/menloparklab/langchain-cohere-qdrant-doc-retrieval) | 135 |
+|[hirokidaichi/wanna](https://github.com/hirokidaichi/wanna) | 135 |
+|[steamship-core/vercel-examples](https://github.com/steamship-core/vercel-examples) | 134 |
+|[pablomarin/GPT-Azure-Search-Engine](https://github.com/pablomarin/GPT-Azure-Search-Engine) | 133 |
+|[ibiscp/LLM-IMDB](https://github.com/ibiscp/LLM-IMDB) | 133 |
+|[shauryr/S2QA](https://github.com/shauryr/S2QA) | 133 |
+|[jerlendds/osintbuddy](https://github.com/jerlendds/osintbuddy) | 132 |
+|[yuanjie-ai/ChatLLM](https://github.com/yuanjie-ai/ChatLLM) | 132 |
+|[yasyf/summ](https://github.com/yasyf/summ) | 132 |
+|[WongSaang/chatgpt-ui-server](https://github.com/WongSaang/chatgpt-ui-server) | 130 |
+|[peterw/StoryStorm](https://github.com/peterw/StoryStorm) | 127 |
+|[Teahouse-Studios/akari-bot](https://github.com/Teahouse-Studios/akari-bot) | 126 |
+|[vaibkumr/prompt-optimizer](https://github.com/vaibkumr/prompt-optimizer) | 125 |
+|[preset-io/promptimize](https://github.com/preset-io/promptimize) | 124 |
+|[homanp/vercel-langchain](https://github.com/homanp/vercel-langchain) | 124 |
+|[petehunt/langchain-github-bot](https://github.com/petehunt/langchain-github-bot) | 123 |
+|[eunomia-bpf/GPTtrace](https://github.com/eunomia-bpf/GPTtrace) | 118 |
+|[nicknochnack/LangchainDocuments](https://github.com/nicknochnack/LangchainDocuments) | 116 |
+|[jiran214/GPT-vup](https://github.com/jiran214/GPT-vup) | 112 |
+|[rsaryev/talk-codebase](https://github.com/rsaryev/talk-codebase) | 112 |
+|[zenml-io/zenml-projects](https://github.com/zenml-io/zenml-projects) | 112 |
+|[microsoft/azure-openai-in-a-day-workshop](https://github.com/microsoft/azure-openai-in-a-day-workshop) | 112 |
+|[davila7/file-gpt](https://github.com/davila7/file-gpt) | 112 |
+|[prof-frink-lab/slangchain](https://github.com/prof-frink-lab/slangchain) | 111 |
+|[aurelio-labs/arxiv-bot](https://github.com/aurelio-labs/arxiv-bot) | 110 |
+|[fixie-ai/fixie-examples](https://github.com/fixie-ai/fixie-examples) | 108 |
+|[miaoshouai/miaoshouai-assistant](https://github.com/miaoshouai/miaoshouai-assistant) | 105 |
+|[flurb18/AgentOoba](https://github.com/flurb18/AgentOoba) | 103 |
+|[solana-labs/chatgpt-plugin](https://github.com/solana-labs/chatgpt-plugin) | 102 |
+|[Significant-Gravitas/Auto-GPT-Benchmarks](https://github.com/Significant-Gravitas/Auto-GPT-Benchmarks) | 102 |
+|[kaarthik108/snowChat](https://github.com/kaarthik108/snowChat) | 100 |
+
+
+_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/docs_skeleton/.gitignore

@@ -1,7 +0,0 @@
-.yarn/
-
-node_modules/
-
-.docusaurus
-.cache-loader
-docs/api

docs/docs_skeleton/README.md

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

docs/docs_skeleton/babel.config.js

@@ -1,12 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @format
- */
-
-module.exports = {
-  presets: [require.resolve("@docusaurus/core/lib/babel/preset")],
-};

docs/docs_skeleton/code-block-loader.js

@@ -1,76 +0,0 @@
-/* eslint-disable prefer-template */
-/* eslint-disable no-param-reassign */
-// eslint-disable-next-line import/no-extraneous-dependencies
-const babel = require("@babel/core");
-const path = require("path");
-const fs = require("fs");
-
-/**
- *
- * @param {string|Buffer} content Content of the resource file
- * @param {object} [map] SourceMap data consumable by https://github.com/mozilla/source-map
- * @param {any} [meta] Meta data, could be anything
- */
-async function webpackLoader(content, map, meta) {
-  const cb = this.async();
-
-  if (!this.resourcePath.endsWith(".ts")) {
-    cb(null, JSON.stringify({ content, imports: [] }), map, meta);
-    return;
-  }
-
-  try {
-    const result = await babel.parseAsync(content, {
-      sourceType: "module",
-      filename: this.resourcePath,
-    });
-
-    const imports = [];
-
-    result.program.body.forEach((node) => {
-      if (node.type === "ImportDeclaration") {
-        const source = node.source.value;
-
-        if (!source.startsWith("langchain")) {
-          return;
-        }
-
-        node.specifiers.forEach((specifier) => {
-          if (specifier.type === "ImportSpecifier") {
-            const local = specifier.local.name;
-            const imported = specifier.imported.name;
-            imports.push({ local, imported, source });
-          } else {
-            throw new Error("Unsupported import type");
-          }
-        });
-      }
-    });
-
-    imports.forEach((imp) => {
-      const { imported, source } = imp;
-      const moduleName = source.split("/").slice(1).join("_");
-      const docsPath = path.resolve(__dirname, "docs", "api", moduleName);
-      const available = fs.readdirSync(docsPath, { withFileTypes: true });
-      const found = available.find(
-        (dirent) =>
-          dirent.isDirectory() &&
-          fs.existsSync(path.resolve(docsPath, dirent.name, imported + ".md"))
-      );
-      if (found) {
-        imp.docs =
-          "/" + path.join("docs", "api", moduleName, found.name, imported);
-      } else {
-        throw new Error(
-          `Could not find docs for ${source}.${imported} in docs/api/`
-        );
-      }
-    });
-
-    cb(null, JSON.stringify({ content, imports }), map, meta);
-  } catch (err) {
-    cb(err);
-  }
-}
-
-module.exports = webpackLoader;

docs/docs_skeleton/docs/_static/css/custom.css

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

docs/docs_skeleton/docs/get_started/installation.mdx

@@ -1,5 +0,0 @@
-# Installation
-
-import Installation from "@snippets/get_started/installation.mdx"
-
-<Installation/>

docs/docs_skeleton/docs/get_started/introduction.mdx

@@ -1,65 +0,0 @@
----
-sidebar_position: 0
----
-
-# Introduction
-
-**LangChain** is a framework for developing applications powered by language models. It enables applications that are:
-- **Data-aware**: connect a language model to other sources of data
-- **Agentic**: allow a language model to interact with its environment
-
-The main value props of LangChain are:
-1. **Components**: abstractions for working with language models, along with a collection of implementations for each abstraction. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
-2. **Off-the-shelf chains**: a structured assembly of components for accomplishing specific higher-level tasks
-
-Off-the-shelf chains make it easy to get started. For more complex applications and nuanced use-cases, components make it easy to customize existing chains or build new ones.
-
-## Get started
-
-[Here’s](/docs/get_started/installation.html) how to install LangChain, set up your environment, and start building.
-
-We recommend following our [Quickstart](/docs/get_started/quickstart.html) guide to familiarize yourself with the framework by building your first LangChain application.
-
-_**Note**: These docs are for the LangChain [Python package](https://github.com/hwchase17/langchain). For documentation on [LangChain.js](https://github.com/hwchase17/langchainjs), the JS/TS version, [head here](https://js.langchain.com/docs)._
-
-## Modules
-
-LangChain provides standard, extendable interfaces and external integrations for the following modules, listed from least to most complex:
-
-#### [Model I/O](/docs/modules/model_io/)
-Interface with language models
-#### [Data connection](/docs/modules/data_connection/)
-Interface with application-specific data
-#### [Chains](/docs/modules/chains/)
-Construct sequences of calls
-#### [Agents](/docs/modules/agents/)
-Let chains choose which tools to use given high-level directives
-#### [Memory](/docs/modules/memory/)
-Persist application state between runs of a chain
-#### [Callbacks](/docs/modules/callbacks/)
-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/)
-- [Answering questions using sources](/docs/use_cases/question_answering/)
-- [Analyzing structured data](/docs/use_cases/tabular.html)
-- 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).
-
-### [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.
-
-## API reference
-
-Head to the [reference](https://api.python.langchain.com) section for full documentation of all classes and methods in the LangChain Python package.

docs/docs_skeleton/docs/get_started/quickstart.mdx

@@ -1,162 +0,0 @@
-# Quickstart
-
-## Installation
-
-To install LangChain run:
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-import Install from "@snippets/get_started/quickstart/installation.mdx"
-
-<Install/>
-
-For more details, see our [Installation guide](/docs/get_started/installation.html).
-
-## Environment setup
-
-Using LangChain will usually require integrations with one or more model providers, data stores, APIs, etc. For this example, we'll use OpenAI's model APIs.
-
-import OpenAISetup from "@snippets/get_started/quickstart/openai_setup.mdx"
-
-<OpenAISetup/>
-
-## Building an application
-
-Now we can start building our language model application. LangChain provides many modules that can be used to build language model applications.
-Modules can be used as stand-alones in simple applications and they can be combined for more complex use cases.
-
-The core building block of LangChain applications is the LLMChain.
-This combines three things:
-- LLM: The language model is the core reasoning engine here. In order to work with LangChain, you need to understand the different types of language models and how to work with them.
-- Prompt Templates: This provides instructions to the language model. This controls what the language model outputs, so understanding how to construct prompts and different prompting strategies is crucial.
-- Output Parsers: These translate the raw response from the LLM to a more workable format, making it easy to use the output downstream.
-
-In this getting started guide we will cover those three components by themselves, and then cover the LLMChain which combines all of them.
-Understanding these concepts will set you up well for being able to use and customize LangChain applications.
-Most LangChain applications allow you to configure the LLM and/or the prompt used, so knowing how to take advantage of this will be a big enabler.
-
-## LLMs
-
-There are two types of language models, which in LangChain are called:
-
-- LLMs: this is a language model which takes a string as input and returns a string
-- ChatModels: this is a language model which takes a list of messages as input and returns a message
-
-The input/output for LLMs is simple and easy to understand - a string.
-But what about ChatModels? The input there is a list of `ChatMessage`s, and the output is a single `ChatMessage`.
-A `ChatMessage` has two required components:
-
-- `content`: This is the content of the message.
-- `role`: This is the role of the entity from which the `ChatMessage` is coming from.
-
-LangChain provides several objects to easily distinguish between different roles:
-
-- `HumanMessage`: A `ChatMessage` coming from a human/user.
-- `AIMessage`: A `ChatMessage` coming from an AI/assistant.
-- `SystemMessage`: A `ChatMessage` coming from the system.
-- `FunctionMessage`: A `ChatMessage` coming from a function call.
-
-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:
-- `predict`: Takes in a string, returns a string
-- `predict_messages`: Takes in a list of messages, returns a message.
-
-Let's see how to work with these different types of models and these different types of inputs.
-First, let's import an LLM and a ChatModel.
-
-import ImportLLMs from "@snippets/get_started/quickstart/import_llms.mdx"
-
-<ImportLLMs/>
-
-The `OpenAI` and `ChatOpenAI` objects are basically just configuration objects.
-You can initialize them with parameters like `temperature` and others, and pass them around.
-
-Next, let's use the `predict` method to run over a string input.
-
-import InputString from "@snippets/get_started/quickstart/input_string.mdx"
-
-<InputString/>
-
-Finally, let's use the `predict_messages` method to run over a list of messages.
-
-import InputMessages from "@snippets/get_started/quickstart/input_messages.mdx"
-
-<InputMessages/>
-
-For both these methods, you can also pass in parameters as key word arguments.
-For example, you could pass in `temperature=0` to adjust the temperature that is used from what the object was configured with.
-Whatever values are passed in during run time will always override what the object was configured with.
-
-
-## Prompt templates
-
-Most LLM applications do not pass user input directly into an LLM. Usually they will add the user input to a larger piece of text, called a prompt template, that provides additional context on the specific task at hand.
-
-In the previous example, the text we passed to the model contained instructions to generate a company name. For our application, it'd be great if the user only had to provide the description of a company/product, without having to worry about giving the model instructions.
-
-PromptTemplates help with exactly this!
-They bundle up all the logic for going from user input into a fully formatted prompt.
-This can start off very simple - for example, a prompt to produce the above string would just be:
-
-import PromptTemplateLLM from "@snippets/get_started/quickstart/prompt_templates_llms.mdx"
-import PromptTemplateChatModel from "@snippets/get_started/quickstart/prompt_templates_chat_models.mdx"
-
-<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 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.
-
-PromptTemplates can also be used to produce a list of messages.
-In this case, the prompt not only contains information about the content, but also each message (its role, its position in the list, etc)
-Here, what happens most often is a ChatPromptTemplate is a list of ChatMessageTemplates.
-Each ChatMessageTemplate contains instructions for how to format that ChatMessage - its role, and then also its content.
-Let's take a look at this below:
-
-<PromptTemplateChatModel/>
-
-ChatPromptTemplates can also include other things besides ChatMessageTemplates - see the [section on prompts](/docs/modules/model_io/prompts) for more detail.
-
-## 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 a ChatMessage into just a string
-- Convert the extra information returned from a call besides the message (like OpenAI function invocation) into a string.
-
-For full information on this, see the [section on output parsers](/docs/modules/model_io/output_parsers)
-
-In this getting started guide, we will write our own output parser - one that converts a comma separated list into a list.
-
-import OutputParser from "@snippets/get_started/quickstart/output_parser.mdx"
-
-<OutputParser/>
-
-## LLMChain
-
-We can now combine all these into one chain.
-This chain will take input variables, pass those to a prompt template to create a prompt, pass the prompt to an LLM, and then pass the output through an (optional) output parser.
-This is a convenient way to bundle up a modular piece of logic.
-Let's see it in action!
-
-import LLMChain from "@snippets/get_started/quickstart/llm_chain.mdx"
-
-<LLMChain/>
-
-## Next Steps
-
-This is it!
-We've now gone over how to create the core building block of LangChain applications - the LLMChains.
-There is a lot more nuance in all these components (LLMs, prompts, output parsers) and a lot more different components to learn about as well.
-To continue on your journey:
-
-- [Dive deeper](/docs/modules/model_io) into LLMs, prompts, and output parsers
-- Learn the other [key components](/docs/modules)
-- Check out our [helpful guides](/docs/guides) for detailed walkthroughs on particular topics
-- Explore [end-to-end use cases](/docs/use_cases)

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

@@ -1,24 +0,0 @@
----
-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.
-
-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.
-
-To create a custom comparison evaluator, inherit from the `PairwiseStringEvaluator` class and overwrite the `_evaluate_string_pairs` method. If you require asynchronous evaluation, also overwrite the `_aevaluate_string_pairs` method.
-
-Here's a summary of the key methods and properties of a comparison evaluator:
-
-- `evaluate_string_pairs`: Evaluate the output string pairs. This function should be overwritten when creating custom evaluators.
-- `aevaluate_string_pairs`: Asynchronously evaluate the output string pairs. This function should be overwritten for asynchronous evaluation.
-- `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.
-
-import DocCardList from "@theme/DocCardList";
-
-<DocCardList />
-

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

@@ -1,12 +0,0 @@
----
-sidebar_position: 5
----
-# Examples
-
-🚧 _Docs under construction_ 🚧
-
-Below are some examples for inspecting and checking different chains.
-
-import DocCardList from "@theme/DocCardList";
-
-<DocCardList />

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

@@ -1,31 +0,0 @@
----
-sidebar_position: 6
----
-
-import DocCardList from "@theme/DocCardList";
-
-# Evaluation
-
-Building applications with language models involves many moving parts. One of the most critical components is ensuring that the outcomes produced by your models are reliable and useful across a broad array of inputs, and that they work well with your application's other software components. Ensuring reliability usually boils down to some combination of application design, testing & evaluation, and runtime checks. 
-
-The guides in this section review the APIs and functionality LangChain provides to help yous better evaluate your applications. Evaluation and testing are both critical when thinking about deploying LLM applications, since production environments require repeatable and useful outcomes.
-
-LangChain offers various types of evaluators to help you measure performance and integrity on diverse data, and we hope to encourage the the community to create and share other useful evaluators so everyone can improve. These docs will introduce the evaluator types, how to use them, and provide some examples of their use in real-world scenarios.
-
-Each evaluator type in LangChain comes with ready-to-use implementations and an extensible API that allows for customization according to your unique requirements. Here are some of the types of evaluators we offer:
-
-- [String Evaluators](/docs/guides/evaluation/string/): These evaluators assess the predicted string for a given input, usually comparing it against a reference string.
-- [Trajectory Evaluators](/docs/guides/evaluation/trajectory/): These are used to evaluate the entire trajectory of agent actions.
-- [Comparison Evaluators](/docs/guides/evaluation/comparison/): These evaluators are designed to compare predictions from two runs on a common input.
-
-These evaluators can be used across various scenarios and can be applied to different chain and LLM implementations in the LangChain library.
-
-We also are working to share guides and cookbooks that demonstrate how to use these evaluators in real-world scenarios, such as:
-
-- [Chain Comparisons](/docs/guides/evaluation/examples/comparisons): This example uses a comparison evaluator to predict the preferred output. It reviews ways to measure confidence intervals to select statistically significant differences in aggregate preference scores across different models or prompts.
-
-## Reference Docs
-
-For detailed information on the available evaluators, including how to instantiate, configure, and customize them, check out the [reference documentation](https://api.python.langchain.com/en/latest/api_reference.html#module-langchain.evaluation) directly.
-
-<DocCardList />

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

@@ -1,27 +0,0 @@
----
-sidebar_position: 2 
----
-# String Evaluators
-
-A string evaluator is a component within LangChain designed to assess the performance of a language model by comparing its generated outputs (predictions) to a reference string or an input. This comparison is a crucial step in the evaluation of language models, providing a measure of the accuracy or quality of the generated text.
-
-In practice, string evaluators are typically used to evaluate a predicted string against a given input, such as a question or a prompt. Often, a reference label or context string is provided to define what a correct or ideal response would look like. These evaluators can be customized to tailor the evaluation process to fit your application's specific requirements.
-
-To create a custom string evaluator, inherit from the `StringEvaluator` class and implement the `_evaluate_strings` method. If you require asynchronous support, also implement the `_aevaluate_strings` method.
-
-Here's a summary of the key attributes and methods associated with a string evaluator:
-
-- `evaluation_name`: Specifies the name of the evaluation.
-- `requires_input`: Boolean attribute that indicates whether the evaluator requires an input string. If True, the evaluator will raise an error when the input isn't provided. If False, a warning will be logged if an input _is_ provided, indicating that it will not be considered in the evaluation.
-- `requires_reference`: Boolean attribute specifying whether the evaluator requires a reference label. If True, the evaluator will raise an error when the reference isn't provided. If False, a warning will be logged if a reference _is_ provided, indicating that it will not be considered in the evaluation.
-
-String evaluators also implement the following methods:
-
-- `aevaluate_strings`: Asynchronously evaluates the output of the Chain or Language Model, with support for optional input and label.
-- `evaluate_strings`: Synchronously evaluates the output of the Chain or Language Model, with support for optional input and label.
-
-The following sections provide detailed information on available string evaluator implementations as well as how to create a custom string evaluator.
-
-import DocCardList from "@theme/DocCardList";
-
-<DocCardList />

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

@@ -1,28 +0,0 @@
----
-sidebar_position: 4
----
-# Trajectory Evaluators
-
-Trajectory Evaluators in LangChain provide a more holistic approach to evaluating an agent. These evaluators assess the full sequence of actions taken by an agent and their corresponding responses, which we refer to as the "trajectory". This allows you to better measure an agent's effectiveness and capabilities.
-
-A Trajectory Evaluator implements the `AgentTrajectoryEvaluator` interface, which requires two main methods:
-
-- `evaluate_agent_trajectory`: This method synchronously evaluates an agent's trajectory.
-- `aevaluate_agent_trajectory`: This asynchronous counterpart allows evaluations to be run in parallel for efficiency.
-
-Both methods accept three main parameters:
-
-- `input`: The initial input given to the agent.
-- `prediction`: The final predicted response from the agent.
-- `agent_trajectory`: The intermediate steps taken by the agent, given as a list of tuples.
-
-These methods return a dictionary. It is recommended that custom implementations return a `score` (a float indicating the effectiveness of the agent) and `reasoning` (a string explaining the reasoning behind the score).
-
-You can capture an agent's trajectory by initializing the agent with the `return_intermediate_steps=True` parameter. This lets you collect all intermediate steps without relying on special callbacks.
-
-For a deeper dive into the implementation and use of Trajectory Evaluators, refer to the sections below.
-
-import DocCardList from "@theme/DocCardList";
-
-<DocCardList />
-

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

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

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

@@ -1,12 +0,0 @@
-# LangSmith
-
-import DocCardList from "@theme/DocCardList";
-
-LangSmith helps you trace and evaluate your language model applications and intelligent agents to help you
-move from prototype to production.
-
-Check out the [interactive walkthrough](walkthrough) below to get started.
-
-For more information, please refer to the [LangSmith documentation](https://docs.smith.langchain.com/)
-
-<DocCardList />

docs/docs_skeleton/docs/guides/safety/constitutional_chain.mdx

@@ -1,7 +0,0 @@
-# Self-critique chain with constitutional AI
-The ConstitutionalChain is a chain that ensures the output of a language model adheres to a predefined set of constitutional principles. By incorporating specific rules and guidelines, the ConstitutionalChain filters and modifies the generated content to align with these principles, thus providing more controlled, ethical, and contextually appropriate responses. This mechanism helps maintain the integrity of the output while minimizing the risk of generating content that may violate guidelines, be offensive, or deviate from the desired context.
-
-
-import Example from "@snippets/modules/chains/additional/constitutional_chain.mdx"
-
-<Example/>

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

@@ -1,6 +0,0 @@
-# Preventing harmful outputs
-
-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.

docs/docs_skeleton/docs/guides/safety/moderation.mdx

@@ -1,8 +0,0 @@
-# Moderation
-This notebook walks through examples of how to use a moderation chain, and several common ways for doing so. Moderation chains are useful for detecting text that could be hateful, violent, etc. This can be useful to apply on both user input, but also on the output of a Language Model. Some API providers, like OpenAI, [specifically prohibit](https://beta.openai.com/docs/usage-policies/use-case-policy) you, or your end users, from generating some types of harmful content. To comply with this (and to just generally prevent your application from being harmful) you may often want to append a moderation chain to any LLMChains, in order to make sure any output the LLM generates is not harmful.
-
-If the content passed into the moderation chain is harmful, there is not one best way to handle it, it probably depends on your application. Sometimes you may want to throw an error in the Chain (and have your application handle that). Other times, you may want to return something to the user explaining that the text was harmful. There could even be other ways to handle it! We will cover all these ways in this walkthrough.
-
-import Example from "@snippets/modules/chains/additional/moderation.mdx"
-
-<Example/>

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

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

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

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

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

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

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

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

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

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

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

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

docs/docs_skeleton/docs/modules/agents/how_to/_category_.yml

@@ -1,2 +0,0 @@
-label: 'How-to'
-position: 1