test

Refactored `requests.py`. The same as
https://github.com/langchain-ai/langchain/pull/7961 #8098 #8099
requests.py is in the root code folder. This creates the
`langchain.requests: Requests` group on the API Reference navigation
ToC, on the same level as Chains and Agents which is incorrect.

Refactoring:

- copied requests.py content into utils/requests.py
- I added the backwards compatibility ref in the original requests.py. 
- updated imports to requests objects

@hwchase17, @baskaryan

.devcontainer/Dockerfile

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

@@ -0,0 +1,37 @@
+# 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/hwchase17/langchain)
+
+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:
+
+   - 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,24 +1,26 @@
 // 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-dockerfile
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose
 {
-	"dockerComposeFile": "./docker-compose.yaml",
-	"service": "langchain",
-	"workspaceFolder": "/workspaces/langchain",
+	// Name for the dev container
 	"name": "langchain",
-	"customizations": {
-		"vscode": {
-			"extensions": [   
-				"ms-python.python"
-			],
-			"settings": {
-				"python.defaultInterpreterPath": "/home/vscode/langchain-py-env/bin/python3.11"
-			}
-		}
-		
-	},
 
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	"features": {},
+	// 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",
+
+	// 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": {}
+	// }
 
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	// "forwardPorts": [],
@@ -26,8 +28,9 @@
 	// Uncomment the next line to run commands after the container is created.
 	// "postCreateCommand": "cat /etc/os-release",
 
-	// 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
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
 }

.devcontainer/docker-compose.yaml

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

.gitattributes

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

.github/CONTRIBUTING.md

@@ -59,6 +59,8 @@ 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:
@@ -67,6 +69,14 @@ 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
@@ -93,6 +103,14 @@ 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/).
@@ -103,8 +121,42 @@ 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.
@@ -204,32 +256,43 @@ 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
 
-Docs are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
+The docs directory contains Documentation and API Reference.
 
+Documentation is built using [Docusaurus 2](https://docusaurus.io/).
+
+API Reference are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
 For that reason, we ask that you add good documentation to all classes and methods.
 
 Similar to linting, we recognize documentation can be annoying. If you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
 
 ### Build Documentation Locally
 
+In the following commands, the prefix `api_` indicates that those are operations for the API Reference.
+
 Before building the documentation, it is always a good idea to clean the build directory:
 
 ```bash
 make docs_clean
+make api_docs_clean
 ```
 
-Next, you can run the linkchecker to make sure all links are valid:
-
-```bash
-make docs_linkcheck
-```
-
-Finally, you can build the documentation as outlined below:
+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:
+
+```bash
+make docs_linkcheck
+make api_docs_linkcheck
 ```
 
 ## 🏭 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,56 +1,28 @@
-# Your PR Title (What it does)
+<!-- 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.
 
-<!-- Remove if not applicable -->
+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
 
-Fixes # (issue)
+If no one reviews your PR within a few days, feel free to @-mention the same people again.
 
-## 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?
-
-Community members can review the PR once tests pass. 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,11 +52,13 @@ 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

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

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

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

.github/workflows/langchain_ci.yml

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

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

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

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

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

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

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

@@ -1,49 +0,0 @@
-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,6 +73,7 @@ instance/
 
 # Sphinx documentation
 docs/_build/
+docs/docs/_build/
 
 # PyBuilder
 target/
@@ -149,4 +150,23 @@ wandb/
 
 # integration test artifacts
 data_map*
-\[('_type', 'fake'), ('stop', None)]
+\[('_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/_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

.gitmodules

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

.readthedocs.yaml

@@ -9,10 +9,13 @@ 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/conf.py
+   configuration: docs/api_reference/conf.py
 
 # If using Sphinx, optionally build your docs in additional formats such as PDF
 # formats:
@@ -21,6 +24,6 @@ sphinx:
 # Optionally declare the Python requirements required to build your docs
 python:
    install:
-   - requirements: docs/requirements.txt
+   - requirements: docs/api_reference/requirements.txt
    - method: pip
-     path: .
+     path: .

MIGRATE.md

@@ -0,0 +1,57 @@
+# 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`
+
+## `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,57 +1,45 @@
-.PHONY: all clean format lint test tests test_watch integration_tests docker_tests help extended_tests
+.PHONY: all clean docs_build docs_clean docs_linkcheck api_docs_build api_docs_clean api_docs_linkcheck
 
+# 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
 
-clean: docs_clean
+######################
+# DOCUMENTATION
+######################
+
+clean: docs_clean api_docs_clean
+
 
 docs_build:
-	cd docs && poetry run make html
+	docs/.local_build.sh
 
 docs_clean:
-	cd docs && poetry run make clean
+	rm -r docs/_dist
 
 docs_linkcheck:
-	poetry run linkchecker docs/_build/html/index.html
+	poetry run linkchecker docs/_dist/docs_skeleton/ --ignore-url node_modules
 
-format:
-	poetry run black .
-	poetry run ruff --select I --fix .
+api_docs_build:
+	poetry run python docs/api_reference/create_api_rst.py
+	cd docs/api_reference && poetry run make html
 
-PYTHON_FILES=.
-lint: PYTHON_FILES=.
-lint_diff: PYTHON_FILES=$(shell git diff --name-only --diff-filter=d master | grep -E '\.py$$')
+api_docs_clean:
+	rm -f docs/api_reference/api_reference.rst
+	cd docs/api_reference && poetry run make clean
 
-lint lint_diff:
-	poetry run mypy $(PYTHON_FILES)
-	poetry run black $(PYTHON_FILES) --check
-	poetry run ruff .
+api_docs_linkcheck:
+	poetry run linkchecker docs/api_reference/_build/html/index.html
 
-TEST_FILE ?= tests/unit_tests/
+spell_check:
+	poetry run codespell --toml pyproject.toml
 
-test:
-	poetry run pytest --disable-socket --allow-unix-socket $(TEST_FILE)
+spell_fix:
+	poetry run codespell --toml pyproject.toml -w
 
-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
+######################
 
 help:
 	@echo '----'
@@ -59,12 +47,3 @@ help:
 	@echo 'docs_build                   - build the documentation'
 	@echo 'docs_clean                   - clean the documentation build artifacts'
 	@echo 'docs_linkcheck               - run linkchecker on the documentation'
-	@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

@@ -2,9 +2,9 @@
 
 ⚡ Building applications with LLMs through composability ⚡
 
-[![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)
+[![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)
 [![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,6 +12,8 @@
 [![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/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).
@@ -19,11 +21,19 @@ Looking for the JS/TS version? Check out [LangChain.js](https://github.com/hwcha
 **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.
 
+## 🚨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).
+
 ## Quick Install
 
 `pip install langchain`
 or
-`conda install langchain -c conda-forge`
+`pip install langsmith && conda install langchain -c conda-forge`
 
 ## 🤔 What is this?
 
@@ -33,22 +43,22 @@ This library aims to assist in the development of those types of applications. C
 
 **❓ Question Answering over specific documents**
 
-- [Documentation](https://langchain.readthedocs.io/en/latest/use_cases/question_answering.html)
+- [Documentation](https://python.langchain.com/docs/use_cases/question_answering/)
 - End-to-end Example: [Question Answering over Notion Database](https://github.com/hwchase17/notion-qa)
 
 **💬 Chatbots**
 
-- [Documentation](https://langchain.readthedocs.io/en/latest/use_cases/chatbots.html)
+- [Documentation](https://python.langchain.com/docs/use_cases/chatbots/)
 - End-to-end Example: [Chat-LangChain](https://github.com/hwchase17/chat-langchain)
 
 **🤖 Agents**
 
-- [Documentation](https://langchain.readthedocs.io/en/latest/modules/agents.html)
+- [Documentation](https://python.langchain.com/docs/modules/agents/)
 - End-to-end Example: [GPT+WolframAlpha](https://huggingface.co/spaces/JavaFXpert/Chat-GPT-LangChain)
 
 ## 📖 Documentation
 
-Please see [here](https://langchain.readthedocs.io/en/latest/?) for full documentation on:
+Please see [here](https://python.langchain.com) for full documentation on:
 
 - Getting started (installation, setting up the environment, simple examples)
 - How-To examples (demos, integrations, helper functions)
@@ -84,7 +94,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://langchain.readthedocs.io/en/latest/).
+For more information on these concepts, please see our [full documentation](https://python.langchain.com).
 
 ## 💁 Contributing
 

docs/.local_build.sh

@@ -0,0 +1,17 @@
+#!/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
+yarn install
+yarn start

docs/additional_resources/tracing.md

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

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

@@ -0,0 +1,125 @@
+"""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
+
+import toml
+
+sys.path.insert(0, os.path.abspath("."))
+sys.path.insert(0, os.path.abspath("../../libs/langchain"))
+
+with open("../../libs/langchain/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",
+    "sphinx_copybutton",
+    "sphinx_panels",
+    "IPython.sphinxext.ipython_console_highlighting",
+]
+source_suffix = [".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_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_default_options = {
+    "members": True,
+    "show-inheritance": True,
+    "inherited-members": "BaseModel",
+    "undoc-members": True,
+    "special-members": "__call__",
+}
+# 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

@@ -0,0 +1,96 @@
+"""Script for auto-generating api_reference.rst"""
+import glob
+import re
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).parents[2].absolute()
+PKG_DIR = ROOT_DIR / "libs" / "langchain" / "langchain"
+WRITE_FILE = Path(__file__).parent / "api_reference.rst"
+
+
+def load_members() -> dict:
+    members: dict = {}
+    for py in glob.glob(str(PKG_DIR) + "/**/*.py", recursive=True):
+        module = py[len(str(PKG_DIR)) + 1 :].replace(".py", "").replace("/", ".")
+        top_level = module.split(".")[0]
+        if top_level not in members:
+            members[top_level] = {"classes": [], "functions": []}
+        with open(py, "r") as f:
+            for line in f.readlines():
+                cls = re.findall(r"^class ([^_].*)\(", line)
+                members[top_level]["classes"].extend([module + "." + c for c in cls])
+                func = re.findall(r"^def ([^_].*)\(", line)
+                afunc = re.findall(r"^async def ([^_].*)\(", line)
+                func_strings = [module + "." + f for f in func + afunc]
+                members[top_level]["functions"].extend(func_strings)
+    return members
+
+
+def construct_doc(members: dict) -> str:
+    full_doc = """\
+.. _api_reference:
+
+=============
+API Reference
+=============
+
+"""
+    for module, _members in sorted(members.items(), key=lambda kv: kv[0]):
+        classes = _members["classes"]
+        functions = _members["functions"]
+        if not (classes or functions):
+            continue
+
+        module_title = module.replace("_", " ").title()
+        if module_title == "Llms":
+            module_title = "LLMs"
+        section = f":mod:`langchain.{module}`: {module_title}"
+        full_doc += f"""\
+{section}
+{'=' * (len(section) + 1)}
+
+.. automodule:: langchain.{module}
+    :no-members:
+    :no-inherited-members:
+
+"""
+
+        if classes:
+            cstring = "\n    ".join(sorted(classes))
+            full_doc += f"""\
+Classes
+--------------
+.. currentmodule:: langchain
+
+.. autosummary::
+    :toctree: {module}
+    :template: class.rst
+
+    {cstring}
+
+"""
+        if functions:
+            fstring = "\n    ".join(sorted(functions))
+            full_doc += f"""\
+Functions
+--------------
+.. currentmodule:: langchain
+
+.. autosummary::
+    :toctree: {module}
+
+    {fstring}
+
+"""
+    return full_doc
+
+
+def main() -> None:
+    members = load_members()
+    full_doc = construct_doc(members)
+    with open(WRITE_FILE, "w") as f:
+        f.write(full_doc)
+
+
+if __name__ == "__main__":
+    main()

docs/api_reference/index.rst

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

docs/api_reference/modules/evaluation.rst

@@ -0,0 +1,9 @@
+Evaluation
+=======================
+
+LangChain has a number of convenient evaluation chains you can use off the shelf to grade your models' oupputs.
+
+.. automodule:: langchain.evaluation
+   :members:
+   :undoc-members:
+   :inherited-members:

docs/api_reference/requirements.txt

@@ -1,13 +1,13 @@
+-e libs/langchain
 autodoc_pydantic==1.8.0
 myst_parser
 nbsphinx==0.8.9
 sphinx==4.5.0
 sphinx-autobuild==2021.3.14
-sphinx_book_theme
 sphinx_rtd_theme==1.0.0
 sphinx-typlog-theme==0.8.0
 sphinx-panels
 toml
 myst_nb
 sphinx_copybutton
-pydata-sphinx-theme==0.13.1
+pydata-sphinx-theme==0.13.1

docs/api_reference/templates/COPYRIGHT.txt

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

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

docs/api_reference/templates/redirects.html

@@ -0,0 +1,15 @@
+{% 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/themes/COPYRIGHT.txt

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

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

@@ -0,0 +1,142 @@
+{# 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="http://scikit-learn.org/stable/{{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

@@ -0,0 +1,69 @@
+{%- 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 %}
+
+{% if theme_link_to_live_contributing_page|tobool %}
+{# Link to development page for live builds #}
+  {%- set development_link = "https://scikit-learn.org/dev/developers/index.html" %}
+{# Open on a new development page in new window/tab for live builds #}
+  {%- set development_attrs = 'target="_blank" rel="noopener noreferrer"' %}
+{%- else %}
+  {%- set development_link = pathto('developers/index') %}
+  {%- set development_attrs = '' %}
+{%- 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" 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

@@ -0,0 +1,16 @@
+{%- 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

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

docs/conf.py

@@ -1,112 +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 --------------------------------------------------------------
-
-# 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

@@ -1,192 +0,0 @@
-# Dependents
-
-Dependents stats for `hwchase17/langchain`
-
-[![](https://img.shields.io/static/v1?label=Used%20by&message=5152&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-[![](https://img.shields.io/static/v1?label=Used%20by%20(public)&message=172&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-[![](https://img.shields.io/static/v1?label=Used%20by%20(private)&message=4980&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-[![](https://img.shields.io/static/v1?label=Used%20by%20(stars)&message=17239&color=informational&logo=slickpic)](https://github.com/hwchase17/langchain/network/dependents)
-
-[update: 2023-05-17; only dependent repositories with Stars > 100]
-
-
-| Repository | Stars  |
-| :--------  | -----: |
-|[openai/openai-cookbook](https://github.com/openai/openai-cookbook) | 35401 |
-|[LAION-AI/Open-Assistant](https://github.com/LAION-AI/Open-Assistant) | 32861 |
-|[microsoft/TaskMatrix](https://github.com/microsoft/TaskMatrix) | 32766 |
-|[hpcaitech/ColossalAI](https://github.com/hpcaitech/ColossalAI) | 29560 |
-|[reworkd/AgentGPT](https://github.com/reworkd/AgentGPT) | 22315 |
-|[imartinez/privateGPT](https://github.com/imartinez/privateGPT) | 17474 |
-|[openai/chatgpt-retrieval-plugin](https://github.com/openai/chatgpt-retrieval-plugin) | 16923 |
-|[mindsdb/mindsdb](https://github.com/mindsdb/mindsdb) | 16112 |
-|[jerryjliu/llama_index](https://github.com/jerryjliu/llama_index) | 15407 |
-|[mlflow/mlflow](https://github.com/mlflow/mlflow) | 14345 |
-|[GaiZhenbiao/ChuanhuChatGPT](https://github.com/GaiZhenbiao/ChuanhuChatGPT) | 10372 |
-|[databrickslabs/dolly](https://github.com/databrickslabs/dolly) | 9919 |
-|[AIGC-Audio/AudioGPT](https://github.com/AIGC-Audio/AudioGPT) | 8177 |
-|[logspace-ai/langflow](https://github.com/logspace-ai/langflow) | 6807 |
-|[imClumsyPanda/langchain-ChatGLM](https://github.com/imClumsyPanda/langchain-ChatGLM) | 6087 |
-|[arc53/DocsGPT](https://github.com/arc53/DocsGPT) | 5292 |
-|[e2b-dev/e2b](https://github.com/e2b-dev/e2b) | 4622 |
-|[nsarrazin/serge](https://github.com/nsarrazin/serge) | 4076 |
-|[madawei2699/myGPTReader](https://github.com/madawei2699/myGPTReader) | 3952 |
-|[zauberzeug/nicegui](https://github.com/zauberzeug/nicegui) | 3952 |
-|[go-skynet/LocalAI](https://github.com/go-skynet/LocalAI) | 3762 |
-|[GreyDGL/PentestGPT](https://github.com/GreyDGL/PentestGPT) | 3388 |
-|[mmabrouk/chatgpt-wrapper](https://github.com/mmabrouk/chatgpt-wrapper) | 3243 |
-|[zilliztech/GPTCache](https://github.com/zilliztech/GPTCache) | 3189 |
-|[wenda-LLM/wenda](https://github.com/wenda-LLM/wenda) | 3050 |
-|[marqo-ai/marqo](https://github.com/marqo-ai/marqo) | 2930 |
-|[gkamradt/langchain-tutorials](https://github.com/gkamradt/langchain-tutorials) | 2710 |
-|[PrefectHQ/marvin](https://github.com/PrefectHQ/marvin) | 2545 |
-|[project-baize/baize-chatbot](https://github.com/project-baize/baize-chatbot) | 2479 |
-|[whitead/paper-qa](https://github.com/whitead/paper-qa) | 2399 |
-|[langgenius/dify](https://github.com/langgenius/dify) | 2344 |
-|[GerevAI/gerev](https://github.com/GerevAI/gerev) | 2283 |
-|[hwchase17/chat-langchain](https://github.com/hwchase17/chat-langchain) | 2266 |
-|[guangzhengli/ChatFiles](https://github.com/guangzhengli/ChatFiles) | 1903 |
-|[Azure-Samples/azure-search-openai-demo](https://github.com/Azure-Samples/azure-search-openai-demo) | 1884 |
-|[OpenBMB/BMTools](https://github.com/OpenBMB/BMTools) | 1860 |
-|[Farama-Foundation/PettingZoo](https://github.com/Farama-Foundation/PettingZoo) | 1813 |
-|[OpenGVLab/Ask-Anything](https://github.com/OpenGVLab/Ask-Anything) | 1571 |
-|[IntelligenzaArtificiale/Free-Auto-GPT](https://github.com/IntelligenzaArtificiale/Free-Auto-GPT) | 1480 |
-|[hwchase17/notion-qa](https://github.com/hwchase17/notion-qa) | 1464 |
-|[NVIDIA/NeMo-Guardrails](https://github.com/NVIDIA/NeMo-Guardrails) | 1419 |
-|[Unstructured-IO/unstructured](https://github.com/Unstructured-IO/unstructured) | 1410 |
-|[Kav-K/GPTDiscord](https://github.com/Kav-K/GPTDiscord) | 1363 |
-|[paulpierre/RasaGPT](https://github.com/paulpierre/RasaGPT) | 1344 |
-|[StanGirard/quivr](https://github.com/StanGirard/quivr) | 1330 |
-|[lunasec-io/lunasec](https://github.com/lunasec-io/lunasec) | 1318 |
-|[vocodedev/vocode-python](https://github.com/vocodedev/vocode-python) | 1286 |
-|[agiresearch/OpenAGI](https://github.com/agiresearch/OpenAGI) | 1156 |
-|[h2oai/h2ogpt](https://github.com/h2oai/h2ogpt) | 1141 |
-|[jina-ai/thinkgpt](https://github.com/jina-ai/thinkgpt) | 1106 |
-|[yanqiangmiffy/Chinese-LangChain](https://github.com/yanqiangmiffy/Chinese-LangChain) | 1072 |
-|[ttengwang/Caption-Anything](https://github.com/ttengwang/Caption-Anything) | 1064 |
-|[jina-ai/dev-gpt](https://github.com/jina-ai/dev-gpt) | 1057 |
-|[juncongmoo/chatllama](https://github.com/juncongmoo/chatllama) | 1003 |
-|[greshake/llm-security](https://github.com/greshake/llm-security) | 1002 |
-|[visual-openllm/visual-openllm](https://github.com/visual-openllm/visual-openllm) | 957 |
-|[richardyc/Chrome-GPT](https://github.com/richardyc/Chrome-GPT) | 918 |
-|[irgolic/AutoPR](https://github.com/irgolic/AutoPR) | 886 |
-|[mmz-001/knowledge_gpt](https://github.com/mmz-001/knowledge_gpt) | 867 |
-|[thomas-yanxin/LangChain-ChatGLM-Webui](https://github.com/thomas-yanxin/LangChain-ChatGLM-Webui) | 850 |
-|[microsoft/X-Decoder](https://github.com/microsoft/X-Decoder) | 837 |
-|[peterw/Chat-with-Github-Repo](https://github.com/peterw/Chat-with-Github-Repo) | 826 |
-|[cirediatpl/FigmaChain](https://github.com/cirediatpl/FigmaChain) | 782 |
-|[hashintel/hash](https://github.com/hashintel/hash) | 778 |
-|[seanpixel/Teenage-AGI](https://github.com/seanpixel/Teenage-AGI) | 773 |
-|[jina-ai/langchain-serve](https://github.com/jina-ai/langchain-serve) | 738 |
-|[corca-ai/EVAL](https://github.com/corca-ai/EVAL) | 737 |
-|[ai-sidekick/sidekick](https://github.com/ai-sidekick/sidekick) | 717 |
-|[rlancemartin/auto-evaluator](https://github.com/rlancemartin/auto-evaluator) | 703 |
-|[poe-platform/api-bot-tutorial](https://github.com/poe-platform/api-bot-tutorial) | 689 |
-|[SamurAIGPT/Camel-AutoGPT](https://github.com/SamurAIGPT/Camel-AutoGPT) | 666 |
-|[eyurtsev/kor](https://github.com/eyurtsev/kor) | 608 |
-|[run-llama/llama-lab](https://github.com/run-llama/llama-lab) | 559 |
-|[namuan/dr-doc-search](https://github.com/namuan/dr-doc-search) | 544 |
-|[pieroit/cheshire-cat](https://github.com/pieroit/cheshire-cat) | 520 |
-|[griptape-ai/griptape](https://github.com/griptape-ai/griptape) | 514 |
-|[getmetal/motorhead](https://github.com/getmetal/motorhead) | 481 |
-|[hwchase17/chat-your-data](https://github.com/hwchase17/chat-your-data) | 462 |
-|[langchain-ai/langchain-aiplugin](https://github.com/langchain-ai/langchain-aiplugin) | 452 |
-|[jina-ai/agentchain](https://github.com/jina-ai/agentchain) | 439 |
-|[SamurAIGPT/ChatGPT-Developer-Plugins](https://github.com/SamurAIGPT/ChatGPT-Developer-Plugins) | 437 |
-|[alexanderatallah/window.ai](https://github.com/alexanderatallah/window.ai) | 433 |
-|[michaelthwan/searchGPT](https://github.com/michaelthwan/searchGPT) | 427 |
-|[mpaepper/content-chatbot](https://github.com/mpaepper/content-chatbot) | 425 |
-|[mckaywrigley/repo-chat](https://github.com/mckaywrigley/repo-chat) | 422 |
-|[whyiyhw/chatgpt-wechat](https://github.com/whyiyhw/chatgpt-wechat) | 421 |
-|[freddyaboulton/gradio-tools](https://github.com/freddyaboulton/gradio-tools) | 407 |
-|[jonra1993/fastapi-alembic-sqlmodel-async](https://github.com/jonra1993/fastapi-alembic-sqlmodel-async) | 395 |
-|[yeagerai/yeagerai-agent](https://github.com/yeagerai/yeagerai-agent) | 383 |
-|[akshata29/chatpdf](https://github.com/akshata29/chatpdf) | 374 |
-|[OpenGVLab/InternGPT](https://github.com/OpenGVLab/InternGPT) | 368 |
-|[ruoccofabrizio/azure-open-ai-embeddings-qna](https://github.com/ruoccofabrizio/azure-open-ai-embeddings-qna) | 358 |
-|[101dotxyz/GPTeam](https://github.com/101dotxyz/GPTeam) | 357 |
-|[mtenenholtz/chat-twitter](https://github.com/mtenenholtz/chat-twitter) | 354 |
-|[amosjyng/langchain-visualizer](https://github.com/amosjyng/langchain-visualizer) | 343 |
-|[msoedov/langcorn](https://github.com/msoedov/langcorn) | 334 |
-|[showlab/VLog](https://github.com/showlab/VLog) | 330 |
-|[continuum-llms/chatgpt-memory](https://github.com/continuum-llms/chatgpt-memory) | 324 |
-|[steamship-core/steamship-langchain](https://github.com/steamship-core/steamship-langchain) | 323 |
-|[daodao97/chatdoc](https://github.com/daodao97/chatdoc) | 320 |
-|[xuwenhao/geektime-ai-course](https://github.com/xuwenhao/geektime-ai-course) | 308 |
-|[StevenGrove/GPT4Tools](https://github.com/StevenGrove/GPT4Tools) | 301 |
-|[logan-markewich/llama_index_starter_pack](https://github.com/logan-markewich/llama_index_starter_pack) | 300 |
-|[andylokandy/gpt-4-search](https://github.com/andylokandy/gpt-4-search) | 299 |
-|[Anil-matcha/ChatPDF](https://github.com/Anil-matcha/ChatPDF) | 287 |
-|[itamargol/openai](https://github.com/itamargol/openai) | 273 |
-|[BlackHC/llm-strategy](https://github.com/BlackHC/llm-strategy) | 267 |
-|[momegas/megabots](https://github.com/momegas/megabots) | 259 |
-|[bborn/howdoi.ai](https://github.com/bborn/howdoi.ai) | 238 |
-|[Cheems-Seminar/grounded-segment-any-parts](https://github.com/Cheems-Seminar/grounded-segment-any-parts) | 232 |
-|[ur-whitelab/exmol](https://github.com/ur-whitelab/exmol) | 227 |
-|[sullivan-sean/chat-langchainjs](https://github.com/sullivan-sean/chat-langchainjs) | 227 |
-|[explosion/spacy-llm](https://github.com/explosion/spacy-llm) | 226 |
-|[recalign/RecAlign](https://github.com/recalign/RecAlign) | 218 |
-|[jupyterlab/jupyter-ai](https://github.com/jupyterlab/jupyter-ai) | 218 |
-|[alvarosevilla95/autolang](https://github.com/alvarosevilla95/autolang) | 215 |
-|[conceptofmind/toolformer](https://github.com/conceptofmind/toolformer) | 213 |
-|[MagnivOrg/prompt-layer-library](https://github.com/MagnivOrg/prompt-layer-library) | 209 |
-|[JohnSnowLabs/nlptest](https://github.com/JohnSnowLabs/nlptest) | 208 |
-|[airobotlab/KoChatGPT](https://github.com/airobotlab/KoChatGPT) | 197 |
-|[langchain-ai/auto-evaluator](https://github.com/langchain-ai/auto-evaluator) | 195 |
-|[yvann-hub/Robby-chatbot](https://github.com/yvann-hub/Robby-chatbot) | 195 |
-|[alejandro-ao/langchain-ask-pdf](https://github.com/alejandro-ao/langchain-ask-pdf) | 192 |
-|[daveebbelaar/langchain-experiments](https://github.com/daveebbelaar/langchain-experiments) | 189 |
-|[NimbleBoxAI/ChainFury](https://github.com/NimbleBoxAI/ChainFury) | 187 |
-|[kaleido-lab/dolphin](https://github.com/kaleido-lab/dolphin) | 184 |
-|[Anil-matcha/Website-to-Chatbot](https://github.com/Anil-matcha/Website-to-Chatbot) | 183 |
-|[plchld/InsightFlow](https://github.com/plchld/InsightFlow) | 180 |
-|[OpenBMB/AgentVerse](https://github.com/OpenBMB/AgentVerse) | 166 |
-|[benthecoder/ClassGPT](https://github.com/benthecoder/ClassGPT) | 166 |
-|[jbrukh/gpt-jargon](https://github.com/jbrukh/gpt-jargon) | 161 |
-|[hardbyte/qabot](https://github.com/hardbyte/qabot) | 160 |
-|[shaman-ai/agent-actors](https://github.com/shaman-ai/agent-actors) | 153 |
-|[radi-cho/datasetGPT](https://github.com/radi-cho/datasetGPT) | 153 |
-|[poe-platform/poe-protocol](https://github.com/poe-platform/poe-protocol) | 152 |
-|[paolorechia/learn-langchain](https://github.com/paolorechia/learn-langchain) | 149 |
-|[ajndkr/lanarky](https://github.com/ajndkr/lanarky) | 149 |
-|[fengyuli-dev/multimedia-gpt](https://github.com/fengyuli-dev/multimedia-gpt) | 147 |
-|[yasyf/compress-gpt](https://github.com/yasyf/compress-gpt) | 144 |
-|[homanp/superagent](https://github.com/homanp/superagent) | 143 |
-|[realminchoi/babyagi-ui](https://github.com/realminchoi/babyagi-ui) | 141 |
-|[ethanyanjiali/minChatGPT](https://github.com/ethanyanjiali/minChatGPT) | 141 |
-|[ccurme/yolopandas](https://github.com/ccurme/yolopandas) | 139 |
-|[hwchase17/langchain-streamlit-template](https://github.com/hwchase17/langchain-streamlit-template) | 138 |
-|[Jaseci-Labs/jaseci](https://github.com/Jaseci-Labs/jaseci) | 136 |
-|[hirokidaichi/wanna](https://github.com/hirokidaichi/wanna) | 135 |
-|[Haste171/langchain-chatbot](https://github.com/Haste171/langchain-chatbot) | 134 |
-|[jmpaz/promptlib](https://github.com/jmpaz/promptlib) | 130 |
-|[Klingefjord/chatgpt-telegram](https://github.com/Klingefjord/chatgpt-telegram) | 130 |
-|[filip-michalsky/SalesGPT](https://github.com/filip-michalsky/SalesGPT) | 128 |
-|[handrew/browserpilot](https://github.com/handrew/browserpilot) | 128 |
-|[shauryr/S2QA](https://github.com/shauryr/S2QA) | 127 |
-|[steamship-core/vercel-examples](https://github.com/steamship-core/vercel-examples) | 127 |
-|[yasyf/summ](https://github.com/yasyf/summ) | 127 |
-|[gia-guar/JARVIS-ChatGPT](https://github.com/gia-guar/JARVIS-ChatGPT) | 126 |
-|[jerlendds/osintbuddy](https://github.com/jerlendds/osintbuddy) | 125 |
-|[ibiscp/LLM-IMDB](https://github.com/ibiscp/LLM-IMDB) | 124 |
-|[Teahouse-Studios/akari-bot](https://github.com/Teahouse-Studios/akari-bot) | 124 |
-|[hwchase17/chroma-langchain](https://github.com/hwchase17/chroma-langchain) | 124 |
-|[menloparklab/langchain-cohere-qdrant-doc-retrieval](https://github.com/menloparklab/langchain-cohere-qdrant-doc-retrieval) | 123 |
-|[peterw/StoryStorm](https://github.com/peterw/StoryStorm) | 123 |
-|[chakkaradeep/pyCodeAGI](https://github.com/chakkaradeep/pyCodeAGI) | 123 |
-|[petehunt/langchain-github-bot](https://github.com/petehunt/langchain-github-bot) | 115 |
-|[su77ungr/CASALIOY](https://github.com/su77ungr/CASALIOY) | 113 |
-|[eunomia-bpf/GPTtrace](https://github.com/eunomia-bpf/GPTtrace) | 113 |
-|[zenml-io/zenml-projects](https://github.com/zenml-io/zenml-projects) | 112 |
-|[pablomarin/GPT-Azure-Search-Engine](https://github.com/pablomarin/GPT-Azure-Search-Engine) | 111 |
-|[shamspias/customizable-gpt-chatbot](https://github.com/shamspias/customizable-gpt-chatbot) | 109 |
-|[WongSaang/chatgpt-ui-server](https://github.com/WongSaang/chatgpt-ui-server) | 108 |
-|[davila7/file-gpt](https://github.com/davila7/file-gpt) | 104 |
-|[enhancedocs/enhancedocs](https://github.com/enhancedocs/enhancedocs) | 102 |
-|[aurelio-labs/arxiv-bot](https://github.com/aurelio-labs/arxiv-bot) | 101 |
-
-
-
-_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

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

docs/docs_skeleton/README.md

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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1,76 @@
+/* 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

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

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

docs/docs_skeleton/docs/get_started/introduction.mdx

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

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

@@ -0,0 +1,8 @@
+---
+sidebar_position: 3 
+---
+# Comparison Evaluators
+
+import DocCardList from "@theme/DocCardList";
+
+<DocCardList />

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

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

@@ -0,0 +1,28 @@
+---
+sidebar_position: 6
+---
+
+import DocCardList from "@theme/DocCardList";
+
+# Evaluation
+
+Language models can be unpredictable. This makes it challenging to ship reliable applications to production, where repeatable, useful outcomes across diverse inputs are a minimum requirement. Tests help demonstrate each component in an LLM application can produce the required or expected functionality. These tests also safeguard against regressions while you improve interconnected pieces of an integrated system. However, measuring the quality of generated text can be challenging. It can be hard to agree on the right set of metrics for your application, and it can be difficult to translate those into better performance. Furthermore, it's common to lack sufficient evaluation data to adequately test the range of inputs and expected outputs for each component when you're just getting started. The LangChain community is building open source tools and guides to help address these challenges.
+
+LangChain exposes different types of evaluators for common types of evaluation. Each type has off-the-shelf implementations you can use to get started, as well as an
+ extensible API so you can create your own or contribute improvements for everyone to use. The following sections have example notebooks for you to get started.
+
+- [String Evaluators](/docs/modules/evaluation/string/): Evaluate the predicted string for a given input, usually against a reference string
+- [Trajectory Evaluators](/docs/modules/evaluation/trajectory/): Evaluate the whole trajectory of agent actions
+- [Comparison Evaluators](/docs/modules/evaluation/comparison/): Compare predictions from two runs on a common input
+
+
+This section also provides some additional examples of how you could use these evaluators for different scenarios or apply to different chain implementations in the LangChain library. Some examples include:
+
+- [Preference Scoring Chain Outputs](/docs/modules/evaluation/examples/comparisons): An example using a comparison evaluator on different models or prompts to select statistically significant differences in aggregate preference scores
+
+
+## Reference Docs
+
+For detailed information of 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

@@ -0,0 +1,8 @@
+---
+sidebar_position: 2 
+---
+# String Evaluators
+
+import DocCardList from "@theme/DocCardList";
+
+<DocCardList />

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

@@ -0,0 +1,8 @@
+---
+sidebar_position: 4
+---
+# Trajectory Evaluators
+
+import DocCardList from "@theme/DocCardList";
+
+<DocCardList />

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

@@ -0,0 +1,12 @@
+# 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/modules/agents/agent_types/chat_conversation_agent.mdx

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

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

@@ -0,0 +1,11 @@
+# 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 to 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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+# Replicating MRKL
+
+This walkthrough demonstrates how to replicate the [MRKL](https://arxiv.org/pdf/2205.00445.pdf) system using agents.
+
+This uses the example Chinook database.
+To set it up follow the instructions on https://database.guide/2-sample-databases-sqlite/, placing the `.db` file in a notebooks folder at the root of this repository.
+
+import Example from "@snippets/modules/agents/how_to/mrkl.mdx"
+
+<Example/>
+
+## With a chat model
+
+import ChatExample from "@snippets/modules/agents/how_to/mrkl_chat.mdx"
+
+<ChatExample/>

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

@@ -0,0 +1,85 @@
+---
+sidebar_position: 4
+---
+# Agents
+
+The core idea of agents is to use an LLM to choose a sequence of actions to take.
+In chains, a sequence of actions is hardcoded (in code).
+In agents, a language model is used as a reasoning engine to determine which actions to take and in which order.
+
+There are several key components here:
+
+## Agent
+
+This is the class responsible for deciding what step to take next.
+This is powered by a language model and a prompt.
+This prompt can include things like:
+
+1. The personality of the agent (useful for having it respond in a certain way)
+2. Background context for the agent (useful for giving it more context on the types of tasks it's being asked to do)
+3. Prompting strategies to invoke better reasoning (the most famous/widely used being [ReAct](https://arxiv.org/abs/2210.03629))
+
+LangChain provides a few different types of agents to get started.
+Even then, you will likely want to customize those agents with parts (1) and (2).
+For a full list of agent types see [agent types](/docs/modules/agents/agent_types/)
+
+## Tools
+
+Tools are functions that an agent calls.
+There are two important considerations here:
+
+1. Giving the agent access to the right tools
+2. Describing the tools in a way that is most helpful to the agent
+
+Without both, the agent you are trying to build will not work.
+If you don't give the agent access to a correct set of tools, it will never be able to accomplish the objective.
+If you don't describe the tools properly, the agent won't know how to properly use them.
+
+LangChain provides a wide set of tools to get started, but also makes it easy to define your own (including custom descriptions).
+For a full list of tools, see [here](/docs/modules/agents/tools/)
+
+## Toolkits
+
+Often the set of tools an agent has access to is more important than a single tool.
+For this LangChain provides the concept of toolkits - groups of tools needed to accomplish specific objectives.
+There are generally around 3-5 tools in a toolkit.
+
+LangChain provides a wide set of toolkits to get started.
+For a full list of toolkits, see [here](/docs/modules/agents/toolkits/)
+
+## AgentExecutor
+
+The agent executor is the runtime for an agent.
+This is what actually calls the agent and executes the actions it chooses.
+Pseudocode for this runtime is below:
+
+```python
+next_action = agent.get_action(...)
+while next_action != AgentFinish:
+    observation = run(next_action)
+    next_action = agent.get_action(..., next_action, observation)
+return next_action
+```
+
+While this may seem simple, there are several complexities this runtime handles for you, including:
+
+1. Handling cases where the agent selects a non-existent tool
+2. Handling cases where the tool errors
+3. Handling cases where the agent produces output that cannot be parsed into a tool invocation
+4. Logging and observability at all levels (agent decisions, tool calls) either to stdout or [LangSmith](https://smith.langchain.com).
+
+## Other types of agent runtimes
+
+The `AgentExecutor` class is the main agent runtime supported by LangChain.
+However, there are other, more experimental runtimes we also support.
+These include:
+
+- [Plan-and-execute Agent](/docs/modules/agents/agent_types/plan_and_execute.html)
+- [Baby AGI](/docs/use_cases/autonomous_agents/baby_agi.html)
+- [Auto GPT](/docs/use_cases/autonomous_agents/autogpt.html)
+
+## Get started
+
+import GetStarted from "@snippets/modules/agents/get_started.mdx"
+
+<GetStarted/>

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

@@ -0,0 +1,10 @@
+---
+sidebar_position: 3
+---
+# Toolkits
+
+:::info
+Head to [Integrations](/docs/integrations/toolkits/) for documentation on built-in toolkit integrations.
+:::
+
+Toolkits are collections of tools that are designed to be used together for specific tasks and have convenience loading methods.

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

@@ -0,0 +1,21 @@
+---
+sidebar_position: 2
+---
+# Tools
+
+:::info
+Head to [Integrations](/docs/integrations/tools/) for documentation on built-in tool integrations.
+:::
+
+Tools are interfaces that an agent can use to interact with the world.
+
+## Get started
+
+Tools are functions that agents can use to interact with the world.
+These tools can be generic utilities (e.g. search), other chains, or even other agents.
+
+Currently, tools can be loaded with the following snippet:
+
+import GetStarted from "@snippets/modules/agents/tools/get_started.mdx"
+
+<GetStarted/>

docs/docs_skeleton/docs/modules/callbacks/index.mdx

@@ -0,0 +1,14 @@
+---
+sidebar_position: 5
+---
+# Callbacks
+
+:::info
+Head to [Integrations](/docs/integrations/callbacks/) for documentation on built-in callbacks integrations with 3rd-party tools.
+:::
+
+LangChain provides a callbacks system that allows you to hook into the various stages of your LLM application. This is useful for logging, monitoring, streaming, and other tasks.
+
+import GetStarted from "@snippets/modules/callbacks/get_started.mdx"
+
+<GetStarted/>

docs/docs_skeleton/docs/modules/chains/additional/analyze_document.mdx

@@ -0,0 +1,7 @@
+# Analyze Document
+
+The AnalyzeDocumentChain can be used as an end-to-end to chain. This chain takes in a single document, splits it up, and then runs it through a CombineDocumentsChain.
+
+import Example from "@snippets/modules/chains/additional/analyze_document.mdx"
+
+<Example/>

docs/docs_skeleton/docs/modules/chains/additional/constitutional_chain.mdx

@@ -0,0 +1,7 @@
+# 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/modules/chains/additional/index.mdx

@@ -0,0 +1,8 @@
+---
+sidebar_position: 4
+---
+# Additional
+
+import DocCardList from "@theme/DocCardList";
+
+<DocCardList />

docs/docs_skeleton/docs/modules/chains/additional/moderation.mdx

@@ -0,0 +1,8 @@
+# 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/>