fmt

Description: Video imagery to text (Closed Captioning)
This pull request introduces the VideoCaptioningChain, a tool for
automated video captioning. It processes audio and video to generate
subtitles and closed captions, merging them into a single SRT output.

Issue: https://github.com/langchain-ai/langchain/issues/11770
Dependencies: opencv-python, ffmpeg-python, assemblyai, transformers,
pillow, torch, openai
Tag maintainer:
@baskaryan
@hwchase17


Hello!

We are a group of students from the University of Toronto
(@LunarECL, @TomSadan, @nicoledroi1, @A2113S) that want to make a
contribution to the LangChain community! We have ran make format, make
lint and make test locally before submitting the PR. To our knowledge,
our changes do not introduce any new errors.

Thank you for taking the time to review our PR!

---------

Co-authored-by: Bagatur <baskaryan@gmail.com>

.github/DISCUSSION_TEMPLATE/q-a.yml

@@ -3,18 +3,18 @@ body:
   - type: markdown
     attributes:
       value: |
-        Thanks for your interest in 🦜️🔗 LangChain!
+        Thanks for your interest in LangChain 🦜️🔗!
 
         Please follow these instructions, fill every question, and do every step. 🙏
         
         We're asking for this because answering questions and solving problems in GitHub takes a lot of time --
-        this is time that we cannot spend on adding new features, fixing bugs, write documentation or reviewing pull requests.
+        this is time that we cannot spend on adding new features, fixing bugs, writing documentation or reviewing pull requests.
 
-        By asking questions in a structured way (following this) it will be much easier to help you.
+        By asking questions in a structured way (following this) it will be much easier for us to help you.
 
-        And there's a high chance that you will find the solution along the way and you won't even have to submit it and wait for an answer. 😎
+        There's a high chance that by following this process, you'll find the solution on your own, eliminating the need to submit a question and wait for an answer. 😎
 
-        As there are too many questions, we will **DISCARD** and close the incomplete ones. 
+        As there are many questions submitted every day, we will **DISCARD** and close the incomplete ones. 
         
         That will allow us (and others) to focus on helping people like you that follow the whole process. 🤓
         

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -35,6 +35,8 @@ body:
           required: true
         - label: I am sure that this is a bug in LangChain rather than my code.
           required: true
+        - label: The bug is not resolved by updating to the latest stable version of LangChain (or the specific integration package).
+          required: true
   - type: textarea
     id: reproduction
     validations:

.github/ISSUE_TEMPLATE/privileged.yml

@@ -9,7 +9,7 @@ body:
         If you are not a LangChain maintainer or were not asked directly by a maintainer to create an issue, then please start the conversation in a [Question in GitHub Discussions](https://github.com/langchain-ai/langchain/discussions/categories/q-a) instead.
         
         You are a LangChain maintainer if you maintain any of the packages inside of the LangChain repository 
-        or are a regular contributor to LangChain with previous merged merged pull requests.
+        or are a regular contributor to LangChain with previous merged pull requests.
   - type: checkboxes
     id: privileged
     attributes:

.github/scripts/check_diff.py

@@ -1,17 +1,24 @@
 import json
 import sys
 import os
+from typing import Dict
 
-LANGCHAIN_DIRS = {
+LANGCHAIN_DIRS = [
     "libs/core",
+    "libs/text-splitters",
+    "libs/community",
     "libs/langchain",
     "libs/experimental",
-    "libs/community",
-}
+]
 
 if __name__ == "__main__":
     files = sys.argv[1:]
-    dirs_to_run = set()
+
+    dirs_to_run: Dict[str, set] = {
+        "lint": set(),
+        "test": set(),
+        "extended-test": set(),
+    }
 
     if len(files) == 300:
         # max diff length is 300 files - there are likely files missing
@@ -24,31 +31,49 @@ if __name__ == "__main__":
                 ".github/workflows",
                 ".github/tools",
                 ".github/actions",
-                "libs/core",
                 ".github/scripts/check_diff.py",
             )
         ):
-            dirs_to_run.update(LANGCHAIN_DIRS)
-        elif "libs/community" in file:
-            dirs_to_run.update(
-                ("libs/community", "libs/langchain", "libs/experimental")
-            )
-        elif "libs/partners" in file:
-            partner_dir = file.split("/")[2]
-            if os.path.isdir(f"libs/partners/{partner_dir}"):
-                dirs_to_run.add(f"libs/partners/{partner_dir}")
-            # Skip if the directory was deleted
-        elif "libs/langchain" in file:
-            dirs_to_run.update(("libs/langchain", "libs/experimental"))
-        elif "libs/experimental" in file:
-            dirs_to_run.add("libs/experimental")
-        elif file.startswith("libs/"):
-            dirs_to_run.update(LANGCHAIN_DIRS)
-        else:
-            pass
-    json_output = json.dumps(list(dirs_to_run))
-    print(f"dirs-to-run={json_output}")  # noqa: T201
+            # add all LANGCHAIN_DIRS for infra changes
+            dirs_to_run["extended-test"].update(LANGCHAIN_DIRS)
+            dirs_to_run["lint"].add(".")
 
-    extended_test_dirs = [d for d in dirs_to_run if not d.startswith("libs/partners")]
-    json_output_extended = json.dumps(extended_test_dirs)
-    print(f"dirs-to-run-extended={json_output_extended}")  # noqa: T201
+        if any(file.startswith(dir_) for dir_ in LANGCHAIN_DIRS):
+            # add that dir and all dirs after in LANGCHAIN_DIRS
+            # for extended testing
+            found = False
+            for dir_ in LANGCHAIN_DIRS:
+                if file.startswith(dir_):
+                    found = True
+                if found:
+                    dirs_to_run["extended-test"].add(dir_)
+        elif file.startswith("libs/cli"):
+            # todo: add cli makefile
+            pass
+        elif file.startswith("libs/partners"):
+            partner_dir = file.split("/")[2]
+            if os.path.isdir(f"libs/partners/{partner_dir}") and [
+                filename
+                for filename in os.listdir(f"libs/partners/{partner_dir}")
+                if not filename.startswith(".")
+            ] != ["README.md"]:
+                dirs_to_run["test"].add(f"libs/partners/{partner_dir}")
+            # Skip if the directory was deleted or is just a tombstone readme
+        elif file.startswith("libs/"):
+            raise ValueError(
+                f"Unknown lib: {file}. check_diff.py likely needs "
+                "an update for this new library!"
+            )
+        elif any(file.startswith(p) for p in ["docs/", "templates/", "cookbook/"]):
+            dirs_to_run["lint"].add(".")
+
+    outputs = {
+        "dirs-to-lint": list(
+            dirs_to_run["lint"] | dirs_to_run["test"] | dirs_to_run["extended-test"]
+        ),
+        "dirs-to-test": list(dirs_to_run["test"] | dirs_to_run["extended-test"]),
+        "dirs-to-extended-test": list(dirs_to_run["extended-test"]),
+    }
+    for key, value in outputs.items():
+        json_output = json.dumps(value)
+        print(f"{key}={json_output}")  # noqa: T201

.github/scripts/get_min_versions.py

@@ -4,7 +4,12 @@ import tomllib
 from packaging.version import parse as parse_version
 import re
 
-MIN_VERSION_LIBS = ["langchain-core", "langchain-community", "langchain"]
+MIN_VERSION_LIBS = [
+    "langchain-core",
+    "langchain-community",
+    "langchain",
+    "langchain-text-splitters",
+]
 
 
 def get_min_version(version: str) -> str:
@@ -56,12 +61,13 @@ def get_min_version_from_toml(toml_path: str):
     return min_versions
 
 
-# Get the TOML file path from the command line argument
-toml_file = sys.argv[1]
+if __name__ == "__main__":
+    # Get the TOML file path from the command line argument
+    toml_file = sys.argv[1]
 
-# Call the function to get the minimum versions
-min_versions = get_min_version_from_toml(toml_file)
+    # Call the function to get the minimum versions
+    min_versions = get_min_version_from_toml(toml_file)
 
-print(
-    " ".join([f"{lib}=={version}" for lib, version in min_versions.items()])
-)  # noqa: T201
+    print(
+        " ".join([f"{lib}=={version}" for lib, version in min_versions.items()])
+    )  # noqa: T201

.github/workflows/_dependencies.yml

@@ -63,6 +63,8 @@ jobs:
       - name: Install the opposite major version of pydantic
         # If normal tests use pydantic v1, here we'll use v2, and vice versa.
         shell: bash
+        # airbyte currently doesn't support pydantic v2
+        if: ${{ !startsWith(inputs.working-directory, 'libs/partners/airbyte') }}
         run: |
           # Determine the major part of pydantic version
           REGULAR_VERSION=$(poetry run python -c "import pydantic; print(pydantic.__version__)" | cut -d. -f1)
@@ -97,6 +99,8 @@ jobs:
           fi
           echo "Found pydantic version ${CURRENT_VERSION}, as expected"
       - name: Run pydantic compatibility tests
+        # airbyte currently doesn't support pydantic v2
+        if: ${{ !startsWith(inputs.working-directory, 'libs/partners/airbyte') }}
         shell: bash
         run: make test
 

.github/workflows/_integration_test.yml

@@ -70,6 +70,13 @@ jobs:
           ASTRA_DB_API_ENDPOINT: ${{ secrets.ASTRA_DB_API_ENDPOINT }}
           ASTRA_DB_APPLICATION_TOKEN: ${{ secrets.ASTRA_DB_APPLICATION_TOKEN }}
           ASTRA_DB_KEYSPACE: ${{ secrets.ASTRA_DB_KEYSPACE }}
+          ES_URL: ${{ secrets.ES_URL }}
+          ES_CLOUD_ID: ${{ secrets.ES_CLOUD_ID }}
+          ES_API_KEY: ${{ secrets.ES_API_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # for airbyte
+          MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
+          VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
+          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
         run: |
           make integration_tests
 

.github/workflows/_release.yml

@@ -55,7 +55,7 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -157,6 +157,24 @@ jobs:
         run: make tests
         working-directory: ${{ inputs.working-directory }}
 
+      - name: Get minimum versions
+        working-directory: ${{ inputs.working-directory }}
+        id: min-version
+        run: |
+          poetry run pip install packaging
+          min_versions="$(poetry run python $GITHUB_WORKSPACE/.github/scripts/get_min_versions.py pyproject.toml)"
+          echo "min-versions=$min_versions" >> "$GITHUB_OUTPUT"
+          echo "min-versions=$min_versions"
+
+      - name: Run unit tests with minimum dependency versions
+        if: ${{ steps.min-version.outputs.min-versions != '' }}
+        env:
+          MIN_VERSIONS: ${{ steps.min-version.outputs.min-versions }}
+        run: |
+          poetry run pip install $MIN_VERSIONS
+          make tests
+        working-directory: ${{ inputs.working-directory }}
+
       - name: 'Authenticate to Google Cloud'
         id: 'auth'
         uses: google-github-actions/auth@v2
@@ -191,27 +209,16 @@ jobs:
           ASTRA_DB_API_ENDPOINT: ${{ secrets.ASTRA_DB_API_ENDPOINT }}
           ASTRA_DB_APPLICATION_TOKEN: ${{ secrets.ASTRA_DB_APPLICATION_TOKEN }}
           ASTRA_DB_KEYSPACE: ${{ secrets.ASTRA_DB_KEYSPACE }}
+          ES_URL: ${{ secrets.ES_URL }}
+          ES_CLOUD_ID: ${{ secrets.ES_CLOUD_ID }}
+          ES_API_KEY: ${{ secrets.ES_API_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # for airbyte
+          MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
+          VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
+          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
         run: make integration_tests
         working-directory: ${{ inputs.working-directory }}
 
-      - name: Get minimum versions
-        working-directory: ${{ inputs.working-directory }}
-        id: min-version
-        run: |
-          poetry run pip install packaging
-          min_versions="$(poetry run python $GITHUB_WORKSPACE/.github/scripts/get_min_versions.py pyproject.toml)"
-          echo "min-versions=$min_versions" >> "$GITHUB_OUTPUT"
-          echo "min-versions=$min_versions"
-
-      - name: Run unit tests with minimum dependency versions
-        if: ${{ steps.min-version.outputs.min-versions != '' }}
-        env:
-          MIN_VERSIONS: ${{ steps.min-version.outputs.min-versions }}
-        run: |
-          poetry run pip install $MIN_VERSIONS
-          make tests
-        working-directory: ${{ inputs.working-directory }}
-
   publish:
     needs:
       - build
@@ -241,7 +248,7 @@ jobs:
           working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -280,7 +287,7 @@ jobs:
           working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/

.github/workflows/_test_doc_imports.yml

@@ -0,0 +1,50 @@
+name: test_doc_imports
+
+on:
+  workflow_call:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+    name: "check doc imports #${{ matrix.python-version }}"
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: core
+
+      - name: Install dependencies
+        shell: bash
+        run: poetry install --with test
+
+      - name: Install langchain editable
+        run: |
+          poetry run pip install -e libs/core libs/langchain libs/community libs/experimental
+
+      - name: Check doc imports
+        shell: bash
+        run: |
+          poetry run python docs/scripts/check_imports.py
+
+      - name: Ensure the test did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/_test_release.yml

@@ -48,7 +48,7 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/
@@ -76,7 +76,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/

.github/workflows/api_doc_build.yml

@@ -1,52 +0,0 @@
-name: API docs build
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron:  '0 13 * * *'
-env:
-  POETRY_VERSION: "1.7.1"
-  PYTHON_VERSION: "3.10"
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: bagatur/api_docs_build
-
-      - name: Set Git config
-        run: |
-          git config --local user.email "actions@github.com"
-          git config --local user.name "Github Actions"
-
-      - name: Merge master
-        run: | 
-          git fetch origin master
-          git merge origin/master -m "Merge master" --allow-unrelated-histories -X theirs
-
-      - name: Set up Python ${{ env.PYTHON_VERSION }} + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: api-docs
-
-      - name: Install dependencies
-        run: |
-          poetry run python -m pip install --upgrade --no-cache-dir pip setuptools
-          poetry run python -m pip install --upgrade --no-cache-dir sphinx readthedocs-sphinx-ext
-          poetry run python -m pip install ./libs/partners/*
-          poetry run python -m pip install --exists-action=w --no-cache-dir -r docs/api_reference/requirements.txt
-
-      - name: Build docs
-        run: |
-          poetry run python -m pip install --upgrade --no-cache-dir pip setuptools
-          poetry run python docs/api_reference/create_api_rst.py
-          poetry run python -m sphinx -T -E -b html -d _build/doctrees -c docs/api_reference docs/api_reference api_reference_build/html -j auto
-
-      # https://github.com/marketplace/actions/add-commit
-      - uses: EndBug/add-and-commit@v9
-        with:
-          message: 'Update API docs build'

.github/workflows/check-broken-links.yml

@@ -0,0 +1,24 @@
+name: Check Broken Links
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron:  '0 13 * * *'
+
+jobs:
+  check-links:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js 18.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+          cache: "yarn"
+          cache-dependency-path: ./docs/yarn.lock
+      - name: Install dependencies
+        run: yarn install --immutable --mode=skip-build
+        working-directory: ./docs
+      - name: Check broken links
+        run: yarn check-broken-links
+        working-directory: ./docs

.github/workflows/check_diffs.yml

@@ -33,14 +33,16 @@ jobs:
         run: |
           python .github/scripts/check_diff.py ${{ steps.files.outputs.all }} >> $GITHUB_OUTPUT
     outputs:
-      dirs-to-run: ${{ steps.set-matrix.outputs.dirs-to-run }}
-      dirs-to-run-extended: ${{ steps.set-matrix.outputs.dirs-to-run-extended }}
+      dirs-to-lint: ${{ steps.set-matrix.outputs.dirs-to-lint }}
+      dirs-to-test: ${{ steps.set-matrix.outputs.dirs-to-test }}
+      dirs-to-extended-test: ${{ steps.set-matrix.outputs.dirs-to-extended-test }}
   lint:
     name: cd ${{ matrix.working-directory }}
     needs: [ build ]
+    if: ${{ needs.build.outputs.dirs-to-lint != '[]' }}
     strategy:
       matrix:
-        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-run) }}
+        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-lint) }}
     uses: ./.github/workflows/_lint.yml
     with:
       working-directory: ${{ matrix.working-directory }}
@@ -49,20 +51,28 @@ jobs:
   test:
     name: cd ${{ matrix.working-directory }}
     needs: [ build ]
+    if: ${{ needs.build.outputs.dirs-to-test != '[]' }}
     strategy:
       matrix:
-        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-run) }}
+        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-test) }}
     uses: ./.github/workflows/_test.yml
     with:
       working-directory: ${{ matrix.working-directory }}
     secrets: inherit
 
+  test_doc_imports:
+    needs: [ build ]
+    if: ${{ needs.build.outputs.dirs-to-test != '[]' }}
+    uses: ./.github/workflows/_test_doc_imports.yml
+    secrets: inherit
+
   compile-integration-tests:
     name: cd ${{ matrix.working-directory }}
     needs: [ build ]
+    if: ${{ needs.build.outputs.dirs-to-test != '[]' }}
     strategy:
       matrix:
-        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-run) }}
+        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-test) }}
     uses: ./.github/workflows/_compile_integration_test.yml
     with:
       working-directory: ${{ matrix.working-directory }}
@@ -71,9 +81,10 @@ jobs:
   dependencies:
     name: cd ${{ matrix.working-directory }}
     needs: [ build ]
+    if: ${{ needs.build.outputs.dirs-to-test != '[]' }}
     strategy:
       matrix:
-        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-run) }}
+        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-test) }}
     uses: ./.github/workflows/_dependencies.yml
     with:
       working-directory: ${{ matrix.working-directory }}
@@ -82,10 +93,11 @@ jobs:
   extended-tests:
     name: "cd ${{ matrix.working-directory }} / make extended_tests #${{ matrix.python-version }}"
     needs: [ build ]
+    if: ${{ needs.build.outputs.dirs-to-extended-test != '[]' }}
     strategy:
       matrix:
         # note different variable for extended test dirs
-        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-run-extended) }}
+        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-extended-test) }}
         python-version:
           - "3.8"
           - "3.9"

.github/workflows/codespell.yml

@@ -32,6 +32,6 @@ jobs:
       - name: Codespell
         uses: codespell-project/actions-codespell@v2
         with:
-          skip: guide_imports.json,*.ambr
+          skip: guide_imports.json,*.ambr,./cookbook/data/imdb_top_1000.csv,*.lock
           ignore_words_list: ${{ steps.extract_ignore_words.outputs.ignore_words_list }}
           exclude_file: libs/community/langchain_community/llms/yuan2.py

.github/workflows/doc_lint.yml

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

.gitignore

@@ -115,13 +115,11 @@ celerybeat.pid
 # Environments
 .env
 .envrc
-.venv
-.venvs
+.venv*
+venv*
 env/
-venv/
 ENV/
 env.bak/
-venv.bak/
 
 # Spyder project settings
 .spyderproject

Makefile

@@ -1,44 +1,56 @@
-.PHONY: all clean docs_build docs_clean docs_linkcheck api_docs_build api_docs_clean api_docs_linkcheck
+.PHONY: all clean help docs_build docs_clean docs_linkcheck api_docs_build api_docs_clean api_docs_linkcheck spell_check spell_fix lint lint_package lint_tests format format_diff
 
-# Default target executed when no arguments are given to make.
+## help: Show this help info.
+help: Makefile
+	@printf "\n\033[1mUsage: make <TARGETS> ...\033[0m\n\n\033[1mTargets:\033[0m\n\n"
+	@sed -n 's/^##//p' $< | awk -F':' '{printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' | sort | sed -e 's/^/ /'
+
+## all: Default target, shows help.
 all: help
 
+## clean: Clean documentation and API documentation artifacts.
+clean: docs_clean api_docs_clean
 
 ######################
 # DOCUMENTATION
 ######################
 
-clean: docs_clean api_docs_clean
-
-
+## docs_build: Build the documentation.
 docs_build:
 	docs/.local_build.sh
 
+## docs_clean: Clean the documentation build artifacts.
 docs_clean:
 	@if [ -d _dist ]; then \
-			rm -r _dist; \
-			echo "Directory _dist has been cleaned."; \
+		rm -r _dist; \
+		echo "Directory _dist has been cleaned."; \
 	else \
-			echo "Nothing to clean."; \
+		echo "Nothing to clean."; \
 	fi
 
+## docs_linkcheck: Run linkchecker on the documentation.
 docs_linkcheck:
 	poetry run linkchecker _dist/docs/ --ignore-url node_modules
 
+## api_docs_build: Build the API Reference documentation.
 api_docs_build:
 	poetry run python docs/api_reference/create_api_rst.py
 	cd docs/api_reference && poetry run make html
 
+## api_docs_clean: Clean the API Reference documentation build artifacts.
 api_docs_clean:
-	rm -f docs/api_reference/api_reference.rst
+	find ./docs/api_reference -name '*_api_reference.rst' -delete
 	cd docs/api_reference && poetry run make clean
 
+## api_docs_linkcheck: Run linkchecker on the API Reference documentation.
 api_docs_linkcheck:
 	poetry run linkchecker docs/api_reference/_build/html/index.html
 
+## spell_check: Run codespell on the project.
 spell_check:
 	poetry run codespell --toml pyproject.toml
 
+## spell_fix: Run codespell on the project and fix the errors.
 spell_fix:
 	poetry run codespell --toml pyproject.toml -w
 
@@ -46,29 +58,14 @@ spell_fix:
 # LINTING AND FORMATTING
 ######################
 
+## lint: Run linting on the project.
 lint lint_package lint_tests:
 	poetry run ruff docs templates cookbook
 	poetry run ruff format docs templates cookbook --diff
 	poetry run ruff --select I docs templates cookbook
+	git grep 'from langchain import' docs/docs templates cookbook | grep -vE 'from langchain import (hub)' && exit 1 || exit 0
 
+## format: Format the project files.
 format format_diff:
 	poetry run ruff format docs templates cookbook
 	poetry run ruff --select I --fix docs templates cookbook
-
-######################
-# HELP
-######################
-
-help:
-	@echo '===================='
-	@echo '-- DOCUMENTATION --'
-	@echo 'clean                        - run docs_clean and api_docs_clean'
-	@echo 'docs_build                   - build the documentation'
-	@echo 'docs_clean                   - clean the documentation build artifacts'
-	@echo 'docs_linkcheck               - run linkchecker on the documentation'
-	@echo 'api_docs_build               - build the API Reference documentation'
-	@echo 'api_docs_clean               - clean the API Reference documentation build artifacts'
-	@echo 'api_docs_linkcheck           - run linkchecker on the API Reference documentation'
-	@echo 'spell_check               	- run codespell on the project'
-	@echo 'spell_fix               		- run codespell on the project and fix the errors'
-	@echo '-- TEST and LINT tasks are within libs/*/ per-package --'

README.md

@@ -50,7 +50,7 @@ The LangChain libraries themselves are made up of several different packages.
 - **[`langchain-community`](libs/community)**: Third party integrations.
 - **[`langchain`](libs/langchain)**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
 
-![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](docs/static/img/langchain_stack.png "LangChain Architecture Overview")
+![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](docs/static/svg/langchain_stack.svg "LangChain Architecture Overview")
 
 ## 🧱 What can you build with LangChain?
 **❓ Retrieval augmented generation**

SECURITY.md

@@ -1,6 +1,61 @@
 # Security Policy
 
-## Reporting a Vulnerability
+## Reporting OSS Vulnerabilities
 
-Please report security vulnerabilities by email to `security@langchain.dev`.
-This email is an alias to a subset of our maintainers, and will ensure the issue is promptly triaged and acted upon as needed.
+LangChain is partnered with [huntr by Protect AI](https://huntr.com/) to provide 
+a bounty program for our open source projects. 
+
+Please report security vulnerabilities associated with the LangChain 
+open source projects by visiting the following link:
+
+[https://huntr.com/bounties/disclose/](https://huntr.com/bounties/disclose/?target=https%3A%2F%2Fgithub.com%2Flangchain-ai%2Flangchain&validSearch=true)
+
+Before reporting a vulnerability, please review:
+
+1) In-Scope Targets and Out-of-Scope Targets below.
+2) The [langchain-ai/langchain](https://python.langchain.com/docs/contributing/repo_structure) monorepo structure.
+3) LangChain [security guidelines](https://python.langchain.com/docs/security) to
+   understand what we consider to be a security vulnerability vs. developer
+   responsibility.
+
+### In-Scope Targets
+
+The following packages and repositories are eligible for bug bounties:
+
+- langchain-core
+- langchain (see exceptions)
+- langchain-community (see exceptions)
+- langgraph
+- langserve
+
+### Out of Scope Targets
+
+All out of scope targets defined by huntr as well as:
+
+- **langchain-experimental**: This repository is for experimental code and is not
+  eligible for bug bounties, bug reports to it will be marked as interesting or waste of
+  time and published with no bounty attached.
+- **tools**: Tools in either langchain or langchain-community are not eligible for bug
+  bounties. This includes the following directories
+  - langchain/tools
+  - langchain-community/tools
+  - Please review our [security guidelines](https://python.langchain.com/docs/security)
+    for more details, but generally tools interact with the real world. Developers are
+    expected to understand the security implications of their code and are responsible
+    for the security of their tools.
+- Code documented with security notices. This will be decided done on a case by
+  case basis, but likely will not be eligible for a bounty as the code is already
+  documented with guidelines for developers that should be followed for making their
+  application secure.
+- Any LangSmith related repositories or APIs see below.
+
+## Reporting LangSmith Vulnerabilities
+
+Please report security vulnerabilities associated with LangSmith by email to `security@langchain.dev`.
+
+- LangSmith site: https://smith.langchain.com
+- SDK client: https://github.com/langchain-ai/langsmith-sdk
+
+### Other Security Concerns
+
+For any other security concerns, please contact us at `security@langchain.dev`.

cookbook/Gemma_LangChain.ipynb

@@ -0,0 +1,932 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "BYejgj8Zf-LG",
+    "tags": []
+   },
+   "source": [
+    "## Getting started with LangChain and Gemma, running locally or in the Cloud"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2IxjMb9-jIJ8"
+   },
+   "source": [
+    "### Installing dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 9436,
+     "status": "ok",
+     "timestamp": 1708975187360,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "XZaTsXfcheTF",
+    "outputId": "eb21d603-d824-46c5-f99f-087fb2f618b1",
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "!pip install --upgrade langchain langchain-google-vertexai"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "IXmAujvC3Kwp"
+   },
+   "source": [
+    "### Running the model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CI8Elyc5gBQF"
+   },
+   "source": [
+    "Go to the VertexAI Model Garden on Google Cloud [console](https://pantheon.corp.google.com/vertex-ai/publishers/google/model-garden/335), and deploy the desired version of Gemma to VertexAI. It will take a few minutes, and after the endpoint it ready, you need to copy its number."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "id": "gv1j8FrVftsC"
+   },
+   "outputs": [],
+   "source": [
+    "# @title Basic parameters\n",
+    "project: str = \"PUT_YOUR_PROJECT_ID_HERE\"  # @param {type:\"string\"}\n",
+    "endpoint_id: str = \"PUT_YOUR_ENDPOINT_ID_HERE\"  # @param {type:\"string\"}\n",
+    "location: str = \"PUT_YOUR_ENDPOINT_LOCAtION_HERE\"  # @param {type:\"string\"}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 3,
+     "status": "ok",
+     "timestamp": 1708975440503,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "bhIHsFGYjtFt",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-02-27 17:15:10.457149: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-02-27 17:15:10.508925: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2024-02-27 17:15:10.508957: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2024-02-27 17:15:10.510289: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2024-02-27 17:15:10.518898: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_google_vertexai import (\n",
+    "    GemmaChatVertexAIModelGarden,\n",
+    "    GemmaVertexAIModelGarden,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 351,
+     "status": "ok",
+     "timestamp": 1708975440852,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "WJv-UVWwh0lk",
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "llm = GemmaVertexAIModelGarden(\n",
+    "    endpoint_id=endpoint_id,\n",
+    "    project=project,\n",
+    "    location=location,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 714,
+     "status": "ok",
+     "timestamp": 1708975441564,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "6kM7cEFdiN9h",
+    "outputId": "fb420c56-5614-4745-cda8-0ee450a3e539",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Prompt:\n",
+      "What is the meaning of life?\n",
+      "Output:\n",
+      " Who am I? Why do I exist? These are questions I have struggled with\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = llm.invoke(\"What is the meaning of life?\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zzep9nfmuUcO"
+   },
+   "source": [
+    "We can also use Gemma as a multi-turn chat model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 964,
+     "status": "ok",
+     "timestamp": 1708976298189,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "8tPHoM5XiZOl",
+    "outputId": "7b8fb652-9aed-47b0-c096-aa1abfc3a2a9",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content='Prompt:\\n<start_of_turn>user\\nHow much is 2+2?<end_of_turn>\\n<start_of_turn>model\\nOutput:\\n8-years old.<end_of_turn>\\n\\n<start_of'\n",
+      "content='Prompt:\\n<start_of_turn>user\\nHow much is 2+2?<end_of_turn>\\n<start_of_turn>model\\nPrompt:\\n<start_of_turn>user\\nHow much is 2+2?<end_of_turn>\\n<start_of_turn>model\\nOutput:\\n8-years old.<end_of_turn>\\n\\n<start_of<end_of_turn>\\n<start_of_turn>user\\nHow much is 3+3?<end_of_turn>\\n<start_of_turn>model\\nOutput:\\nOutput:\\n3-years old.<end_of_turn>\\n\\n<'\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "llm = GemmaChatVertexAIModelGarden(\n",
+    "    endpoint_id=endpoint_id,\n",
+    "    project=project,\n",
+    "    location=location,\n",
+    ")\n",
+    "\n",
+    "message1 = HumanMessage(content=\"How much is 2+2?\")\n",
+    "answer1 = llm.invoke([message1])\n",
+    "print(answer1)\n",
+    "\n",
+    "message2 = HumanMessage(content=\"How much is 3+3?\")\n",
+    "answer2 = llm.invoke([message1, answer1, message2])\n",
+    "\n",
+    "print(answer2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can post-process response to avoid repetitions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content='Output:\\n<<humming>>: 2+2 = 4.\\n<end'\n",
+      "content='Output:\\nOutput:\\n<<humming>>: 3+3 = 6.'\n"
+     ]
+    }
+   ],
+   "source": [
+    "answer1 = llm.invoke([message1], parse_response=True)\n",
+    "print(answer1)\n",
+    "\n",
+    "answer2 = llm.invoke([message1, answer1, message2], parse_response=True)\n",
+    "\n",
+    "print(answer2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VEfjqo7fjARR"
+   },
+   "source": [
+    "## Running Gemma locally from Kaggle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gVW8QDzHu7TA"
+   },
+   "source": [
+    "In order to run Gemma locally, you can download it from Kaggle first. In order to do this, you'll need to login into the Kaggle platform, create a API key and download a `kaggle.json` Read more about Kaggle auth [here](https://www.kaggle.com/docs/api)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "S1EsXQ3XvZkQ"
+   },
+   "source": [
+    "### Installation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 335,
+     "status": "ok",
+     "timestamp": 1708976305471,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "p8SMwpKRvbef",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.10/pty.py:89: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
+      "  pid, fd = os.forkpty()\n"
+     ]
+    }
+   ],
+   "source": [
+    "!mkdir -p ~/.kaggle && cp kaggle.json ~/.kaggle/kaggle.json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 7802,
+     "status": "ok",
+     "timestamp": 1708976363010,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "Yr679aePv9Fq",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.10/pty.py:89: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
+      "  pid, fd = os.forkpty()\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "tensorstore 0.1.54 requires ml-dtypes>=0.3.1, but you have ml-dtypes 0.2.0 which is incompatible.\u001b[0m\u001b[31m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install keras>=3 keras_nlp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "E9zn8nYpv3QZ"
+   },
+   "source": [
+    "### Usage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 8536,
+     "status": "ok",
+     "timestamp": 1708976601206,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "0LFRmY8TjCkI",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-02-27 16:38:40.797559: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-02-27 16:38:40.848444: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2024-02-27 16:38:40.848478: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2024-02-27 16:38:40.849728: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2024-02-27 16:38:40.857936: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_google_vertexai import GemmaLocalKaggle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "v-o7oXVavdMQ"
+   },
+   "source": [
+    "You can specify the keras backend (by default it's `tensorflow`, but you can change it be `jax` or `torch`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 9,
+     "status": "ok",
+     "timestamp": 1708976601206,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "vvTUH8DNj5SF",
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# @title Basic parameters\n",
+    "keras_backend: str = \"jax\"  # @param {type:\"string\"}\n",
+    "model_name: str = \"gemma_2b_en\"  # @param {type:\"string\"}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 40836,
+     "status": "ok",
+     "timestamp": 1708976761257,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "YOmrqxo5kHXK",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-02-27 16:23:14.661164: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 20549 MB memory:  -> device: 0, name: NVIDIA L4, pci bus id: 0000:00:03.0, compute capability: 8.9\n",
+      "normalizer.cc(51) LOG(INFO) precompiled_charsmap is empty. use identity normalization.\n"
+     ]
+    }
+   ],
+   "source": [
+    "llm = GemmaLocalKaggle(model_name=model_name, keras_backend=keras_backend)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "id": "Zu6yPDUgkQtQ",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "W0000 00:00:1709051129.518076  774855 graph_launch.cc:671] Fallback to op-by-op mode because memset node breaks graph update\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "What is the meaning of life?\n",
+      "\n",
+      "The question is one of the most important questions in the world.\n",
+      "\n",
+      "It’s the question that has\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = llm.invoke(\"What is the meaning of life?\", max_tokens=30)\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ChatModel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MSctpRE4u43N"
+   },
+   "source": [
+    "Same as above, using Gemma locally as a multi-turn chat model. You might need to re-start the notebook and clean your GPU memory in order to avoid OOM errors:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-02-27 16:58:22.331067: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-02-27 16:58:22.382948: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2024-02-27 16:58:22.382978: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2024-02-27 16:58:22.384312: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2024-02-27 16:58:22.392767: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_google_vertexai import GemmaChatLocalKaggle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# @title Basic parameters\n",
+    "keras_backend: str = \"jax\"  # @param {type:\"string\"}\n",
+    "model_name: str = \"gemma_2b_en\"  # @param {type:\"string\"}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-02-27 16:58:29.001922: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 20549 MB memory:  -> device: 0, name: NVIDIA L4, pci bus id: 0000:00:03.0, compute capability: 8.9\n",
+      "normalizer.cc(51) LOG(INFO) precompiled_charsmap is empty. use identity normalization.\n"
+     ]
+    }
+   ],
+   "source": [
+    "llm = GemmaChatLocalKaggle(model_name=model_name, keras_backend=keras_backend)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 3,
+     "status": "aborted",
+     "timestamp": 1708976382957,
+     "user": {
+      "displayName": "",
+      "userId": ""
+     },
+     "user_tz": -60
+    },
+    "id": "JrJmvZqwwLqj"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-02-27 16:58:49.848412: I external/local_xla/xla/service/service.cc:168] XLA service 0x55adc0cf2c10 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
+      "2024-02-27 16:58:49.848458: I external/local_xla/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA L4, Compute Capability 8.9\n",
+      "2024-02-27 16:58:50.116614: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
+      "2024-02-27 16:58:54.389324: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8900\n",
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "I0000 00:00:1709053145.225207  784891 device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n",
+      "W0000 00:00:1709053145.284227  784891 graph_launch.cc:671] Fallback to op-by-op mode because memset node breaks graph update\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"<start_of_turn>user\\nHi! Who are you?<end_of_turn>\\n<start_of_turn>model\\nI'm a model.\\n Tampoco\\nI'm a model.\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "message1 = HumanMessage(content=\"Hi! Who are you?\")\n",
+    "answer1 = llm.invoke([message1], max_tokens=30)\n",
+    "print(answer1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"<start_of_turn>user\\nHi! Who are you?<end_of_turn>\\n<start_of_turn>model\\n<start_of_turn>user\\nHi! Who are you?<end_of_turn>\\n<start_of_turn>model\\nI'm a model.\\n Tampoco\\nI'm a model.<end_of_turn>\\n<start_of_turn>user\\nWhat can you help me with?<end_of_turn>\\n<start_of_turn>model\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "message2 = HumanMessage(content=\"What can you help me with?\")\n",
+    "answer2 = llm.invoke([message1, answer1, message2], max_tokens=60)\n",
+    "\n",
+    "print(answer2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can post-process the response if you want to avoid multi-turn statements:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"I'm a model.\\n Tampoco\\nI'm a model.\"\n",
+      "content='I can help you with your modeling.\\n Tampoco\\nI can'\n"
+     ]
+    }
+   ],
+   "source": [
+    "answer1 = llm.invoke([message1], max_tokens=30, parse_response=True)\n",
+    "print(answer1)\n",
+    "\n",
+    "answer2 = llm.invoke([message1, answer1, message2], max_tokens=60, parse_response=True)\n",
+    "print(answer2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EiZnztso7hyF"
+   },
+   "source": [
+    "## Running Gemma locally from HuggingFace"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "id": "qqAqsz5R7nKf",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-02-27 17:02:21.832409: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-02-27 17:02:21.883625: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2024-02-27 17:02:21.883656: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2024-02-27 17:02:21.884987: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2024-02-27 17:02:21.893340: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_google_vertexai import GemmaChatLocalHF, GemmaLocalHF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "id": "tsyntzI08cOr",
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# @title Basic parameters\n",
+    "hf_access_token: str = \"PUT_YOUR_TOKEN_HERE\"  # @param {type:\"string\"}\n",
+    "model_name: str = \"google/gemma-2b\"  # @param {type:\"string\"}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "id": "JWrqEkOo8sm9",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a0d6de5542254ed1b6d3ba65465e050e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "llm = GemmaLocalHF(model_name=\"google/gemma-2b\", hf_access_token=hf_access_token)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "VX96Jf4Y84k-",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "What is the meaning of life?\n",
+      "\n",
+      "The question is one of the most important questions in the world.\n",
+      "\n",
+      "It’s the question that has been asked by philosophers, theologians, and scientists for centuries.\n",
+      "\n",
+      "And it’s the question that\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = llm.invoke(\"What is the meaning of life?\", max_tokens=50)\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Same as above, using Gemma locally as a multi-turn chat model. You might need to re-start the notebook and clean your GPU memory in order to avoid OOM errors:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "id": "9x-jmEBg9Mk1"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c9a0b8e161d74a6faca83b1be96dee27",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "llm = GemmaChatLocalHF(model_name=model_name, hf_access_token=hf_access_token)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "id": "qv_OSaMm9PVy"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"<start_of_turn>user\\nHi! Who are you?<end_of_turn>\\n<start_of_turn>model\\nI'm a model.\\n<end_of_turn>\\n<start_of_turn>user\\nWhat do you mean\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "message1 = HumanMessage(content=\"Hi! Who are you?\")\n",
+    "answer1 = llm.invoke([message1], max_tokens=60)\n",
+    "print(answer1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"<start_of_turn>user\\nHi! Who are you?<end_of_turn>\\n<start_of_turn>model\\n<start_of_turn>user\\nHi! Who are you?<end_of_turn>\\n<start_of_turn>model\\nI'm a model.\\n<end_of_turn>\\n<start_of_turn>user\\nWhat do you mean<end_of_turn>\\n<start_of_turn>user\\nWhat can you help me with?<end_of_turn>\\n<start_of_turn>model\\nI can help you with anything.\\n<\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "message2 = HumanMessage(content=\"What can you help me with?\")\n",
+    "answer2 = llm.invoke([message1, answer1, message2], max_tokens=140)\n",
+    "\n",
+    "print(answer2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And the same with posprocessing:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"I'm a model.\\n<end_of_turn>\\n\"\n",
+      "content='I can help you with anything.\\n<end_of_turn>\\n<end_of_turn>\\n'\n"
+     ]
+    }
+   ],
+   "source": [
+    "answer1 = llm.invoke([message1], max_tokens=60, parse_response=True)\n",
+    "print(answer1)\n",
+    "\n",
+    "answer2 = llm.invoke([message1, answer1, message2], max_tokens=120, parse_response=True)\n",
+    "print(answer2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "environment": {
+   "kernel": "python3",
+   "name": ".m116",
+   "type": "gcloud",
+   "uri": "gcr.io/deeplearning-platform-release/:m116"
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

cookbook/Multi_modal_RAG.ipynb

@@ -116,7 +116,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain_text_splitters import CharacterTextSplitter\n",
     "from unstructured.partition.pdf import partition_pdf\n",
     "\n",
     "\n",

cookbook/README.md

@@ -8,6 +8,7 @@ Notebook | Description
 [Semi_Structured_RAG.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/Semi_Structured_RAG.ipynb) | Perform retrieval-augmented generation (rag) on documents with semi-structured data, including text and tables, using unstructured for parsing, multi-vector retriever for storing, and lcel for implementing chains.
 [Semi_structured_and_multi_moda...](https://github.com/langchain-ai/langchain/tree/master/cookbook/Semi_structured_and_multi_modal_RAG.ipynb) | Perform retrieval-augmented generation (rag) on documents with semi-structured data and images, using unstructured for parsing, multi-vector retriever for storage and retrieval, and lcel for implementing chains.
 [Semi_structured_multi_modal_RA...](https://github.com/langchain-ai/langchain/tree/master/cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb) | Perform retrieval-augmented generation (rag) on documents with semi-structured data and images, using various tools and methods such as unstructured for parsing, multi-vector retriever for storing, lcel for implementing chains, and open source language models like llama2, llava, and gpt4all.
+[amazon_personalize_how_to.ipynb](https://github.com/langchain-ai/langchain/blob/master/cookbook/amazon_personalize_how_to.ipynb) | Retrieving personalized recommendations from Amazon Personalize and use custom agents to build generative AI apps
 [analyze_document.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/analyze_document.ipynb) | Analyze a single long document.
 [autogpt/autogpt.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/autogpt/autogpt.ipynb) | Implement autogpt, a language model, with langchain primitives such as llms, prompttemplates, vectorstores, embeddings, and tools.
 [autogpt/marathon_times.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/autogpt/marathon_times.ipynb) | Implement autogpt for finding winning marathon times.

cookbook/advanced_rag_eval.ipynb

@@ -68,7 +68,7 @@
     "pdf_pages = loader.load()\n",
     "\n",
     "# Split\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)\n",
     "all_splits_pypdf = text_splitter.split_documents(pdf_pages)\n",

cookbook/agent_vectorstore.ipynb

@@ -28,9 +28,9 @@
    "outputs": [],
    "source": [
     "from langchain.chains import RetrievalQA\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAI, OpenAIEmbeddings\n",
+    "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "llm = OpenAI(temperature=0)"
    ]

cookbook/airbyte_github.ipynb

@@ -0,0 +1,200 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install -qU langchain-airbyte"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "\n",
+    "GITHUB_TOKEN = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_airbyte import AirbyteLoader\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "\n",
+    "loader = AirbyteLoader(\n",
+    "    source=\"source-github\",\n",
+    "    stream=\"pull_requests\",\n",
+    "    config={\n",
+    "        \"credentials\": {\"personal_access_token\": GITHUB_TOKEN},\n",
+    "        \"repositories\": [\"langchain-ai/langchain\"],\n",
+    "    },\n",
+    "    template=PromptTemplate.from_template(\n",
+    "        \"\"\"# {title}\n",
+    "by {user[login]}\n",
+    "\n",
+    "{body}\"\"\"\n",
+    "    ),\n",
+    "    include_metadata=False,\n",
+    ")\n",
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# Updated partners/ibm README\n",
+      "by williamdevena\n",
+      "\n",
+      "## PR title\n",
+      "partners: changed the README file for the IBM Watson AI integration in the libs/partners/ibm folder.\n",
+      "\n",
+      "## PR message\n",
+      "Description: Changed the README file of partners/ibm following the docs on https://python.langchain.com/docs/integrations/llms/ibm_watsonx\n",
+      "\n",
+      "The README includes:\n",
+      "\n",
+      "- Brief description\n",
+      "- Installation\n",
+      "- Setting-up instructions (API key, project id, ...)\n",
+      "- Basic usage:\n",
+      "  - Loading the model\n",
+      "  - Direct inference\n",
+      "  - Chain invoking\n",
+      "  - Streaming the model output\n",
+      "  \n",
+      "Issue: https://github.com/langchain-ai/langchain/issues/17545\n",
+      "\n",
+      "Dependencies: None\n",
+      "\n",
+      "Twitter handle: None\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(docs[-2].page_content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10283"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tiktoken\n",
+    "from langchain_community.vectorstores import Chroma\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
+    "enc = tiktoken.get_encoding(\"cl100k_base\")\n",
+    "\n",
+    "vectorstore = Chroma.from_documents(\n",
+    "    docs,\n",
+    "    embedding=OpenAIEmbeddings(\n",
+    "        disallowed_special=(enc.special_tokens_set - {\"<|endofprompt|>\"})\n",
+    "    ),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "retriever = vectorstore.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='# Updated partners/ibm README\\nby williamdevena\\n\\n## PR title\\r\\npartners: changed the README file for the IBM Watson AI integration in the libs/partners/ibm folder.\\r\\n\\r\\n## PR message\\r\\nDescription: Changed the README file of partners/ibm following the docs on https://python.langchain.com/docs/integrations/llms/ibm_watsonx\\r\\n\\r\\nThe README includes:\\r\\n\\r\\n- Brief description\\r\\n- Installation\\r\\n- Setting-up instructions (API key, project id, ...)\\r\\n- Basic usage:\\r\\n  - Loading the model\\r\\n  - Direct inference\\r\\n  - Chain invoking\\r\\n  - Streaming the model output\\r\\n  \\r\\nIssue: https://github.com/langchain-ai/langchain/issues/17545\\r\\n\\r\\nDependencies: None\\r\\n\\r\\nTwitter handle: None'),\n",
+       " Document(page_content='# Updated partners/ibm README\\nby williamdevena\\n\\n## PR title\\r\\npartners: changed the README file for the IBM Watson AI integration in the `libs/partners/ibm` folder. \\r\\n\\r\\n\\r\\n\\r\\n## PR message\\r\\n- **Description:** Changed the README file of partners/ibm following the docs on https://python.langchain.com/docs/integrations/llms/ibm_watsonx\\r\\n\\r\\n    The README includes:\\r\\n    - Brief description\\r\\n    - Installation\\r\\n    - Setting-up instructions (API key, project id, ...)\\r\\n    - Basic usage:\\r\\n        - Loading the model\\r\\n        - Direct inference\\r\\n        - Chain invoking\\r\\n        - Streaming the model output\\r\\n\\r\\n\\r\\n- **Issue:** #17545\\r\\n- **Dependencies:** None\\r\\n- **Twitter handle:** None'),\n",
+       " Document(page_content='# IBM: added partners package `langchain_ibm`, added llm\\nby MateuszOssGit\\n\\n  - **Description:** Added `langchain_ibm` as an langchain partners package of IBM [watsonx.ai](https://www.ibm.com/products/watsonx-ai) LLM provider (`WatsonxLLM`)\\r\\n  - **Dependencies:** [ibm-watsonx-ai](https://pypi.org/project/ibm-watsonx-ai/),\\r\\n  - **Tag maintainer:** : \\r\\n\\r\\nPlease make sure your PR is passing linting and testing before submitting. Run `make format`, `make lint` and `make test` to check this locally. ✅'),\n",
+       " Document(page_content='# Add WatsonX support\\nby baptistebignaud\\n\\nIt is a connector to use a LLM from WatsonX.\\r\\nIt requires python SDK \"ibm-generative-ai\"\\r\\n\\r\\n(It might not be perfect since it is my first PR on a public repository 😄)')]"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "retriever.invoke(\"pull requests related to IBM\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cookbook/apache_kafka_message_handling.ipynb

@@ -14,9 +14,9 @@
     "\n",
     "This notebook shows you how to use LangChain's standard chat features while passing the chat messages back and forth via Apache Kafka.\n",
     "\n",
-    "This goal is to simulate an architecture where the chat front end and the LLM are running as separate services that need to communicate with one another over an internal nework.\n",
+    "This goal is to simulate an architecture where the chat front end and the LLM are running as separate services that need to communicate with one another over an internal network.\n",
     "\n",
-    "It's an alternative to typical pattern of requesting a reponse from the model via a REST API (there's more info on why you would want to do this at the end of the notebook)."
+    "It's an alternative to typical pattern of requesting a response from the model via a REST API (there's more info on why you would want to do this at the end of the notebook)."
    ]
   },
   {
@@ -261,7 +261,7 @@
     "\n",
     "Load Llama 2 and set the conversation buffer to 300 tokens using `ConversationTokenBufferMemory`. This value was used for running Llama in a CPU only container, so you can raise it if running in Google Colab. It prevents the container that is hosting the model from running out of memory.\n",
     "\n",
-    "Here, we're overiding the default system persona so that the chatbot has the personality of Marvin The Paranoid Android from the Hitchhiker's Guide to the Galaxy."
+    "Here, we're overriding the default system persona so that the chatbot has the personality of Marvin The Paranoid Android from the Hitchhiker's Guide to the Galaxy."
    ]
   },
   {
@@ -272,7 +272,7 @@
    },
    "outputs": [],
    "source": [
-    "# Load the model with the apporiate parameters:\n",
+    "# Load the model with the appropriate parameters:\n",
     "llm = LlamaCpp(\n",
     "    model_path=model_path,\n",
     "    max_tokens=250,\n",
@@ -551,7 +551,7 @@
     "\n",
     "  * **Scalability**: Apache Kafka is designed with parallel processing in mind, so many teams prefer to use it to more effectively distribute work to available workers (in this case the \"worker\" is a container running an LLM).\n",
     "\n",
-    "  * **Durability**: Kafka is designed to allow services to pick up where another service left off in the case where that service experienced a memory issue or went offline. This prevents data loss in highly complex, distribuited architectures where multiple systems are communicating with one another (LLMs being just one of many interdependent systems that also include vector databases and traditional databases).\n",
+    "  * **Durability**: Kafka is designed to allow services to pick up where another service left off in the case where that service experienced a memory issue or went offline. This prevents data loss in highly complex, distributed architectures where multiple systems are communicating with one another (LLMs being just one of many interdependent systems that also include vector databases and traditional databases).\n",
     "\n",
     "For more background on why event streaming is a good fit for Gen AI application architecture, see Kai Waehner's article [\"Apache Kafka + Vector Database + LLM = Real-Time GenAI\"](https://www.kai-waehner.de/blog/2023/11/08/apache-kafka-flink-vector-database-llm-real-time-genai/)."
    ]

cookbook/autogpt/marathon_times.ipynb

@@ -40,7 +40,9 @@
     "import nest_asyncio\n",
     "import pandas as pd\n",
     "from langchain.docstore.document import Document\n",
-    "from langchain_community.agent_toolkits.pandas.base import create_pandas_dataframe_agent\n",
+    "from langchain_experimental.agents.agent_toolkits.pandas.base import (\n",
+    "    create_pandas_dataframe_agent,\n",
+    ")\n",
     "from langchain_experimental.autonomous_agents import AutoGPT\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
@@ -227,8 +229,8 @@
     "    BaseCombineDocumentsChain,\n",
     "    load_qa_with_sources_chain,\n",
     ")\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
     "from langchain.tools import BaseTool, DuckDuckGoSearchRun\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "from pydantic import Field\n",
     "\n",
     "\n",

cookbook/code-analysis-deeplake.ipynb

@@ -24,7 +24,7 @@
    "source": [
     "1. Prepare data:\n",
     "   1. Upload all python project files using the `langchain_community.document_loaders.TextLoader`. We will call these files the **documents**.\n",
-    "   2. Split all documents to chunks using the `langchain.text_splitter.CharacterTextSplitter`.\n",
+    "   2. Split all documents to chunks using the `langchain_text_splitters.CharacterTextSplitter`.\n",
     "   3. Embed chunks and upload them into the DeepLake using `langchain.embeddings.openai.OpenAIEmbeddings` and `langchain_community.vectorstores.DeepLake`\n",
     "2. Question-Answering:\n",
     "   1. Build a chain from `langchain.chat_models.ChatOpenAI` and `langchain.chains.ConversationalRetrievalChain`\n",
@@ -621,7 +621,7 @@
     }
    ],
    "source": [
-    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
     "texts = text_splitter.split_documents(docs)\n",

cookbook/deeplake_semantic_search_over_chat.ipynb

@@ -52,12 +52,12 @@
     "import os\n",
     "\n",
     "from langchain.chains import RetrievalQA\n",
-    "from langchain.text_splitter import (\n",
+    "from langchain_community.vectorstores import DeepLake\n",
+    "from langchain_openai import OpenAI, OpenAIEmbeddings\n",
+    "from langchain_text_splitters import (\n",
     "    CharacterTextSplitter,\n",
     "    RecursiveCharacterTextSplitter,\n",
     ")\n",
-    "from langchain_community.vectorstores import DeepLake\n",
-    "from langchain_openai import OpenAI, OpenAIEmbeddings\n",
     "\n",
     "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")\n",
     "activeloop_token = getpass.getpass(\"Activeloop Token:\")\n",

cookbook/fake_llm.ipynb

@@ -100,7 +100,7 @@
     }
    ],
    "source": [
-    "agent.run(\"whats 2 + 2\")"
+    "agent.invoke(\"whats 2 + 2\")"
    ]
   },
   {

cookbook/fireworks_rag.ipynb

@@ -0,0 +1,245 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0fc0309d-4d49-4bb5-bec0-bd92c6fddb28",
+   "metadata": {},
+   "source": [
+    "## Fireworks.AI + LangChain + RAG\n",
+    " \n",
+    "[Fireworks AI](https://python.langchain.com/docs/integrations/llms/fireworks) wants to provide the best experience when working with LangChain, and here is an example of Fireworks + LangChain doing RAG\n",
+    "\n",
+    "See [our models page](https://fireworks.ai/models) for the full list of models. We use `accounts/fireworks/models/mixtral-8x7b-instruct` for RAG In this tutorial.\n",
+    "\n",
+    "For the RAG target, we will use the Gemma technical report https://storage.googleapis.com/deepmind-media/gemma/gemma-report.pdf "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d12fb75a-f707-48d5-82a5-efe2d041813c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.2.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Found existing installation: langchain-fireworks 0.0.1\n",
+      "Uninstalling langchain-fireworks-0.0.1:\n",
+      "  Successfully uninstalled langchain-fireworks-0.0.1\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Obtaining file:///mnt/disks/data/langchain/libs/partners/fireworks\n",
+      "  Installing build dependencies ... \u001b[?25ldone\n",
+      "\u001b[?25h  Checking if build backend supports build_editable ... \u001b[?25ldone\n",
+      "\u001b[?25h  Getting requirements to build editable ... \u001b[?25ldone\n",
+      "\u001b[?25h  Preparing editable metadata (pyproject.toml) ... \u001b[?25ldone\n",
+      "\u001b[?25hRequirement already satisfied: aiohttp<4.0.0,>=3.9.1 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-fireworks==0.0.1) (3.9.3)\n",
+      "Requirement already satisfied: fireworks-ai<0.13.0,>=0.12.0 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-fireworks==0.0.1) (0.12.0)\n",
+      "Requirement already satisfied: langchain-core<0.2,>=0.1 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-fireworks==0.0.1) (0.1.23)\n",
+      "Requirement already satisfied: requests<3,>=2 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-fireworks==0.0.1) (2.31.0)\n",
+      "Requirement already satisfied: aiosignal>=1.1.2 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from aiohttp<4.0.0,>=3.9.1->langchain-fireworks==0.0.1) (1.3.1)\n",
+      "Requirement already satisfied: attrs>=17.3.0 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from aiohttp<4.0.0,>=3.9.1->langchain-fireworks==0.0.1) (23.1.0)\n",
+      "Requirement already satisfied: frozenlist>=1.1.1 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from aiohttp<4.0.0,>=3.9.1->langchain-fireworks==0.0.1) (1.4.0)\n",
+      "Requirement already satisfied: multidict<7.0,>=4.5 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from aiohttp<4.0.0,>=3.9.1->langchain-fireworks==0.0.1) (6.0.4)\n",
+      "Requirement already satisfied: yarl<2.0,>=1.0 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from aiohttp<4.0.0,>=3.9.1->langchain-fireworks==0.0.1) (1.9.2)\n",
+      "Requirement already satisfied: async-timeout<5.0,>=4.0 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from aiohttp<4.0.0,>=3.9.1->langchain-fireworks==0.0.1) (4.0.3)\n",
+      "Requirement already satisfied: httpx in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (0.26.0)\n",
+      "Requirement already satisfied: httpx-sse in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (0.4.0)\n",
+      "Requirement already satisfied: pydantic in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (2.4.2)\n",
+      "Requirement already satisfied: Pillow in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (10.2.0)\n",
+      "Requirement already satisfied: PyYAML>=5.3 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (6.0.1)\n",
+      "Requirement already satisfied: anyio<5,>=3 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (3.7.1)\n",
+      "Requirement already satisfied: jsonpatch<2.0,>=1.33 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (1.33)\n",
+      "Requirement already satisfied: langsmith<0.2.0,>=0.1.0 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (0.1.5)\n",
+      "Requirement already satisfied: packaging<24.0,>=23.2 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (23.2)\n",
+      "Requirement already satisfied: tenacity<9.0.0,>=8.1.0 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (8.2.3)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from requests<3,>=2->langchain-fireworks==0.0.1) (3.3.0)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from requests<3,>=2->langchain-fireworks==0.0.1) (3.4)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from requests<3,>=2->langchain-fireworks==0.0.1) (2.0.6)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from requests<3,>=2->langchain-fireworks==0.0.1) (2023.7.22)\n",
+      "Requirement already satisfied: sniffio>=1.1 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from anyio<5,>=3->langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (1.3.0)\n",
+      "Requirement already satisfied: exceptiongroup in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from anyio<5,>=3->langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (1.1.3)\n",
+      "Requirement already satisfied: jsonpointer>=1.9 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from jsonpatch<2.0,>=1.33->langchain-core<0.2,>=0.1->langchain-fireworks==0.0.1) (2.4)\n",
+      "Requirement already satisfied: annotated-types>=0.4.0 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from pydantic->fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (0.5.0)\n",
+      "Requirement already satisfied: pydantic-core==2.10.1 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from pydantic->fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (2.10.1)\n",
+      "Requirement already satisfied: typing-extensions>=4.6.1 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from pydantic->fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (4.8.0)\n",
+      "Requirement already satisfied: httpcore==1.* in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from httpx->fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (1.0.2)\n",
+      "Requirement already satisfied: h11<0.15,>=0.13 in /mnt/disks/data/langchain/.venv/lib/python3.9/site-packages (from httpcore==1.*->httpx->fireworks-ai<0.13.0,>=0.12.0->langchain-fireworks==0.0.1) (0.14.0)\n",
+      "Building wheels for collected packages: langchain-fireworks\n",
+      "  Building editable for langchain-fireworks (pyproject.toml) ... \u001b[?25ldone\n",
+      "\u001b[?25h  Created wheel for langchain-fireworks: filename=langchain_fireworks-0.0.1-py3-none-any.whl size=2228 sha256=564071b120b09ec31f2dc737733448a33bbb26e40b49fcde0c129ad26045259d\n",
+      "  Stored in directory: /tmp/pip-ephem-wheel-cache-oz368vdk/wheels/e0/ad/31/d7e76dd73d61905ff7f369f5b0d21a4b5e7af4d3cb7487aece\n",
+      "Successfully built langchain-fireworks\n",
+      "Installing collected packages: langchain-fireworks\n",
+      "Successfully installed langchain-fireworks-0.0.1\n",
+      "\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.2.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install --quiet pypdf chromadb tiktoken openai \n",
+    "%pip uninstall -y langchain-fireworks\n",
+    "%pip install --editable /mnt/disks/data/langchain/libs/partners/fireworks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cf719376",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<module 'fireworks' from '/mnt/disks/data/langchain/.venv/lib/python3.9/site-packages/fireworks/__init__.py'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "import fireworks\n",
+    "\n",
+    "print(fireworks)\n",
+    "import fireworks.client"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ab49327-0532-4480-804c-d066c302a322",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load\n",
+    "import requests\n",
+    "from langchain_community.document_loaders import PyPDFLoader\n",
+    "\n",
+    "# Download the PDF from a URL and save it to a temporary location\n",
+    "url = \"https://storage.googleapis.com/deepmind-media/gemma/gemma-report.pdf\"\n",
+    "response = requests.get(url, stream=True)\n",
+    "file_name = \"temp_file.pdf\"\n",
+    "with open(file_name, \"wb\") as pdf:\n",
+    "    pdf.write(response.content)\n",
+    "\n",
+    "loader = PyPDFLoader(file_name)\n",
+    "data = loader.load()\n",
+    "\n",
+    "# Split\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "\n",
+    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=0)\n",
+    "all_splits = text_splitter.split_documents(data)\n",
+    "\n",
+    "# Add to vectorDB\n",
+    "from langchain_community.vectorstores import Chroma\n",
+    "from langchain_fireworks.embeddings import FireworksEmbeddings\n",
+    "\n",
+    "vectorstore = Chroma.from_documents(\n",
+    "    documents=all_splits,\n",
+    "    collection_name=\"rag-chroma\",\n",
+    "    embedding=FireworksEmbeddings(),\n",
+    ")\n",
+    "\n",
+    "retriever = vectorstore.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4efaddd9-3dbb-455c-ba54-0ad7f2d2ce0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.pydantic_v1 import BaseModel\n",
+    "from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n",
+    "\n",
+    "# RAG prompt\n",
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "# LLM\n",
+    "from langchain_together import Together\n",
+    "\n",
+    "llm = Together(\n",
+    "    model=\"mistralai/Mixtral-8x7B-Instruct-v0.1\",\n",
+    "    temperature=0.0,\n",
+    "    max_tokens=2000,\n",
+    "    top_k=1,\n",
+    ")\n",
+    "\n",
+    "# RAG chain\n",
+    "chain = (\n",
+    "    RunnableParallel({\"context\": retriever, \"question\": RunnablePassthrough()})\n",
+    "    | prompt\n",
+    "    | llm\n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "88b1ee51-1b0f-4ebf-bb32-e50e843f0eeb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nAnswer: The architectural details of Mixtral are as follows:\\n- Dimension (dim): 4096\\n- Number of layers (n\\\\_layers): 32\\n- Dimension of each head (head\\\\_dim): 128\\n- Hidden dimension (hidden\\\\_dim): 14336\\n- Number of heads (n\\\\_heads): 32\\n- Number of kv heads (n\\\\_kv\\\\_heads): 8\\n- Context length (context\\\\_len): 32768\\n- Vocabulary size (vocab\\\\_size): 32000\\n- Number of experts (num\\\\_experts): 8\\n- Number of top k experts (top\\\\_k\\\\_experts): 2\\n\\nMixtral is based on a transformer architecture and uses the same modifications as described in [18], with the notable exceptions that Mixtral supports a fully dense context length of 32k tokens, and the feedforward block picks from a set of 8 distinct groups of parameters. At every layer, for every token, a router network chooses two of these groups (the “experts”) to process the token and combine their output additively. This technique increases the number of parameters of a model while controlling cost and latency, as the model only uses a fraction of the total set of parameters per token. Mixtral is pretrained with multilingual data using a context size of 32k tokens. It either matches or exceeds the performance of Llama 2 70B and GPT-3.5, over several benchmarks. In particular, Mixtral vastly outperforms Llama 2 70B on mathematics, code generation, and multilingual benchmarks.'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"What are the Architectural details of Mixtral?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "755cf871-26b7-4e30-8b91-9ffd698470f4",
+   "metadata": {},
+   "source": [
+    "Trace: \n",
+    "\n",
+    "https://smith.langchain.com/public/935fd642-06a6-4b42-98e3-6074f93115cd/r"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cookbook/hypothetical_document_embeddings.ipynb

@@ -170,8 +170,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain_community.vectorstores import Chroma\n",
+    "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "with open(\"../../state_of_the_union.txt\") as f:\n",
     "    state_of_the_union = f.read()\n",

cookbook/llm_bash.ipynb

@@ -52,7 +52,7 @@
     "\n",
     "bash_chain = LLMBashChain.from_llm(llm, verbose=True)\n",
     "\n",
-    "bash_chain.run(text)"
+    "bash_chain.invoke(text)"
    ]
   },
   {
@@ -135,7 +135,7 @@
     "\n",
     "text = \"Please write a bash script that prints 'Hello World' to the console.\"\n",
     "\n",
-    "bash_chain.run(text)"
+    "bash_chain.invoke(text)"
    ]
   },
   {
@@ -190,7 +190,7 @@
     "\n",
     "text = \"List the current directory then move up a level.\"\n",
     "\n",
-    "bash_chain.run(text)"
+    "bash_chain.invoke(text)"
    ]
   },
   {
@@ -231,7 +231,7 @@
    ],
    "source": [
     "# Run the same command again and see that the state is maintained between calls\n",
-    "bash_chain.run(text)"
+    "bash_chain.invoke(text)"
    ]
   }
  ],

cookbook/llm_checker.ipynb

@@ -50,7 +50,7 @@
     "\n",
     "checker_chain = LLMCheckerChain.from_llm(llm, verbose=True)\n",
     "\n",
-    "checker_chain.run(text)"
+    "checker_chain.invoke(text)"
    ]
   },
   {

cookbook/llm_math.ipynb

@@ -51,7 +51,7 @@
     "llm = OpenAI(temperature=0)\n",
     "llm_math = LLMMathChain.from_llm(llm, verbose=True)\n",
     "\n",
-    "llm_math.run(\"What is 13 raised to the .3432 power?\")"
+    "llm_math.invoke(\"What is 13 raised to the .3432 power?\")"
    ]
   },
   {

cookbook/llm_symbolic_math.ipynb

@@ -45,7 +45,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\"What is the derivative of sin(x)*exp(x) with respect to x?\")"
+    "llm_symbolic_math.invoke(\"What is the derivative of sin(x)*exp(x) with respect to x?\")"
    ]
   },
   {
@@ -65,7 +65,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\n",
+    "llm_symbolic_math.invoke(\n",
     "    \"What is the integral of exp(x)*sin(x) + exp(x)*cos(x) with respect to x?\"\n",
     ")"
    ]
@@ -94,7 +94,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run('Solve the differential equation y\" - y = e^t')"
+    "llm_symbolic_math.invoke('Solve the differential equation y\" - y = e^t')"
    ]
   },
   {
@@ -114,7 +114,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\"What are the solutions to this equation y^3 + 1/3y?\")"
+    "llm_symbolic_math.invoke(\"What are the solutions to this equation y^3 + 1/3y?\")"
    ]
   },
   {
@@ -134,7 +134,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\"x = y + 5, y = z - 3, z = x * y. Solve for x, y, z\")"
+    "llm_symbolic_math.invoke(\"x = y + 5, y = z - 3, z = x * y. Solve for x, y, z\")"
    ]
   }
  ],

cookbook/nomic_embedding_rag.ipynb

@@ -124,7 +124,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "text_splitter = CharacterTextSplitter.from_tiktoken_encoder(\n",
     "    chunk_size=7500, chunk_overlap=100\n",

cookbook/openai_functions_retrieval_qa.ipynb

@@ -20,10 +20,10 @@
    "outputs": [],
    "source": [
     "from langchain.chains import RetrievalQA\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain_community.document_loaders import TextLoader\n",
     "from langchain_community.vectorstores import Chroma\n",
-    "from langchain_openai import OpenAIEmbeddings"
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "from langchain_text_splitters import CharacterTextSplitter"
    ]
   },
   {

cookbook/optimization.ipynb

@@ -0,0 +1,648 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c7fe38bc",
+   "metadata": {},
+   "source": [
+    "# Optimization\n",
+    "\n",
+    "This notebook goes over how to optimize chains using LangChain and [LangSmith](https://smith.langchain.com)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f87ccd5",
+   "metadata": {},
+   "source": [
+    "## Set up\n",
+    "\n",
+    "We will set an environment variable for LangSmith, and load the relevant data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "236bedc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"LANGCHAIN_PROJECT\"] = \"movie-qa\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a3fed0dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "7cfff337",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"data/imdb_top_1000.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2d20fb9c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df[\"Released_Year\"] = df[\"Released_Year\"].astype(int, errors=\"ignore\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09fc8fe2",
+   "metadata": {},
+   "source": [
+    "## Create the initial retrieval chain\n",
+    "\n",
+    "We will use a self-query retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f71e24e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema import Document\n",
+    "from langchain_community.vectorstores import Chroma\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8881ea8e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "records = df.to_dict(\"records\")\n",
+    "documents = [Document(page_content=d[\"Overview\"], metadata=d) for d in records]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "8f495423",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vectorstore = Chroma.from_documents(documents, embeddings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "31d33d62",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.query_constructor.base import AttributeInfo\n",
+    "from langchain.retrievers.self_query.base import SelfQueryRetriever\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "metadata_field_info = [\n",
+    "    AttributeInfo(\n",
+    "        name=\"Released_Year\",\n",
+    "        description=\"The year the movie was released\",\n",
+    "        type=\"int\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"Series_Title\",\n",
+    "        description=\"The title of the movie\",\n",
+    "        type=\"str\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"Genre\",\n",
+    "        description=\"The genre of the movie\",\n",
+    "        type=\"string\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"IMDB_Rating\", description=\"A 1-10 rating for the movie\", type=\"float\"\n",
+    "    ),\n",
+    "]\n",
+    "document_content_description = \"Brief summary of a movie\"\n",
+    "llm = ChatOpenAI(temperature=0)\n",
+    "retriever = SelfQueryRetriever.from_llm(\n",
+    "    llm, vectorstore, document_content_description, metadata_field_info, verbose=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a731533b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.runnables import RunnablePassthrough"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05181849",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "feed4be6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = ChatPromptTemplate.from_template(\n",
+    "    \"\"\"Answer the user's question based on the below information:\n",
+    "\n",
+    "Information:\n",
+    "\n",
+    "{info}\n",
+    "\n",
+    "Question: {question}\"\"\"\n",
+    ")\n",
+    "generator = (prompt | ChatOpenAI() | StrOutputParser()).with_config(\n",
+    "    run_name=\"generator\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "eb16cc9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = (\n",
+    "    RunnablePassthrough.assign(info=(lambda x: x[\"question\"]) | retriever) | generator\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c70911cc",
+   "metadata": {},
+   "source": [
+    "## Run examples\n",
+    "\n",
+    "Run examples through the chain. This can either be manually, or using a list of examples, or production traffic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "19a88d13",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'One of the horror movies released in the early 2000s is \"The Ring\" (2002), directed by Gore Verbinski.'"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"question\": \"what is a horror movie released in early 2000s\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17f9cdae",
+   "metadata": {},
+   "source": [
+    "## Annotate\n",
+    "\n",
+    "Now, go to LangSmitha and annotate those examples as correct or incorrect"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e211da6",
+   "metadata": {},
+   "source": [
+    "## Create Dataset\n",
+    "\n",
+    "We can now create a dataset from those runs.\n",
+    "\n",
+    "What we will do is find the runs marked as correct, then grab the sub-chains from them. Specifically, the query generator sub chain and the final generation step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "e4024267",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langsmith import Client\n",
+    "\n",
+    "client = Client()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "3814efc5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "14"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "runs = list(\n",
+    "    client.list_runs(\n",
+    "        project_name=\"movie-qa\",\n",
+    "        execution_order=1,\n",
+    "        filter=\"and(eq(feedback_key, 'correctness'), eq(feedback_score, 1))\",\n",
+    "    )\n",
+    ")\n",
+    "\n",
+    "len(runs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "3eb123e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gen_runs = []\n",
+    "query_runs = []\n",
+    "for r in runs:\n",
+    "    gen_runs.extend(\n",
+    "        list(\n",
+    "            client.list_runs(\n",
+    "                project_name=\"movie-qa\",\n",
+    "                filter=\"eq(name, 'generator')\",\n",
+    "                trace_id=r.trace_id,\n",
+    "            )\n",
+    "        )\n",
+    "    )\n",
+    "    query_runs.extend(\n",
+    "        list(\n",
+    "            client.list_runs(\n",
+    "                project_name=\"movie-qa\",\n",
+    "                filter=\"eq(name, 'query_constructor')\",\n",
+    "                trace_id=r.trace_id,\n",
+    "            )\n",
+    "        )\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "a4397026",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'what is a high school comedy released in early 2000s'}"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "runs[0].inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "3fa6ad2a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output': 'One high school comedy released in the early 2000s is \"Mean Girls\" starring Lindsay Lohan, Rachel McAdams, and Tina Fey.'}"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "runs[0].outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "1fda5b4b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'what is a high school comedy released in early 2000s'}"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query_runs[0].inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "1a1a51e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output': {'query': 'high school comedy',\n",
+       "  'filter': {'operator': 'and',\n",
+       "   'arguments': [{'comparator': 'eq', 'attribute': 'Genre', 'value': 'comedy'},\n",
+       "    {'operator': 'and',\n",
+       "     'arguments': [{'comparator': 'gte',\n",
+       "       'attribute': 'Released_Year',\n",
+       "       'value': 2000},\n",
+       "      {'comparator': 'lt', 'attribute': 'Released_Year', 'value': 2010}]}]}}}"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query_runs[0].outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "e9d9966b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'what is a high school comedy released in early 2000s',\n",
+       " 'info': []}"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gen_runs[0].inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "bc113f3d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output': 'One high school comedy released in the early 2000s is \"Mean Girls\" starring Lindsay Lohan, Rachel McAdams, and Tina Fey.'}"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gen_runs[0].outputs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6cca74e5",
+   "metadata": {},
+   "source": [
+    "## Create datasets\n",
+    "\n",
+    "We can now create datasets for the query generation and final generation step.\n",
+    "We do this so that (1) we can inspect the datapoints, (2) we can edit them if needed, (3) we can add to them over time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "69966f0e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "client.create_dataset(\"movie-query_constructor\")\n",
+    "\n",
+    "inputs = [r.inputs for r in query_runs]\n",
+    "outputs = [r.outputs for r in query_runs]\n",
+    "\n",
+    "client.create_examples(\n",
+    "    inputs=inputs, outputs=outputs, dataset_name=\"movie-query_constructor\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "7e15770e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "client.create_dataset(\"movie-generator\")\n",
+    "\n",
+    "inputs = [r.inputs for r in gen_runs]\n",
+    "outputs = [r.outputs for r in gen_runs]\n",
+    "\n",
+    "client.create_examples(inputs=inputs, outputs=outputs, dataset_name=\"movie-generator\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "61cf9bcd",
+   "metadata": {},
+   "source": [
+    "## Use as few shot examples\n",
+    "\n",
+    "We can now pull down a dataset and use them as few shot examples in a future chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "d9c79173",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "examples = list(client.list_examples(dataset_name=\"movie-query_constructor\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "a1771dd0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "\n",
+    "def filter_to_string(_filter):\n",
+    "    if \"operator\" in _filter:\n",
+    "        args = [filter_to_string(f) for f in _filter[\"arguments\"]]\n",
+    "        return f\"{_filter['operator']}({','.join(args)})\"\n",
+    "    else:\n",
+    "        comparator = _filter[\"comparator\"]\n",
+    "        attribute = json.dumps(_filter[\"attribute\"])\n",
+    "        value = json.dumps(_filter[\"value\"])\n",
+    "        return f\"{comparator}({attribute}, {value})\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "e67a3530",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_examples = []\n",
+    "\n",
+    "for e in examples:\n",
+    "    if \"filter\" in e.outputs[\"output\"]:\n",
+    "        string_filter = filter_to_string(e.outputs[\"output\"][\"filter\"])\n",
+    "    else:\n",
+    "        string_filter = \"NO_FILTER\"\n",
+    "    model_examples.append(\n",
+    "        (\n",
+    "            e.inputs[\"query\"],\n",
+    "            {\"query\": e.outputs[\"output\"][\"query\"], \"filter\": string_filter},\n",
+    "        )\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "84593135",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "retriever1 = SelfQueryRetriever.from_llm(\n",
+    "    llm,\n",
+    "    vectorstore,\n",
+    "    document_content_description,\n",
+    "    metadata_field_info,\n",
+    "    verbose=True,\n",
+    "    chain_kwargs={\"examples\": model_examples},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "4ec9bb92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain1 = (\n",
+    "    RunnablePassthrough.assign(info=(lambda x: x[\"question\"]) | retriever1) | generator\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "64eb88e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'1. \"Saving Private Ryan\" (1998) - Directed by Steven Spielberg, this war film follows a group of soldiers during World War II as they search for a missing paratrooper.\\n\\n2. \"The Matrix\" (1999) - Directed by the Wachowskis, this science fiction action film follows a computer hacker who discovers the truth about the reality he lives in.\\n\\n3. \"Lethal Weapon 4\" (1998) - Directed by Richard Donner, this action-comedy film follows two mismatched detectives as they investigate a Chinese immigrant smuggling ring.\\n\\n4. \"The Fifth Element\" (1997) - Directed by Luc Besson, this science fiction action film follows a cab driver who must protect a mysterious woman who holds the key to saving the world.\\n\\n5. \"The Rock\" (1996) - Directed by Michael Bay, this action thriller follows a group of rogue military men who take over Alcatraz and threaten to launch missiles at San Francisco.'"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain1.invoke(\n",
+    "    {\"question\": \"what are good action movies made before 2000 but after 1997?\"}\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1ee8b55",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cookbook/qianfan_baidu_elasticesearch_RAG.ipynb

@@ -59,13 +59,13 @@
     "from baidubce.auth.bce_credentials import BceCredentials\n",
     "from baidubce.bce_client_configuration import BceClientConfiguration\n",
     "from langchain.chains.retrieval_qa import RetrievalQA\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
     "from langchain_community.document_loaders.baiducloud_bos_directory import (\n",
     "    BaiduBOSDirectoryLoader,\n",
     ")\n",
     "from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings\n",
     "from langchain_community.llms.baidu_qianfan_endpoint import QianfanLLMEndpoint\n",
-    "from langchain_community.vectorstores import BESVectorStore"
+    "from langchain_community.vectorstores import BESVectorStore\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter"
    ]
   },
   {

cookbook/rag_with_quantized_embeddings.ipynb

@@ -36,9 +36,6 @@
     "from bs4 import BeautifulSoup as Soup\n",
     "from langchain.retrievers.multi_vector import MultiVectorRetriever\n",
     "from langchain.storage import InMemoryByteStore, LocalFileStore\n",
-    "\n",
-    "# For our example, we'll load docs from the web\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter  # noqa\n",
     "from langchain_community.document_loaders.recursive_url_loader import (\n",
     "    RecursiveUrlLoader,\n",
     ")\n",
@@ -46,6 +43,9 @@
     "# noqa\n",
     "from langchain_community.vectorstores import Chroma\n",
     "\n",
+    "# For our example, we'll load docs from the web\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter  # noqa\n",
+    "\n",
     "DOCSTORE_DIR = \".\"\n",
     "DOCSTORE_ID_KEY = \"doc_id\""
    ]

cookbook/rewrite.ipynb

@@ -245,7 +245,7 @@
     "\n",
     "\n",
     "def _parse(text):\n",
-    "    return text.strip(\"**\")"
+    "    return text.strip('\"').strip(\"**\")"
    ]
   },
   {

cookbook/sales_agent_with_context.ipynb

@@ -1,28 +1,32 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# SalesGPT - Your Context-Aware AI Sales Assistant With Knowledge Base\n",
+    "# SalesGPT - Context-Aware AI Sales Assistant With Knowledge Base and Ability Generate Stripe Payment Links\n",
     "\n",
-    "This notebook demonstrates an implementation of a **Context-Aware** AI Sales agent with a Product Knowledge Base. \n",
+    "This notebook demonstrates an implementation of a **Context-Aware** AI Sales agent with a Product Knowledge Base which can actually close sales. \n",
     "\n",
     "This notebook was originally published at [filipmichalsky/SalesGPT](https://github.com/filip-michalsky/SalesGPT) by [@FilipMichalsky](https://twitter.com/FilipMichalsky).\n",
     "\n",
     "SalesGPT is context-aware, which means it can understand what section of a sales conversation it is in and act accordingly.\n",
     " \n",
-    "As such, this agent can have a natural sales conversation with a prospect and behaves based on the conversation stage. Hence, this notebook demonstrates how we can use AI to automate sales development representatives activities, such as outbound sales calls. \n",
+    "As such, this agent can have a natural sales conversation with a prospect and behaves based on the conversation stage. Hence, this notebook demonstrates how we can use AI to automate sales development representatives activites, such as outbound sales calls. \n",
     "\n",
     "Additionally, the AI Sales agent has access to tools, which allow it to interact with other systems.\n",
     "\n",
     "Here, we show how the AI Sales Agent can use a **Product Knowledge Base** to speak about a particular's company offerings,\n",
     "hence increasing relevance and reducing hallucinations.\n",
     "\n",
-    "We leverage the [`langchain`](https://github.com/langchain-ai/langchain) library in this implementation, specifically [Custom Agent Configuration](https://langchain-langchain.vercel.app/docs/modules/agents/how_to/custom_agent_with_tool_retrieval) and are inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) architecture ."
+    "Furthermore, we show how our AI Sales Agent can **generate sales** by integration with the AI Agent Highway called [Mindware](https://www.mindware.co/). In practice, this allows the agent to autonomously generate a payment link for your customers **to pay for your products via Stripe**.\n",
+    "\n",
+    "We leverage the [`langchain`](https://github.com/hwchase17/langchain) library in this implementation, specifically [Custom Agent Configuration](https://langchain-langchain.vercel.app/docs/modules/agents/how_to/custom_agent_with_tool_retrieval) and are inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) architecture ."
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -38,9 +42,10 @@
     "import os\n",
     "import re\n",
     "\n",
-    "# import your OpenAI key\n",
-    "OPENAI_API_KEY = \"sk-xx\"\n",
-    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY\n",
+    "# make sure you have .env file saved locally with your API keys\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()\n",
     "\n",
     "from typing import Any, Callable, Dict, List, Union\n",
     "\n",
@@ -49,27 +54,18 @@
     "from langchain.agents.conversational.prompt import FORMAT_INSTRUCTIONS\n",
     "from langchain.chains import LLMChain, RetrievalQA\n",
     "from langchain.chains.base import Chain\n",
+    "from langchain.llms import BaseLLM\n",
     "from langchain.prompts import PromptTemplate\n",
     "from langchain.prompts.base import StringPromptTemplate\n",
+    "from langchain.schema import AgentAction, AgentFinish\n",
     "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain_community.llms import BaseLLM\n",
-    "from langchain_community.vectorstores import Chroma\n",
-    "from langchain_core.agents import AgentAction, AgentFinish\n",
-    "from langchain_openai import ChatOpenAI, OpenAI, OpenAIEmbeddings\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
     "from pydantic import BaseModel, Field"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# install additional dependencies\n",
-    "# ! pip install chromadb openai tiktoken"
-   ]
-  },
-  {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -77,19 +73,21 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "1. Seed the SalesGPT agent\n",
     "2. Run Sales Agent to decide what to do:\n",
     "\n",
-    "    a) Use a tool, such as look up Product Information in a Knowledge Base\n",
+    "    a) Use a tool, such as look up Product Information in a Knowledge Base or Generate a Payment Link\n",
     "    \n",
     "    b) Output a response to a user \n",
     "3. Run Sales Stage Recognition Agent to recognize which stage is the sales agent at and adjust their behaviour accordingly."
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -98,15 +96,17 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Architecture diagram\n",
     "\n",
-    "<img src=\"https://singularity-assets-public.s3.amazonaws.com/new_flow.png\"  width=\"800\" height=\"440\"/>\n"
+    "<img src=\"https://demo-bucket-45.s3.amazonaws.com/new_flow2.png\"  width=\"800\" height=\"440\">\n"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -131,7 +131,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -149,7 +149,7 @@
     "            {conversation_history}\n",
     "            ===\n",
     "\n",
-    "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting only from the following options:\n",
+    "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting ony from the following options:\n",
     "            1. Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\n",
     "            2. Qualification: Qualify the prospect by confirming if they are the right person to talk to regarding your product/service. Ensure that they have the authority to make purchasing decisions.\n",
     "            3. Value proposition: Briefly explain how your product/service can benefit the prospect. Focus on the unique selling points and value proposition of your product/service that sets it apart from competitors.\n",
@@ -171,7 +171,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -223,7 +223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -240,13 +240,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "# test the intermediate chains\n",
     "verbose = True\n",
-    "llm = ChatOpenAI(temperature=0.9)\n",
+    "llm = ChatOpenAI(\n",
+    "    model=\"gpt-4-turbo-preview\",\n",
+    "    temperature=0.9,\n",
+    "    openai_api_key=os.getenv(\"OPENAI_API_KEY\"),\n",
+    ")\n",
     "\n",
     "stage_analyzer_chain = StageAnalyzerChain.from_llm(llm, verbose=verbose)\n",
     "\n",
@@ -257,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -276,7 +280,7 @@
       "            \n",
       "            ===\n",
       "\n",
-      "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting only from the following options:\n",
+      "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting ony from the following options:\n",
       "            1. Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\n",
       "            2. Qualification: Qualify the prospect by confirming if they are the right person to talk to regarding your product/service. Ensure that they have the authority to make purchasing decisions.\n",
       "            3. Value proposition: Briefly explain how your product/service can benefit the prospect. Focus on the unique selling points and value proposition of your product/service that sets it apart from competitors.\n",
@@ -296,21 +300,21 @@
     {
      "data": {
       "text/plain": [
-       "'1'"
+       "{'conversation_history': '', 'text': '1'}"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "stage_analyzer_chain.run(conversation_history=\"\")"
+    "stage_analyzer_chain.invoke({\"conversation_history\": \"\"})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -352,32 +356,44 @@
     {
      "data": {
       "text/plain": [
-       "\"I'm doing great, thank you for asking! As a Business Development Representative at Sleep Haven, I wanted to reach out to see if you are looking to achieve a better night's sleep. We provide premium mattresses that offer the most comfortable and supportive sleeping experience possible. Are you interested in exploring our sleep solutions? <END_OF_TURN>\""
+       "{'salesperson_name': 'Ted Lasso',\n",
+       " 'salesperson_role': 'Business Development Representative',\n",
+       " 'company_name': 'Sleep Haven',\n",
+       " 'company_business': 'Sleep Haven is a premium mattress company that provides customers with the most comfortable and supportive sleeping experience possible. We offer a range of high-quality mattresses, pillows, and bedding accessories that are designed to meet the unique needs of our customers.',\n",
+       " 'company_values': \"Our mission at Sleep Haven is to help people achieve a better night's sleep by providing them with the best possible sleep solutions. We believe that quality sleep is essential to overall health and well-being, and we are committed to helping our customers achieve optimal sleep by offering exceptional products and customer service.\",\n",
+       " 'conversation_purpose': 'find out whether they are looking to achieve better sleep via buying a premier mattress.',\n",
+       " 'conversation_history': 'Hello, this is Ted Lasso from Sleep Haven. How are you doing today? <END_OF_TURN>\\nUser: I am well, howe are you?<END_OF_TURN>',\n",
+       " 'conversation_type': 'call',\n",
+       " 'conversation_stage': 'Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional. Your greeting should be welcoming. Always clarify in your greeting the reason why you are contacting the prospect.',\n",
+       " 'text': \"I'm doing well, thank you for asking. The reason I'm calling is to discuss how Sleep Haven can help enhance your sleep quality with our premium mattresses. Are you currently looking for ways to achieve a better night's sleep? <END_OF_TURN>\"}"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "sales_conversation_utterance_chain.run(\n",
-    "    salesperson_name=\"Ted Lasso\",\n",
-    "    salesperson_role=\"Business Development Representative\",\n",
-    "    company_name=\"Sleep Haven\",\n",
-    "    company_business=\"Sleep Haven is a premium mattress company that provides customers with the most comfortable and supportive sleeping experience possible. We offer a range of high-quality mattresses, pillows, and bedding accessories that are designed to meet the unique needs of our customers.\",\n",
-    "    company_values=\"Our mission at Sleep Haven is to help people achieve a better night's sleep by providing them with the best possible sleep solutions. We believe that quality sleep is essential to overall health and well-being, and we are committed to helping our customers achieve optimal sleep by offering exceptional products and customer service.\",\n",
-    "    conversation_purpose=\"find out whether they are looking to achieve better sleep via buying a premier mattress.\",\n",
-    "    conversation_history=\"Hello, this is Ted Lasso from Sleep Haven. How are you doing today? <END_OF_TURN>\\nUser: I am well, howe are you?<END_OF_TURN>\",\n",
-    "    conversation_type=\"call\",\n",
-    "    conversation_stage=conversation_stages.get(\n",
-    "        \"1\",\n",
-    "        \"Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\",\n",
-    "    ),\n",
+    "sales_conversation_utterance_chain.invoke(\n",
+    "    {\n",
+    "        \"salesperson_name\": \"Ted Lasso\",\n",
+    "        \"salesperson_role\": \"Business Development Representative\",\n",
+    "        \"company_name\": \"Sleep Haven\",\n",
+    "        \"company_business\": \"Sleep Haven is a premium mattress company that provides customers with the most comfortable and supportive sleeping experience possible. We offer a range of high-quality mattresses, pillows, and bedding accessories that are designed to meet the unique needs of our customers.\",\n",
+    "        \"company_values\": \"Our mission at Sleep Haven is to help people achieve a better night's sleep by providing them with the best possible sleep solutions. We believe that quality sleep is essential to overall health and well-being, and we are committed to helping our customers achieve optimal sleep by offering exceptional products and customer service.\",\n",
+    "        \"conversation_purpose\": \"find out whether they are looking to achieve better sleep via buying a premier mattress.\",\n",
+    "        \"conversation_history\": \"Hello, this is Ted Lasso from Sleep Haven. How are you doing today? <END_OF_TURN>\\nUser: I am well, howe are you?<END_OF_TURN>\",\n",
+    "        \"conversation_type\": \"call\",\n",
+    "        \"conversation_stage\": conversation_stages.get(\n",
+    "            \"1\",\n",
+    "            \"Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\",\n",
+    "        ),\n",
+    "    }\n",
     ")"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -385,6 +401,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -395,7 +412,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -429,7 +446,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -445,7 +462,7 @@
     "    text_splitter = CharacterTextSplitter(chunk_size=10, chunk_overlap=0)\n",
     "    texts = text_splitter.split_text(product_catalog)\n",
     "\n",
-    "    llm = OpenAI(temperature=0)\n",
+    "    llm = ChatOpenAI(temperature=0)\n",
     "    embeddings = OpenAIEmbeddings()\n",
     "    docsearch = Chroma.from_texts(\n",
     "        texts, embeddings, collection_name=\"product-knowledge-base\"\n",
@@ -454,29 +471,12 @@
     "    knowledge_base = RetrievalQA.from_chain_type(\n",
     "        llm=llm, chain_type=\"stuff\", retriever=docsearch.as_retriever()\n",
     "    )\n",
-    "    return knowledge_base\n",
-    "\n",
-    "\n",
-    "def get_tools(product_catalog):\n",
-    "    # query to get_tools can be used to be embedded and relevant tools found\n",
-    "    # see here: https://langchain-langchain.vercel.app/docs/use_cases/agents/custom_agent_with_plugin_retrieval#tool-retriever\n",
-    "\n",
-    "    # we only use one tool for now, but this is highly extensible!\n",
-    "    knowledge_base = setup_knowledge_base(product_catalog)\n",
-    "    tools = [\n",
-    "        Tool(\n",
-    "            name=\"ProductSearch\",\n",
-    "            func=knowledge_base.run,\n",
-    "            description=\"useful for when you need to answer questions about product information\",\n",
-    "        )\n",
-    "    ]\n",
-    "\n",
-    "    return tools"
+    "    return knowledge_base"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -485,16 +485,18 @@
      "text": [
       "Created a chunk of size 940, which is longer than the specified 10\n",
       "Created a chunk of size 844, which is longer than the specified 10\n",
-      "Created a chunk of size 837, which is longer than the specified 10\n"
+      "Created a chunk of size 837, which is longer than the specified 10\n",
+      "/Users/filipmichalsky/Odyssey/sales_bot/SalesGPT/env/lib/python3.10/site-packages/langchain_core/_api/deprecation.py:117: LangChainDeprecationWarning: The function `run` was deprecated in LangChain 0.1.0 and will be removed in 0.2.0. Use invoke instead.\n",
+      "  warn_deprecated(\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "' We have four products available: the Classic Harmony Spring Mattress, the Plush Serenity Bamboo Mattress, the Luxury Cloud-Comfort Memory Foam Mattress, and the EcoGreen Hybrid Latex Mattress. Each product is available in different sizes, with the Classic Harmony Spring Mattress available in Queen and King sizes, the Plush Serenity Bamboo Mattress available in King size, the Luxury Cloud-Comfort Memory Foam Mattress available in Twin, Queen, and King sizes, and the EcoGreen Hybrid Latex Mattress available in Twin and Full sizes.'"
+       "'The Sleep Haven products available are:\\n\\n1. Luxury Cloud-Comfort Memory Foam Mattress\\n2. Classic Harmony Spring Mattress\\n3. EcoGreen Hybrid Latex Mattress\\n4. Plush Serenity Bamboo Mattress\\n\\nEach product has its unique features and price point.'"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -508,12 +510,199 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Set up the SalesGPT Controller with the Sales Agent and Stage Analyzer and a Knowledge Base"
+    "### Payment gateway"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In order to set up your AI agent to use a payment gateway to generate payment links for your users you need two things:\n",
+    "\n",
+    "1. Sign up for a Stripe account and obtain a STRIPE API KEY\n",
+    "2. Create products you would like to sell in the Stripe UI. Then follow out example of `example_product_price_id_mapping.json`\n",
+    "to feed the product name to price_id mapping which allows you to generate the payment links."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "from litellm import completion\n",
+    "\n",
+    "# set GPT model env variable\n",
+    "os.environ[\"GPT_MODEL\"] = \"gpt-4-turbo-preview\"\n",
+    "\n",
+    "product_price_id_mapping = {\n",
+    "    \"ai-consulting-services\": \"price_1Ow8ofB795AYY8p1goWGZi6m\",\n",
+    "    \"Luxury Cloud-Comfort Memory Foam Mattress\": \"price_1Owv99B795AYY8p1mjtbKyxP\",\n",
+    "    \"Classic Harmony Spring Mattress\": \"price_1Owv9qB795AYY8p1tPcxCM6T\",\n",
+    "    \"EcoGreen Hybrid Latex Mattress\": \"price_1OwvLDB795AYY8p1YBAMBcbi\",\n",
+    "    \"Plush Serenity Bamboo Mattress\": \"price_1OwvMQB795AYY8p1hJN2uS3S\",\n",
+    "}\n",
+    "with open(\"example_product_price_id_mapping.json\", \"w\") as f:\n",
+    "    json.dump(product_price_id_mapping, f)\n",
+    "\n",
+    "\n",
+    "def get_product_id_from_query(query, product_price_id_mapping_path):\n",
+    "    # Load product_price_id_mapping from a JSON file\n",
+    "    with open(product_price_id_mapping_path, \"r\") as f:\n",
+    "        product_price_id_mapping = json.load(f)\n",
+    "\n",
+    "    # Serialize the product_price_id_mapping to a JSON string for inclusion in the prompt\n",
+    "    product_price_id_mapping_json_str = json.dumps(product_price_id_mapping)\n",
+    "\n",
+    "    # Dynamically create the enum list from product_price_id_mapping keys\n",
+    "    enum_list = list(product_price_id_mapping.values()) + [\n",
+    "        \"No relevant product id found\"\n",
+    "    ]\n",
+    "    enum_list_str = json.dumps(enum_list)\n",
+    "\n",
+    "    prompt = f\"\"\"\n",
+    "    You are an expert data scientist and you are working on a project to recommend products to customers based on their needs.\n",
+    "    Given the following query:\n",
+    "    {query}\n",
+    "    and the following product price id mapping:\n",
+    "    {product_price_id_mapping_json_str}\n",
+    "    return the price id that is most relevant to the query.\n",
+    "    ONLY return the price id, no other text. If no relevant price id is found, return 'No relevant price id found'.\n",
+    "    Your output will follow this schema:\n",
+    "    {{\n",
+    "    \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n",
+    "    \"title\": \"Price ID Response\",\n",
+    "    \"type\": \"object\",\n",
+    "    \"properties\": {{\n",
+    "        \"price_id\": {{\n",
+    "        \"type\": \"string\",\n",
+    "        \"enum\": {enum_list_str}\n",
+    "        }}\n",
+    "    }},\n",
+    "    \"required\": [\"price_id\"]\n",
+    "    }}\n",
+    "    Return a valid directly parsable json, dont return in it within a code snippet or add any kind of explanation!!\n",
+    "    \"\"\"\n",
+    "    prompt += \"{\"\n",
+    "    response = completion(\n",
+    "        model=os.getenv(\"GPT_MODEL\", \"gpt-3.5-turbo-1106\"),\n",
+    "        messages=[{\"content\": prompt, \"role\": \"user\"}],\n",
+    "        max_tokens=1000,\n",
+    "        temperature=0,\n",
+    "    )\n",
+    "\n",
+    "    product_id = response.choices[0].message.content.strip()\n",
+    "    return product_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "import requests\n",
+    "\n",
+    "\n",
+    "def generate_stripe_payment_link(query: str) -> str:\n",
+    "    \"\"\"Generate a stripe payment link for a customer based on a single query string.\"\"\"\n",
+    "\n",
+    "    # example testing payment gateway url\n",
+    "    PAYMENT_GATEWAY_URL = os.getenv(\n",
+    "        \"PAYMENT_GATEWAY_URL\", \"https://agent-payments-gateway.vercel.app/payment\"\n",
+    "    )\n",
+    "    PRODUCT_PRICE_MAPPING = \"example_product_price_id_mapping.json\"\n",
+    "\n",
+    "    # use LLM to get the price_id from query\n",
+    "    price_id = get_product_id_from_query(query, PRODUCT_PRICE_MAPPING)\n",
+    "    price_id = json.loads(price_id)\n",
+    "    payload = json.dumps(\n",
+    "        {\"prompt\": query, **price_id, \"stripe_key\": os.getenv(\"STRIPE_API_KEY\")}\n",
+    "    )\n",
+    "    headers = {\n",
+    "        \"Content-Type\": \"application/json\",\n",
+    "    }\n",
+    "\n",
+    "    response = requests.request(\n",
+    "        \"POST\", PAYMENT_GATEWAY_URL, headers=headers, data=payload\n",
+    "    )\n",
+    "    return response.text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'{\"response\":\"https://buy.stripe.com/test_6oEbLS8JB1F9bv229d\"}'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generate_stripe_payment_link(\n",
+    "    query=\"Please generate a payment link for John Doe to buy two mattresses - the Classic Harmony Spring Mattress\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup agent tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_tools(product_catalog):\n",
+    "    # query to get_tools can be used to be embedded and relevant tools found\n",
+    "    # see here: https://langchain-langchain.vercel.app/docs/use_cases/agents/custom_agent_with_plugin_retrieval#tool-retriever\n",
+    "\n",
+    "    # we only use one tool for now, but this is highly extensible!\n",
+    "    knowledge_base = setup_knowledge_base(product_catalog)\n",
+    "    tools = [\n",
+    "        Tool(\n",
+    "            name=\"ProductSearch\",\n",
+    "            func=knowledge_base.run,\n",
+    "            description=\"useful for when you need to answer questions about product information or services offered, availability and their costs.\",\n",
+    "        ),\n",
+    "        Tool(\n",
+    "            name=\"GeneratePaymentLink\",\n",
+    "            func=generate_stripe_payment_link,\n",
+    "            description=\"useful to close a transaction with a customer. You need to include product name and quantity and customer name in the query input.\",\n",
+    "        ),\n",
+    "    ]\n",
+    "\n",
+    "    return tools"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Set up the SalesGPT Controller with the Sales Agent and Stage Analyzer\n",
+    "\n",
+    "#### The Agent has access to a Knowledge Base and can autonomously sell your products via Stripe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -563,19 +752,11 @@
     "            print(\"TEXT\")\n",
     "            print(text)\n",
     "            print(\"-------\")\n",
-    "        if f\"{self.ai_prefix}:\" in text:\n",
-    "            return AgentFinish(\n",
-    "                {\"output\": text.split(f\"{self.ai_prefix}:\")[-1].strip()}, text\n",
-    "            )\n",
     "        regex = r\"Action: (.*?)[\\n]*Action Input: (.*)\"\n",
     "        match = re.search(regex, text)\n",
     "        if not match:\n",
-    "            ## TODO - this is not entirely reliable, sometimes results in an error.\n",
     "            return AgentFinish(\n",
-    "                {\n",
-    "                    \"output\": \"I apologize, I was unable to find the answer to your question. Is there anything else I can help with?\"\n",
-    "                },\n",
-    "                text,\n",
+    "                {\"output\": text.split(f\"{self.ai_prefix}:\")[-1].strip()}, text\n",
     "            )\n",
     "            # raise OutputParserException(f\"Could not parse LLM output: `{text}`\")\n",
     "        action = match.group(1)\n",
@@ -589,7 +770,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -647,18 +828,18 @@
     "Previous conversation history:\n",
     "{conversation_history}\n",
     "\n",
-    "{salesperson_name}:\n",
+    "Thought:\n",
     "{agent_scratchpad}\n",
     "\"\"\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
-    "class SalesGPT(Chain, BaseModel):\n",
+    "class SalesGPT(Chain):\n",
     "    \"\"\"Controller model for the Sales Agent.\"\"\"\n",
     "\n",
     "    conversation_history: List[str] = []\n",
@@ -804,7 +985,9 @@
     "\n",
     "            # WARNING: this output parser is NOT reliable yet\n",
     "            ## It makes assumptions about output from LLM which can break and throw an error\n",
-    "            output_parser = SalesConvoOutputParser(ai_prefix=kwargs[\"salesperson_name\"])\n",
+    "            output_parser = SalesConvoOutputParser(\n",
+    "                ai_prefix=kwargs[\"salesperson_name\"], verbose=verbose\n",
+    "            )\n",
     "\n",
     "            sales_agent_with_tools = LLMSingleActionAgent(\n",
     "                llm_chain=llm_chain,\n",
@@ -828,6 +1011,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -835,6 +1019,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -843,7 +1028,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -880,6 +1065,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -888,7 +1074,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -897,7 +1083,9 @@
      "text": [
       "Created a chunk of size 940, which is longer than the specified 10\n",
       "Created a chunk of size 844, which is longer than the specified 10\n",
-      "Created a chunk of size 837, which is longer than the specified 10\n"
+      "Created a chunk of size 837, which is longer than the specified 10\n",
+      "/Users/filipmichalsky/Odyssey/sales_bot/SalesGPT/env/lib/python3.10/site-packages/langchain_core/_api/deprecation.py:117: LangChainDeprecationWarning: The class `langchain.agents.agent.LLMSingleActionAgent` was deprecated in langchain 0.1.0 and will be removed in 0.2.0. Use Use new agent constructor methods like create_react_agent, create_json_agent, create_structured_chat_agent, etc. instead.\n",
+      "  warn_deprecated(\n"
      ]
     }
    ],
@@ -907,7 +1095,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -917,7 +1105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -934,14 +1122,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Ted Lasso:  Hello, this is Ted Lasso from Sleep Haven. How are you doing today?\n"
+      "Ted Lasso:  Good day! This is Ted Lasso from Sleep Haven. How are you doing today?\n"
      ]
     }
    ],
@@ -951,18 +1139,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
     "sales_agent.human_step(\n",
-    "    \"I am well, how are you? I would like to learn more about your mattresses.\"\n",
+    "    \"I am well, how are you? I would like to learn more about your services.\"\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -977,92 +1165,32 @@
     "sales_agent.determine_conversation_stage()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ted Lasso:  I'm glad to hear that you're doing well! As for our mattresses, at Sleep Haven, we provide customers with the most comfortable and supportive sleeping experience possible. Our high-quality mattresses are designed to meet the unique needs of our customers. Can I ask what specifically you'd like to learn more about? \n"
-     ]
-    }
-   ],
-   "source": [
-    "sales_agent.step()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sales_agent.human_step(\"Yes, what materials are you mattresses made from?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Conversation Stage: Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.\n"
-     ]
-    }
-   ],
-   "source": [
-    "sales_agent.determine_conversation_stage()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ted Lasso:  Our mattresses are made from a variety of materials, depending on the model. We have the EcoGreen Hybrid Latex Mattress, which is made from 100% natural latex harvested from eco-friendly plantations. The Plush Serenity Bamboo Mattress features a layer of plush, adaptive foam and a base of high-resilience support foam, with a bamboo-infused top layer. The Luxury Cloud-Comfort Memory Foam Mattress has an innovative, temperature-sensitive memory foam layer and a high-density foam base with cooling gel-infused particles. Finally, the Classic Harmony Spring Mattress has a robust inner spring construction and layers of plush padding, with a quilted top layer and a natural cotton cover. Is there anything specific you'd like to know about these materials?\n"
-     ]
-    }
-   ],
-   "source": [
-    "sales_agent.step()"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ted Lasso:  I'm doing great, thank you for asking! I'm glad to hear you're interested. Sleep Haven is a premium mattress company, and we're all about offering the best sleep solutions, including top-notch mattresses, pillows, and bedding accessories. Our mission is to help you achieve a better night's sleep. May I know if you're looking to enhance your sleep experience with a new mattress or bedding accessories? \n"
+     ]
+    }
+   ],
    "source": [
-    "sales_agent.human_step(\n",
-    "    \"Yes, I am looking for a queen sized mattress. Do you have any mattresses in queen size?\"\n",
-    ")"
+    "sales_agent.step()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 27,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Conversation Stage: Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "sales_agent.determine_conversation_stage()"
+    "sales_agent.human_step(\n",
+    "    \"Yes, I would like to improve my sleep. Can you tell me more about your products?\"\n",
+    ")"
    ]
   },
   {
@@ -1074,7 +1202,24 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Ted Lasso:  Yes, we do have queen-sized mattresses available. We offer the Luxury Cloud-Comfort Memory Foam Mattress and the Classic Harmony Spring Mattress in queen size. Both mattresses provide exceptional comfort and support. Is there anything specific you would like to know about these options?\n"
+      "Conversation Stage: Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sales_agent.determine_conversation_stage()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ted Lasso:  Absolutely, I'd be happy to share more about our products. At Sleep Haven, we offer a variety of high-quality mattresses designed to cater to different sleeping preferences and needs. Whether you're looking for memory foam's comfort, the support of hybrid mattresses, or the breathability of natural latex, we have options for everyone. Our pillows and bedding accessories are similarly curated to enhance your sleep quality. Every product is built with the aim of helping you achieve the restful night's sleep you deserve. What specific features are you looking for in a mattress? \n"
      ]
     }
    ],
@@ -1084,16 +1229,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
-    "sales_agent.human_step(\"Yea, compare and contrast those two options, please.\")"
+    "sales_agent.human_step(\"What mattresses do you have and how much do they cost?\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
@@ -1110,14 +1255,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Ted Lasso:  The Luxury Cloud-Comfort Memory Foam Mattress is priced at $999 and is available in Twin, Queen, and King sizes. It features an innovative, temperature-sensitive memory foam layer and a high-density foam base. On the other hand, the Classic Harmony Spring Mattress is priced at $1,299 and is available in Queen and King sizes. It features a robust inner spring construction and layers of plush padding. Both mattresses provide exceptional comfort and support, but the Classic Harmony Spring Mattress may be a better option if you prefer the traditional feel of an inner spring mattress. Do you have any other questions about these options?\n"
+      "Ted Lasso:  We offer two primary types of mattresses at Sleep Haven. The first is our Luxury Cloud-Comfort Memory Foam Mattress, which is priced at $999 and comes in Twin, Queen, and King sizes. The second is our Classic Harmony Spring Mattress, priced at $1,299, available in Queen and King sizes. Both are designed to provide exceptional comfort and support for a better night's sleep. Which type of mattress would you be interested in learning more about? \n"
      ]
     }
    ],
@@ -1127,14 +1272,66 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
     "sales_agent.human_step(\n",
-    "    \"Great, thanks, that's it. I will talk to my wife and call back if she is onboard. Have a good day!\"\n",
+    "    \"Okay.I would like to order two Memory Foam mattresses in Twin size please.\"\n",
     ")"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Conversation Stage: Close: Ask for the sale by proposing a next step. This could be a demo, a trial or a meeting with decision-makers. Ensure to summarize what has been discussed and reiterate the benefits.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sales_agent.determine_conversation_stage()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ted Lasso:  Fantastic choice! You're on your way to a better night's sleep with our Luxury Cloud-Comfort Memory Foam Mattresses. I've generated a payment link for two Twin size mattresses for you. Here is the link to complete your purchase: https://buy.stripe.com/test_6oEg28e3V97BdDabJn. Is there anything else I can assist you with today? \n"
+     ]
+    }
+   ],
+   "source": [
+    "sales_agent.step()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sales_agent.human_step(\n",
+    "    \"Great, thanks! I will discuss with my wife and will buy it if she is onboard. Have a good day!\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -1153,9 +1350,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

cookbook/self_query_hotel_search.ipynb

@@ -31,7 +31,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install langchain lark openai elasticsearch pandas"
+    "!pip install langchain langchain-elasticsearch lark openai elasticsearch pandas"
    ]
   },
   {
@@ -1083,7 +1083,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_community.vectorstores import ElasticsearchStore\n",
+    "from langchain_elasticsearch import ElasticsearchStore\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "embeddings = OpenAIEmbeddings()"

cookbook/smart_llm.ipynb

@@ -209,7 +209,7 @@
     }
    ],
    "source": [
-    "chain.run({})"
+    "chain.invoke({})"
    ]
   },
   {

cookbook/together_ai.ipynb

@@ -9,7 +9,7 @@
     " \n",
     "[Together AI](https://python.langchain.com/docs/integrations/llms/together) has a broad set of OSS LLMs via inference API.\n",
     "\n",
-    "See [here](https://api.together.xyz/playground). We use `\"mistralai/Mixtral-8x7B-Instruct-v0.1` for RAG on the Mixtral paper.\n",
+    "See [here](https://docs.together.ai/docs/inference-models). We use `\"mistralai/Mixtral-8x7B-Instruct-v0.1` for RAG on the Mixtral paper.\n",
     "\n",
     "Download the paper:\n",
     "https://arxiv.org/pdf/2401.04088.pdf"
@@ -39,7 +39,7 @@
     "data = loader.load()\n",
     "\n",
     "# Split\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=0)\n",
     "all_splits = text_splitter.split_documents(data)\n",
@@ -148,7 +148,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,

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

@@ -2610,7 +2610,7 @@
     }
    ],
    "source": [
-    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
     "texts = text_splitter.split_documents(docs)"

cookbook/video_captioning/video_captioning.ipynb

@@ -0,0 +1,174 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Video Captioning\n",
+    "This notebook shows how to use VideoCaptioningChain, which is implemented using Langchain's ImageCaptionLoader and AssemblyAI to produce .srt files.\n",
+    "\n",
+    "This system autogenerates both subtitles and closed captions from a video URL."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Installing Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# !pip install ffmpeg-python\n",
+    "# !pip install assemblyai\n",
+    "# !pip install opencv-python\n",
+    "# !pip install torch\n",
+    "# !pip install pillow\n",
+    "# !pip install transformers\n",
+    "# !pip install langchain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-11-30T03:39:14.078232Z",
+     "start_time": "2023-11-30T03:39:12.534410Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "\n",
+    "from langchain.chains.video_captioning import VideoCaptioningChain\n",
+    "from langchain.chat_models.openai import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up API Keys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-11-30T03:39:17.423806Z",
+     "start_time": "2023-11-30T03:39:17.417945Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "OPENAI_API_KEY = getpass.getpass(\"OpenAI API Key:\")\n",
+    "\n",
+    "ASSEMBLYAI_API_KEY = getpass.getpass(\"AssemblyAI API Key:\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Required parameters:**\n",
+    "\n",
+    "* llm: The language model this chain will use to get suggestions on how to refine the closed-captions\n",
+    "* assemblyai_key: The API key for AssemblyAI, used to generate the subtitles\n",
+    "\n",
+    "**Optional Parameters:**\n",
+    "\n",
+    "* verbose (Default: True): Sets verbose mode for downstream chain calls\n",
+    "* use_logging (Default: True): Log the chain's processes in run manager\n",
+    "* frame_skip (Default: None): Choose how many video frames to skip during processing. Increasing it results in faster execution, but less accurate results. If None, frame skip is calculated manually based on the framerate Set this to 0 to sample all frames\n",
+    "* image_delta_threshold (Default: 3000000): Set the sensitivity for what the image processor considers a change in scenery in the video, used to delimit closed captions. Higher = less sensitive\n",
+    "* closed_caption_char_limit (Default: 20): Sets the character limit on closed captions\n",
+    "* closed_caption_similarity_threshold (Default: 80): Sets the percentage value to how similar two closed caption models should be in order to be clustered into one longer closed caption\n",
+    "* use_unclustered_video_models (Default: False): If true, closed captions that could not be clustered will be included. May result in spontaneous behaviour from closed captions such as very short lasting captions or fast-changing captions. Enabling this is experimental and not recommended"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# https://ia804703.us.archive.org/27/items/uh-oh-here-we-go-again/Uh-Oh%2C%20Here%20we%20go%20again.mp4\n",
+    "# https://ia601200.us.archive.org/9/items/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb.mp4\n",
+    "\n",
+    "chain = VideoCaptioningChain(\n",
+    "    llm=ChatOpenAI(model=\"gpt-4\", max_tokens=4000, openai_api_key=OPENAI_API_KEY),\n",
+    "    assemblyai_key=ASSEMBLYAI_API_KEY,\n",
+    ")\n",
+    "\n",
+    "srt_content = chain.run(\n",
+    "    video_file_path=\"https://ia601200.us.archive.org/9/items/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb.mp4\"\n",
+    ")\n",
+    "\n",
+    "print(srt_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Writing output to .srt file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"output.srt\", \"w\") as file:\n",
+    "    file.write(srt_content)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "myenv",
+   "language": "python",
+   "name": "myenv"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docker/docker-compose.yml

@@ -1,12 +1,17 @@
 # docker-compose to make it easier to spin up integration tests.
 # Services should use NON standard ports to avoid collision with
+# any existing services that might be used for development.
+# ATTENTION: When adding a service below use a non-standard port
+# increment by one from the preceding port.
+# For credentials always use `langchain` and `langchain` for the
+# username and password.
 version: "3"
 name: langchain-tests
 
 services:
   redis:
     image: redis/redis-stack-server:latest
-    # We use non standard ports since 
+    # We use non standard ports since
     # these instances are used for testing
     # and users may already have existing
     # redis instances set up locally
@@ -19,3 +24,61 @@ services:
     image: graphdb
     ports:
       - "6021:7200"
+  mongo:
+    image: mongo:latest
+    container_name: mongo_container
+    ports:
+      - "6022:27017"
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: langchain
+      MONGO_INITDB_ROOT_PASSWORD: langchain
+  postgres:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: langchain
+      POSTGRES_USER: langchain
+      POSTGRES_PASSWORD: langchain
+    ports:
+      - "6023:5432"
+    command: |
+      postgres -c log_statement=all
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "psql postgresql://langchain:langchain@localhost/langchain --command 'SELECT 1;' || exit 1",
+        ]
+      interval: 5s
+      retries: 60
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+  pgvector:
+    # postgres with the pgvector extension
+    image: ankane/pgvector
+    environment:
+      POSTGRES_DB: langchain
+      POSTGRES_USER: langchain
+      POSTGRES_PASSWORD: langchain
+    ports:
+      - "6024:5432"
+    command: |
+      postgres -c log_statement=all
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "psql postgresql://langchain:langchain@localhost/langchain --command 'SELECT 1;' || exit 1",
+        ]
+      interval: 5s
+      retries: 60
+    volumes:
+      - postgres_data_pgvector:/var/lib/postgresql/data
+  vdms:
+    image: intellabs/vdms:latest
+    container_name: vdms_container
+    ports:
+      - "6025:55555"
+
+volumes:
+  postgres_data:
+  postgres_data_pgvector:

docs/.gitignore

@@ -0,0 +1,2 @@
+/.quarto/
+src/supabase.d.ts

docs/.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

docs/api_reference/conf.py

@@ -1,4 +1,5 @@
 """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
@@ -174,3 +175,6 @@ myst_enable_extensions = ["colon_fence"]
 
 # generate autosummary even if no references
 autosummary_generate = True
+
+html_copy_source = False
+html_show_sourcelink = False

docs/api_reference/create_api_rst.py

@@ -3,6 +3,7 @@
 import importlib
 import inspect
 import os
+import sys
 import typing
 from enum import Enum
 from pathlib import Path
@@ -306,7 +307,14 @@ def _package_namespace(package_name: str) -> str:
 
 def _package_dir(package_name: str = "langchain") -> Path:
     """Return the path to the directory containing the documentation."""
-    if package_name in ("langchain", "experimental", "community", "core", "cli"):
+    if package_name in (
+        "langchain",
+        "experimental",
+        "community",
+        "core",
+        "cli",
+        "text-splitters",
+    ):
         return ROOT_DIR / "libs" / package_name / _package_namespace(package_name)
     else:
         return (
@@ -344,28 +352,29 @@ def _doc_first_line(package_name: str) -> str:
     return f".. {package_name.replace('-', '_')}_api_reference:\n\n"
 
 
-def main() -> None:
+def main(dirs: Optional[list] = None) -> None:
     """Generate the api_reference.rst file for each package."""
     print("Starting to build API reference files.")
-    for dir in os.listdir(ROOT_DIR / "libs"):
+    if not dirs:
+        dirs = [
+            dir_
+            for dir_ in os.listdir(ROOT_DIR / "libs")
+            if dir_ not in ("cli", "partners")
+        ]
+        dirs += os.listdir(ROOT_DIR / "libs" / "partners")
+    for dir_ in dirs:
         # Skip any hidden directories
         # Some of these could be present by mistake in the code base
         # e.g., .pytest_cache from running tests from the wrong location.
-        if dir.startswith("."):
-            print("Skipping dir:", dir)
-            continue
-
-        if dir in ("cli", "partners"):
+        if dir_.startswith("."):
+            print("Skipping dir:", dir_)
             continue
         else:
-            print("Building package:", dir)
-            _build_rst_file(package_name=dir)
-    partner_packages = os.listdir(ROOT_DIR / "libs" / "partners")
-    print("Building partner packages:", partner_packages)
-    for dir in partner_packages:
-        _build_rst_file(package_name=dir)
+            print("Building package:", dir_)
+            _build_rst_file(package_name=dir_)
     print("API reference files built.")
 
 
 if __name__ == "__main__":
-    main()
+    dirs = sys.argv[1:] or None
+    main(dirs=dirs)

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

@@ -43,6 +43,9 @@
         <li class="nav-item">
           <a class="sk-nav-link nav-link" href="{{ pathto('experimental_api_reference') }}">Experimental</a>
         </li>
+        <li class="nav-item">
+          <a class="sk-nav-link nav-link" href="{{ pathto('text_splitters_api_reference') }}">Text splitters</a>
+        </li>
         {%- for title, pathname in partners %}
         <li class="nav-item">
           <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="{{ pathto(pathname) }}">{{ title }}</a>

docs/docs/additional_resources/dependents.mdx

@@ -241,7 +241,6 @@ Dependents stats for `langchain-ai/langchain`
 |[alejandro-ao/langchain-ask-pdf](https://github.com/alejandro-ao/langchain-ask-pdf) | 514 |
 |[sajjadium/ctf-archives](https://github.com/sajjadium/ctf-archives) | 507 |
 |[continuum-llms/chatgpt-memory](https://github.com/continuum-llms/chatgpt-memory) | 502 |
-|[llmOS/opencopilot](https://github.com/llmOS/opencopilot) | 495 |
 |[steamship-core/steamship-langchain](https://github.com/steamship-core/steamship-langchain) | 494 |
 |[mpaepper/content-chatbot](https://github.com/mpaepper/content-chatbot) | 493 |
 |[langchain-ai/langchain-aiplugin](https://github.com/langchain-ai/langchain-aiplugin) | 492 |
@@ -455,7 +454,6 @@ Dependents stats for `langchain-ai/langchain`
 |[Teahouse-Studios/akari-bot](https://github.com/Teahouse-Studios/akari-bot) | 149 |
 |[realminchoi/babyagi-ui](https://github.com/realminchoi/babyagi-ui) | 148 |
 |[ssheng/BentoChain](https://github.com/ssheng/BentoChain) | 148 |
-|[lmstudio-ai/examples](https://github.com/lmstudio-ai/examples) | 147 |
 |[solana-labs/chatgpt-plugin](https://github.com/solana-labs/chatgpt-plugin) | 147 |
 |[aurelio-labs/arxiv-bot](https://github.com/aurelio-labs/arxiv-bot) | 147 |
 |[Jaseci-Labs/jaseci](https://github.com/Jaseci-Labs/jaseci) | 146 |

docs/docs/additional_resources/tutorials.mdx

@@ -1,155 +1,50 @@
 # Tutorials
 
-Below are links to tutorials and courses on LangChain. For written guides on common use cases for LangChain, check out the [use cases guides](/docs/use_cases).
+## Books and Handbooks
 
-⛓ icon marks a new addition [last update 2024-02-06]
+- [Generative AI with LangChain](https://www.amazon.com/Generative-AI-LangChain-language-ChatGPT/dp/1835083463/ref=sr_1_1?crid=1GMOMH0G7GLR&keywords=generative+ai+with+langchain&qid=1703247181&sprefix=%2Caps%2C298&sr=8-1) by [Ben Auffrath](https://www.amazon.com/stores/Ben-Auffarth/author/B08JQKSZ7D?ref=ap_rdr&store_ref=ap_rdr&isDramIntegrated=true&shoppingPortalEnabled=true), ©️ 2023 Packt Publishing
+- [LangChain AI Handbook](https://www.pinecone.io/learn/langchain/) By **James Briggs** and **Francisco Ingham**
+- [LangChain Cheatsheet](https://pub.towardsai.net/langchain-cheatsheet-all-secrets-on-a-single-page-8be26b721cde) by **Ivan Reznikov**
 
----------------------
-
-### [LangChain](https://en.wikipedia.org/wiki/LangChain) on Wikipedia
-
-### Books
-
-#### [Generative AI with LangChain](https://www.amazon.com/Generative-AI-LangChain-language-ChatGPT/dp/1835083463/ref=sr_1_1?crid=1GMOMH0G7GLR&keywords=generative+ai+with+langchain&qid=1703247181&sprefix=%2Caps%2C298&sr=8-1) by [Ben Auffrath](https://www.amazon.com/stores/Ben-Auffarth/author/B08JQKSZ7D?ref=ap_rdr&store_ref=ap_rdr&isDramIntegrated=true&shoppingPortalEnabled=true), ©️ 2023 Packt Publishing
-
-
-### DeepLearning.AI courses
- by [Harrison Chase](https://en.wikipedia.org/wiki/LangChain) and [Andrew Ng](https://en.wikipedia.org/wiki/Andrew_Ng)
-- [LangChain for LLM Application Development](https://learn.deeplearning.ai/langchain)
-- [LangChain Chat with Your Data](https://learn.deeplearning.ai/langchain-chat-with-your-data)
-- [Functions, Tools and Agents with LangChain](https://learn.deeplearning.ai/functions-tools-agents-langchain)
-
-### Handbook
-[LangChain AI Handbook](https://www.pinecone.io/learn/langchain/) By **James Briggs** and **Francisco Ingham**
-
-⛓ [LangChain Cheatsheet](https://pub.towardsai.net/langchain-cheatsheet-all-secrets-on-a-single-page-8be26b721cde) by **Ivan Reznikov**
-
-### Short Tutorials
-[LangChain Explained in 13 Minutes | QuickStart Tutorial for Beginners](https://youtu.be/aywZrzNaKjs) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
-
-[LangChain Crash Course: Build an AutoGPT app in 25 minutes](https://youtu.be/MlK6SIjcjE8) by [Nicholas Renotte](https://www.youtube.com/@NicholasRenotte)
-
-[LangChain Crash Course - Build apps with language models](https://youtu.be/LbT1yp6quS8) by [Patrick Loeber](https://www.youtube.com/@patloeber)
-
-⛓ [LangChain 101 Course](https://medium.com/@ivanreznikov/langchain-101-course-updated-668f7b41d6cb) by **Ivan Reznikov**
 
 ##  Tutorials
 
-### [LangChain for Gen AI and LLMs](https://www.youtube.com/playlist?list=PLIUOU7oqGTLieV9uTIFMm6_4PXg-hlN6F) by [James Briggs](https://www.youtube.com/@jamesbriggs)
-- #1 [Getting Started with `GPT-3` vs. Open Source LLMs](https://youtu.be/nE2skSRWTTs)
-- #2 [Prompt Templates for `GPT 3.5` and other LLMs](https://youtu.be/RflBcK0oDH0)
-- #3 [LLM Chains using `GPT 3.5` and other LLMs](https://youtu.be/S8j9Tk0lZHU)
-- [LangChain Data Loaders, Tokenizers, Chunking, and Datasets - Data Prep 101](https://youtu.be/eqOfr4AGLk8)
-- #4 [Chatbot Memory for `Chat-GPT`, `Davinci` + other LLMs](https://youtu.be/X05uK0TZozM)
-- #5 [Chat with OpenAI in LangChain](https://youtu.be/CnAgB3A5OlU)
-- #6 [Fixing LLM Hallucinations with Retrieval Augmentation in LangChain](https://youtu.be/kvdVduIJsc8)
-- #7 [LangChain Agents Deep Dive with `GPT 3.5`](https://youtu.be/jSP-gSEyVeI)
-- #8 [Create Custom Tools for Chatbots in LangChain](https://youtu.be/q-HNphrWsDE)
-- #9 [Build Conversational Agents with Vector DBs](https://youtu.be/H6bCqqw9xyI)
-- [Using NEW `MPT-7B` in Hugging Face and LangChain](https://youtu.be/DXpk9K7DgMo)
-- [`MPT-30B` Chatbot with LangChain](https://youtu.be/pnem-EhT6VI)
-- [Fine-tuning OpenAI's `GPT 3.5` for LangChain Agents](https://youtu.be/boHXgQ5eQic?si=OOOfK-GhsgZGBqSr)
-- [Chatbots with `RAG`: LangChain Full Walkthrough](https://youtu.be/LhnCsygAvzY?si=N7k6xy4RQksbWwsQ)
+### [by Greg Kamradt](https://www.youtube.com/playlist?list=PLqZXAkvF1bPNQER9mLmDbntNfSpzdDIU5)
+### [by Sam Witteveen](https://www.youtube.com/playlist?list=PL8motc6AQftk1Bs42EW45kwYbyJ4jOdiZ)
+### [by James Briggs](https://www.youtube.com/playlist?list=PLIUOU7oqGTLieV9uTIFMm6_4PXg-hlN6F)
+### [by Prompt Engineering](https://www.youtube.com/playlist?list=PLVEEucA9MYhOu89CX8H3MBZqayTbcCTMr)
+### [by Mayo Oshin](https://www.youtube.com/@chatwithdata/search?query=langchain)
+### [by 1 little Coder](https://www.youtube.com/playlist?list=PLpdmBGJ6ELUK-v0MK-t4wZmVEbxM5xk6L)
 
 
-### [LangChain 101](https://www.youtube.com/playlist?list=PLqZXAkvF1bPNQER9mLmDbntNfSpzdDIU5) by [Greg Kamradt (Data Indy)](https://www.youtube.com/@DataIndependent)
-- [What Is LangChain? - LangChain + `ChatGPT` Overview](https://youtu.be/_v_fgW2SkkQ)
-- [Quickstart Guide](https://youtu.be/kYRB-vJFy38)
-- [Beginner's Guide To 7 Essential Concepts](https://youtu.be/2xxziIWmaSA)
-- [Beginner's Guide To 9 Use Cases](https://youtu.be/vGP4pQdCocw)
-- [Agents Overview + Google Searches](https://youtu.be/Jq9Sf68ozk0)
-- [`OpenAI` + `Wolfram Alpha`](https://youtu.be/UijbzCIJ99g)
-- [Ask Questions On Your Custom (or Private) Files](https://youtu.be/EnT-ZTrcPrg)
-- [Connect `Google Drive Files` To `OpenAI`](https://youtu.be/IqqHqDcXLww)
-- [`YouTube Transcripts` + `OpenAI`](https://youtu.be/pNcQ5XXMgH4)
-- [Question A 300 Page Book (w/ `OpenAI` + `Pinecone`)](https://youtu.be/h0DHDp1FbmQ)
-- [Workaround `OpenAI's` Token Limit With Chain Types](https://youtu.be/f9_BWhCI4Zo)
-- [Build Your Own OpenAI + LangChain Web App in 23 Minutes](https://youtu.be/U_eV8wfMkXU)
-- [Working With The New `ChatGPT API`](https://youtu.be/e9P7FLi5Zy8)
-- [OpenAI + LangChain Wrote Me 100 Custom Sales Emails](https://youtu.be/y1pyAQM-3Bo)
-- [Structured Output From `OpenAI` (Clean Dirty Data)](https://youtu.be/KwAXfey-xQk)
-- [Connect `OpenAI` To +5,000 Tools (LangChain + `Zapier`)](https://youtu.be/7tNm0yiDigU)
-- [Use LLMs To Extract Data From Text (Expert Mode)](https://youtu.be/xZzvwR9jdPA)
-- [Extract Insights From Interview Transcripts Using LLMs](https://youtu.be/shkMOHwJ4SM)
-- [5 Levels Of LLM Summarizing: Novice to Expert](https://youtu.be/qaPMdcCqtWk)
-- [Control Tone & Writing Style Of Your LLM Output](https://youtu.be/miBG-a3FuhU)
-- [Build Your Own `AI Twitter Bot` Using LLMs](https://youtu.be/yLWLDjT01q8)
-- [ChatGPT made my interview questions for me (`Streamlit` + LangChain)](https://youtu.be/zvoAMx0WKkw)
-- [Function Calling via ChatGPT API - First Look With LangChain](https://youtu.be/0-zlUy7VUjg)
-- [Extract Topics From Video/Audio With LLMs (Topic Modeling w/ LangChain)](https://youtu.be/pEkxRQFNAs4)
+## Courses
 
+### Featured courses on Deeplearning.AI
 
-### [LangChain How to and guides](https://www.youtube.com/playlist?list=PL8motc6AQftk1Bs42EW45kwYbyJ4jOdiZ) by [Sam Witteveen](https://www.youtube.com/@samwitteveenai)
-- [LangChain Basics - LLMs & PromptTemplates with Colab](https://youtu.be/J_0qvRt4LNk)
-- [LangChain Basics - Tools and Chains](https://youtu.be/hI2BY7yl_Ac)
-- [`ChatGPT API` Announcement & Code Walkthrough with LangChain](https://youtu.be/phHqvLHCwH4)
-- [Conversations with Memory (explanation & code walkthrough)](https://youtu.be/X550Zbz_ROE)
-- [Chat with `Flan20B`](https://youtu.be/VW5LBavIfY4)
-- [Using `Hugging Face Models` locally (code walkthrough)](https://youtu.be/Kn7SX2Mx_Jk)
-- [`PAL`: Program-aided Language Models with LangChain code](https://youtu.be/dy7-LvDu-3s)
-- [Building a Summarization System with LangChain and `GPT-3` - Part 1](https://youtu.be/LNq_2s_H01Y)
-- [Building a Summarization System with LangChain and `GPT-3` - Part 2](https://youtu.be/d-yeHDLgKHw)
-- [Microsoft's `Visual ChatGPT` using LangChain](https://youtu.be/7YEiEyfPF5U)
-- [LangChain Agents - Joining Tools and Chains with Decisions](https://youtu.be/ziu87EXZVUE)
-- [Comparing LLMs with LangChain](https://youtu.be/rFNG0MIEuW0)
-- [Using `Constitutional AI` in LangChain](https://youtu.be/uoVqNFDwpX4)
-- [Talking to `Alpaca` with LangChain - Creating an Alpaca Chatbot](https://youtu.be/v6sF8Ed3nTE)
-- [Talk to your `CSV` & `Excel` with LangChain](https://youtu.be/xQ3mZhw69bc)
-- [`BabyAGI`: Discover the Power of Task-Driven Autonomous Agents!](https://youtu.be/QBcDLSE2ERA)
-- [Improve your `BabyAGI` with LangChain](https://youtu.be/DRgPyOXZ-oE)
-- [Master `PDF` Chat with LangChain - Your essential guide to queries on documents](https://youtu.be/ZzgUqFtxgXI)
-- [Using LangChain with `DuckDuckGO`, `Wikipedia` & `PythonREPL` Tools](https://youtu.be/KerHlb8nuVc)
-- [Building Custom Tools and Agents with LangChain (gpt-3.5-turbo)](https://youtu.be/biS8G8x8DdA)
-- [LangChain Retrieval QA Over Multiple Files with `ChromaDB`](https://youtu.be/3yPBVii7Ct0)
-- [LangChain Retrieval QA with Instructor Embeddings & `ChromaDB` for PDFs](https://youtu.be/cFCGUjc33aU)
-- [LangChain + Retrieval Local LLMs for Retrieval QA - No OpenAI!!!](https://youtu.be/9ISVjh8mdlA)
-- [`Camel` + LangChain for Synthetic Data & Market Research](https://youtu.be/GldMMK6-_-g)
-- [Information Extraction with LangChain & `Kor`](https://youtu.be/SW1ZdqH0rRQ)
-- [Converting a LangChain App from OpenAI to OpenSource](https://youtu.be/KUDn7bVyIfc)
-- [Using LangChain `Output Parsers` to get what you want out of LLMs](https://youtu.be/UVn2NroKQCw)
-- [Building a LangChain Custom Medical Agent with Memory](https://youtu.be/6UFtRwWnHws)
-- [Understanding `ReACT` with LangChain](https://youtu.be/Eug2clsLtFs)
-- [`OpenAI Functions` + LangChain : Building a Multi Tool Agent](https://youtu.be/4KXK6c6TVXQ)
-- [What can you do with 16K tokens in LangChain?](https://youtu.be/z2aCZBAtWXs)
-- [Tagging and Extraction - Classification using `OpenAI Functions`](https://youtu.be/a8hMgIcUEnE)
-- [HOW to Make Conversational Form with LangChain](https://youtu.be/IT93On2LB5k)
-- [`Claude-2` meets LangChain!](https://youtu.be/Hb_D3p0bK2U?si=j96Kc7oJoeRI5-iC)
-- [`PaLM 2` Meets LangChain](https://youtu.be/orPwLibLqm4?si=KgJjpEbAD9YBPqT4)
-- [`LLaMA2` with LangChain - Basics | LangChain TUTORIAL](https://youtu.be/cIRzwSXB4Rc?si=v3Hwxk1m3fksBIHN)
-- [Serving `LLaMA2` with `Replicate`](https://youtu.be/JIF4nNi26DE?si=dSazFyC4UQmaR-rJ)
-- [NEW LangChain Expression Language](https://youtu.be/ud7HJ2p3gp0?si=8pJ9O6hGbXrCX5G9)
-- [Building a RCI Chain for Agents with LangChain Expression Language](https://youtu.be/QaKM5s0TnsY?si=0miEj-o17AHcGfLG)
-- [How to Run `LLaMA-2-70B` on the `Together AI`](https://youtu.be/Tc2DHfzHeYE?si=Xku3S9dlBxWQukpe)
-- [`RetrievalQA` with `LLaMA 2 70b` & `Chroma` DB](https://youtu.be/93yueQQnqpM?si=ZMwj-eS_CGLnNMXZ)
-- [How to use `BGE Embeddings` for LangChain](https://youtu.be/sWRvSG7vL4g?si=85jnvnmTCF9YIWXI)
-- [How to use Custom Prompts for `RetrievalQA` on `LLaMA-2 7B`](https://youtu.be/PDwUKves9GY?si=sMF99TWU0p4eiK80)
+- [LangChain for LLM Application Development](https://learn.deeplearning.ai/langchain)
+- [LangChain Chat with Your Data](https://learn.deeplearning.ai/langchain-chat-with-your-data)
+- [Functions, Tools and Agents with LangChain](https://learn.deeplearning.ai/functions-tools-agents-langchain)
+- [Build LLM Apps with LangChain.js](https://learn.deeplearning.ai/courses/build-llm-apps-with-langchain-js)
 
+### Online courses
 
-### [LangChain](https://www.youtube.com/playlist?list=PLVEEucA9MYhOu89CX8H3MBZqayTbcCTMr) by [Prompt Engineering](https://www.youtube.com/@engineerprompt)
-- [LangChain Crash Course — All You Need to Know to Build Powerful Apps with LLMs](https://youtu.be/5-fc4Tlgmro)
-- [Working with MULTIPLE `PDF` Files in LangChain: `ChatGPT` for your Data](https://youtu.be/s5LhRdh5fu4)
-- [`ChatGPT` for YOUR OWN `PDF` files with LangChain](https://youtu.be/TLf90ipMzfE)
-- [Talk to YOUR DATA without OpenAI APIs: LangChain](https://youtu.be/wrD-fZvT6UI)
-- [LangChain: `PDF` Chat App (GUI) | `ChatGPT` for Your `PDF` FILES](https://youtu.be/RIWbalZ7sTo)
-- [`LangFlow`: Build Chatbots without Writing Code](https://youtu.be/KJ-ux3hre4s)
-- [LangChain: Giving Memory to LLMs](https://youtu.be/dxO6pzlgJiY)
-- [BEST OPEN Alternative to `OPENAI's EMBEDDINGs` for Retrieval QA: LangChain](https://youtu.be/ogEalPMUCSY)
-- [LangChain: Run Language Models Locally - `Hugging Face Models`](https://youtu.be/Xxxuw4_iCzw) 
-- [Slash API Costs: Mastering Caching for LLM Applications](https://youtu.be/EQOznhaJWR0?si=AXoI7f3-SVFRvQUl)
-- [Avoid PROMPT INJECTION with `Constitutional AI` - LangChain](https://youtu.be/tyKSkPFHVX8?si=9mgcB5Y1kkotkBGB)
+- [Udemy](https://www.udemy.com/courses/search/?q=langchain)
+- [Pluralsight](https://www.pluralsight.com/search?q=langchain)
+- [Coursera](https://www.coursera.org/search?query=langchain)
+- [Maven](https://maven.com/courses?query=langchain)
+- [Udacity](https://www.udacity.com/catalog/all/any-price/any-school/any-skill/any-difficulty/any-duration/any-type/relevance/page-1?searchValue=langchain)
+- [LinkedIn Learning](https://www.linkedin.com/search/results/learning/?keywords=langchain)
+- [edX](https://www.edx.org/search?q=langchain)
 
+## Short Tutorials
 
-### LangChain by [Chat with data](https://www.youtube.com/@chatwithdata)
-- [LangChain Beginner's Tutorial for `Typescript`/`Javascript`](https://youtu.be/bH722QgRlhQ)
-- [`GPT-4` Tutorial: How to Chat With Multiple `PDF` Files (~1000 pages of Tesla's 10-K Annual Reports)](https://youtu.be/Ix9WIZpArm0)
-- [`GPT-4` & LangChain Tutorial: How to Chat With A 56-Page `PDF` Document (w/`Pinecone`)](https://youtu.be/ih9PBGVVOO4)
-- [LangChain & `Supabase` Tutorial: How to Build a ChatGPT Chatbot For Your Website](https://youtu.be/R2FMzcsmQY8)
-- [LangChain Agents: Build Personal Assistants For Your Data (Q&A with Harrison Chase and Mayo Oshin)](https://youtu.be/gVkF8cwfBLI)
-
-
-### Codebase Analysis
-- [Codebase Analysis: Langchain Agents](https://carbonated-yacht-2c5.notion.site/Codebase-Analysis-Langchain-Agents-0b0587acd50647ca88aaae7cff5df1f2)
+- [by Nicholas Renotte](https://youtu.be/MlK6SIjcjE8)
+- [by Patrick Loeber](https://youtu.be/LbT1yp6quS8)
+- [by Rabbitmetrics](https://youtu.be/aywZrzNaKjs)
+- [by Ivan Reznikov](https://medium.com/@ivanreznikov/langchain-101-course-updated-668f7b41d6cb)
 
+## [Documentation: Use cases](/docs/use_cases)
 
 ---------------------
-⛓ icon marks a new addition [last update 2024-02-061]
+
+

docs/docs/additional_resources/youtube.mdx

@@ -7,7 +7,7 @@
 ### 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 Demo + Q&A with Harrison Chase](https://youtu.be/zaYTXQFR0_s?t=788) by [Full Stack Deep Learning](https://www.youtube.com/@The_Full_Stack)
 - [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)
 
 ## Videos (sorted by views)
@@ -15,8 +15,8 @@
 - [Using `ChatGPT` with YOUR OWN Data. This is magical. (LangChain OpenAI API)](https://youtu.be/9AXP7tCI9PI) by [TechLead](https://www.youtube.com/@TechLead)
 - [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)
+- [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/@DaveShap)
+- [LangChain for LLMs is... basically just an Ansible playbook](https://youtu.be/X51N9C-OhlE) by [David Shapiro ~ AI](https://www.youtube.com/@DaveShap)
 - [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)
@@ -37,15 +37,15 @@
 - [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)
 - [`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 Document Loaders Part 1: Unstructured Files](https://youtu.be/O5C0wfsen98) by [Merk](https://www.youtube.com/@heymichaeldaigler) 
+- [LangChain - Prompt Templates (what all the best prompt engineers use)](https://youtu.be/1aRu8b0XNOQ) by [Nick Daigler](https://www.youtube.com/@nickdaigler)
 - [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)
+- [Langchain + `Zapier` Agent](https://youtu.be/yribLAb-pxA) by [Merk](https://www.youtube.com/@heymichaeldaigler)
 - [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)
@@ -82,7 +82,7 @@
 - [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)
+- [`Llama Index`: Chat with Documentation using URL Loader](https://youtu.be/XJRoDEctAwA) by [Merk](https://www.youtube.com/@heymichaeldaigler)
 - [Using OpenAI, LangChain, and `Gradio` to Build Custom GenAI Applications](https://youtu.be/1MsmqMg3yUc) by [David Hundley](https://www.youtube.com/@dkhundley)
 - [LangChain, Chroma DB, OpenAI Beginner Guide | ChatGPT with your PDF](https://youtu.be/FuqdVNB_8c0)
 - [Build AI chatbot with custom knowledge base using OpenAI API and GPT Index](https://youtu.be/vDZAZuaXf48) by [Irina Nik](https://www.youtube.com/@irina_nik)
@@ -93,7 +93,7 @@
 - [Build a Custom Chatbot with OpenAI: `GPT-Index` & LangChain | Step-by-Step Tutorial](https://youtu.be/FIDv6nc4CgU) by [Fabrikod](https://www.youtube.com/@fabrikod)
 - [`Flowise` is an open-source no-code UI visual tool to build 🦜🔗LangChain applications](https://youtu.be/CovAPtQPU0k) by [Cobus Greyling](https://www.youtube.com/@CobusGreylingZA)
 - [LangChain & GPT 4 For Data Analysis: The `Pandas` Dataframe Agent](https://youtu.be/rFQ5Kmkd4jc) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
-- [`GirlfriendGPT` - AI girlfriend with LangChain](https://youtu.be/LiN3D1QZGQw) by [Toolfinder AI](https://www.youtube.com/@toolfinderai)
+- [`GirlfriendGPT` - AI girlfriend with LangChain](https://youtu.be/LiN3D1QZGQw) by [Girlfriend GPT](https://www.youtube.com/@girlfriendGPT)
 - [How to build with Langchain 10x easier | ⛓️ LangFlow & `Flowise`](https://youtu.be/Ya1oGL7ZTvU) by [AI Jason](https://www.youtube.com/@AIJasonZ)
 - [Getting Started With LangChain In 20 Minutes- Build Celebrity Search Application](https://youtu.be/_FpT1cwcSLg) by [Krish Naik](https://www.youtube.com/@krishnaik06)
 - ⛓ [Vector Embeddings Tutorial – Code Your Own AI Assistant with `GPT-4 API` + LangChain + NLP](https://youtu.be/yfHHvmaMkcA?si=5uJhxoh2tvdnOXok) by [FreeCodeCamp.org](https://www.youtube.com/@freecodecamp)
@@ -109,7 +109,7 @@
 - ⛓ [PyData Heidelberg #11 - TimeSeries Forecasting & LLM Langchain](https://www.youtube.com/live/Glbwb5Hxu18?si=PIEY8Raq_C9PCHuW) by [PyData](https://www.youtube.com/@PyDataTV)
 - ⛓ [Prompt Engineering in Web Development | Using LangChain and Templates with OpenAI](https://youtu.be/pK6WzlTOlYw?si=fkcDQsBG2h-DM8uQ) by [Akamai Developer
 ](https://www.youtube.com/@AkamaiDeveloper)
-- ⛓ [Retrieval-Augmented Generation (RAG) using LangChain and `Pinecone` - The RAG Special Episode](https://youtu.be/J_tCD_J6w3s?si=60Mnr5VD9UED9bGG) by [Generative AI and Data Science On AWS](https://www.youtube.com/@GenerativeAIDataScienceOnAWS)
+- ⛓ [Retrieval-Augmented Generation (RAG) using LangChain and `Pinecone` - The RAG Special Episode](https://youtu.be/J_tCD_J6w3s?si=60Mnr5VD9UED9bGG) by [Generative AI and Data Science On AWS](https://www.youtube.com/@GenerativeAIOnAWS)
 - ⛓ [`LLAMA2 70b-chat` Multiple Documents Chatbot with Langchain & Streamlit |All OPEN SOURCE|Replicate API](https://youtu.be/vhghB81vViM?si=dszzJnArMeac7lyc) by [DataInsightEdge](https://www.youtube.com/@DataInsightEdge01)
 - ⛓ [Chatting with 44K Fashion Products: LangChain Opportunities and Pitfalls](https://youtu.be/Zudgske0F_s?si=8HSshHoEhh0PemJA) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
 - ⛓ [Structured Data Extraction from `ChatGPT` with LangChain](https://youtu.be/q1lYg8JISpQ?si=0HctzOHYZvq62sve) by [MG](https://www.youtube.com/@MG_cafe)

docs/docs/contributing/integrations.mdx

@@ -14,19 +14,20 @@ For the most part, new integrations should be added to the Community package. Pa
 
 In the following sections, we'll walk through how to contribute to each of these packages from a fake company, `Parrot Link AI`.
 
-## Community Package
+## Community package
 
 The `langchain-community` package is in `libs/community` and contains most integrations.
 
-It is installed by users with `pip install langchain-community`, and exported members can be imported with code like 
+It can be installed with `pip install langchain-community`, and exported members can be imported with code like 
 
 ```python
-from langchain_community.chat_models import ParrotLinkLLM
-from langchain_community.llms import ChatParrotLink
+from langchain_community.chat_models import ChatParrotLink
+from langchain_community.llms import ParrotLinkLLM
 from langchain_community.vectorstores import ParrotLinkVectorStore
 ```
 
-The community package relies on manually-installed dependent packages, so you will see errors if you try to import a package that is not installed. In our fake example, if you tried to import `ParrotLinkLLM` without installing `parrot-link-sdk`, you will see an `ImportError` telling you to install it when trying to use it.
+The `community` package relies on manually-installed dependent packages, so you will see errors 
+if you try to import a package that is not installed. In our fake example, if you tried to import `ParrotLinkLLM` without installing `parrot-link-sdk`, you will see an `ImportError` telling you to install it when trying to use it.
 
 Let's say we wanted to implement a chat model for Parrot Link AI. We would create a new file in `libs/community/langchain_community/chat_models/parrot_link.py` with the following code:
 
@@ -39,7 +40,7 @@ class ChatParrotLink(BaseChatModel):
     Example:
         .. code-block:: python
 
-            from langchain_parrot_link import ChatParrotLink
+            from langchain_community.chat_models import ChatParrotLink
 
             model = ChatParrotLink()
     """
@@ -56,9 +57,16 @@ And add documentation to:
 
 - `docs/docs/integrations/chat/parrot_link.ipynb`
 
-## Partner Packages
+## Partner package in LangChain repo
 
-Partner packages are in `libs/partners/*` and are installed by users with `pip install langchain-{partner}`, and exported members can be imported with code like 
+Partner packages can be hosted in the `LangChain` monorepo or in an external repo.
+
+Partner package in the `LangChain` repo is placed in `libs/partners/{partner}` 
+and the package source code is in `libs/partners/{partner}/langchain_{partner}`.
+
+A package is 
+installed by users with `pip install langchain-{partner}`, and the package members 
+can be imported with code like:
 
 ```python
 from langchain_{partner} import X
@@ -123,13 +131,49 @@ By default, this will include stubs for a Chat Model, an LLM, and/or a Vector St
 
 ### Write Unit and Integration Tests
 
-Some basic tests are generated in the tests/ directory. You should add more tests to cover your package's functionality.
+Some basic tests are presented in the `tests/` directory. You should add more tests to cover your package's functionality.
 
 For information on running and implementing tests, see the [Testing guide](./testing).
 
 ### Write documentation
 
-Documentation is generated from Jupyter notebooks in the `docs/` directory. You should move the generated notebooks to the relevant `docs/docs/integrations` directory in the monorepo root.
+Documentation is generated from Jupyter notebooks in the `docs/` directory. You should place the notebooks with examples
+to the relevant `docs/docs/integrations` directory in the monorepo root.
+
+### (If Necessary) Deprecate community integration
+
+Note: this is only necessary if you're migrating an existing community integration into 
+a partner package. If the component you're integrating is net-new to LangChain (i.e. 
+not already in the `community` package), you can skip this step.
+
+Let's pretend we migrated our `ChatParrotLink` chat model from the community package to 
+the partner package. We would need to deprecate the old model in the community package.
+
+We would do that by adding a `@deprecated` decorator to the old model as follows, in
+`libs/community/langchain_community/chat_models/parrot_link.py`.
+
+Before our change, our chat model might look like this:
+
+```python
+class ChatParrotLink(BaseChatModel):
+  ...
+```
+
+After our change, it would look like this:
+
+```python
+from langchain_core._api.deprecation import deprecated
+
+@deprecated(
+    since="0.0.<next community version>", 
+    removal="0.2.0", 
+    alternative_import="langchain_parrot_link.ChatParrotLink"
+)
+class ChatParrotLink(BaseChatModel):
+  ...
+```
+
+You should do this for *each* component that you're migrating to the partner package.
 
 ### Additional steps
 
@@ -143,3 +187,15 @@ Maintainer steps (Contributors should **not** do these):
 - [ ] set up pypi and test pypi projects
 - [ ] add credential secrets to Github Actions
 - [ ] add package to conda-forge
+
+## Partner package in external repo
+
+If you are creating a partner package in an external repo, you should follow the same steps as above, 
+but you will need to set up your own CI/CD and package management.
+
+Name your package as `langchain-{partner}-{integration}`.
+
+Still, you have to create the `libs/partners/{partner}-{integration}` folder in the `LangChain` monorepo
+and add a `README.md` file with a link to the external repo. 
+See this [example](https://github.com/langchain-ai/langchain/tree/master/libs/partners/google-genai).
+This allows keeping track of all the partner packages in the `LangChain` documentation.

docs/docs/expression_language/cookbook/multiple_chains.ipynb

@@ -20,9 +20,11 @@
    ]
   },
   {
-   "cell_type": "raw",
+   "cell_type": "code",
    "id": "0f316b5c",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  langchain langchain-openai"
    ]

docs/docs/expression_language/cookbook/prompt_size.ipynb

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

docs/docs/expression_language/cookbook/sql_db.ipynb

@@ -20,9 +20,11 @@
    ]
   },
   {
-   "cell_type": "raw",
+   "cell_type": "code",
    "id": "b3121aa8",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  langchain langchain-openai"
    ]

docs/docs/expression_language/get_started.ipynb

@@ -31,13 +31,42 @@
    ]
   },
   {
-   "cell_type": "raw",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "278b0027",
    "metadata": {},
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  langchain-core langchain-community langchain-openai"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "c3d54f72",
+   "metadata": {},
+   "source": [
+    "```{=mdx}\n",
+    "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
+    "\n",
+    "<ChatModelTabs openaiParams={`model=\"gpt-4\"`} />\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9eed8e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | output: false\n",
+    "# | echo: false\n",
+    "\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(model=\"gpt-4\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -58,10 +87,8 @@
    "source": [
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_openai import ChatOpenAI\n",
     "\n",
     "prompt = ChatPromptTemplate.from_template(\"tell me a short joke about {topic}\")\n",
-    "model = ChatOpenAI(model=\"gpt-4\")\n",
     "output_parser = StrOutputParser()\n",
     "\n",
     "chain = prompt | model | output_parser\n",
@@ -74,15 +101,15 @@
    "id": "81c502c5-85ee-4f36-aaf4-d6e350b7792f",
    "metadata": {},
    "source": [
-    "Notice this line of this code, where we piece together then different components into a single chain using LCEL:\n",
+    "Notice this line of the code, where we piece together these different components into a single chain using LCEL:\n",
     "\n",
     "```\n",
     "chain = prompt | model | output_parser\n",
     "```\n",
     "\n",
-    "The `|` symbol is similar to a [unix pipe operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)), which chains together the different components feeds the output from one component as input into the next component. \n",
+    "The `|` symbol is similar to a [unix pipe operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)), which chains together the different components, feeding the output from one component as input into the next component. \n",
     "\n",
-    "In this chain the user input is passed to the prompt template, then the prompt template output is passed to the model, then the model output is passed to the output parser. Let's take a look at each component individually to really understand what's going on. "
+    "In this chain the user input is passed to the prompt template, then the prompt template output is passed to the model, then the model output is passed to the output parser. Let's take a look at each component individually to really understand what's going on."
    ]
   },
   {
@@ -217,7 +244,7 @@
     }
    ],
    "source": [
-    "from langchain_openai.llms import OpenAI\n",
+    "from langchain_openai import OpenAI\n",
     "\n",
     "llm = OpenAI(model=\"gpt-3.5-turbo-instruct\")\n",
     "llm.invoke(prompt_value)"
@@ -231,7 +258,7 @@
     "### 3. Output parser\n",
     "\n",
     "And lastly we pass our `model` output to the `output_parser`, which is a `BaseOutputParser` meaning it takes either a string or a \n",
-    "`BaseMessage` as input. The `StrOutputParser` specifically simple converts any input into a string."
+    "`BaseMessage` as input. The specific `StrOutputParser` simply converts any input into a string."
    ]
   },
   {
@@ -291,7 +318,7 @@
    "source": [
     ":::info\n",
     "\n",
-    "Note that if you’re curious about the output of any components, you can always test out a smaller version of the chain such as `prompt`  or `prompt | model` to see the intermediate results:\n",
+    "Note that if you’re curious about the output of any components, you can always test out a smaller version of the chain such as `prompt` or `prompt | model` to see the intermediate results:\n",
     "\n",
     ":::"
    ]
@@ -319,7 +346,17 @@
    "source": [
     "## RAG Search Example\n",
     "\n",
-    "For our next example, we want to run a retrieval-augmented generation chain to add some context when responding to questions. "
+    "For our next example, we want to run a retrieval-augmented generation chain to add some context when responding to questions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8fe8eb4",
+   "metadata": {},
+   "source": [
+    "```{=mdx}\n",
+    "<ChatModelTabs />\n",
+    "```"
    ]
   },
   {
@@ -336,8 +373,7 @@
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
     "from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n",
-    "from langchain_openai.chat_models import ChatOpenAI\n",
-    "from langchain_openai.embeddings import OpenAIEmbeddings\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "vectorstore = DocArrayInMemorySearch.from_texts(\n",
     "    [\"harrison worked at kensho\", \"bears like to eat honey\"],\n",
@@ -351,7 +387,6 @@
     "Question: {question}\n",
     "\"\"\"\n",
     "prompt = ChatPromptTemplate.from_template(template)\n",
-    "model = ChatOpenAI()\n",
     "output_parser = StrOutputParser()\n",
     "\n",
     "setup_and_retrieval = RunnableParallel(\n",
@@ -449,7 +484,7 @@
     "With the flow being:\n",
     "\n",
     "1. The first steps create a `RunnableParallel` object with two entries.  The first entry, `context` will include the document results fetched by the retriever. The second entry, `question` will contain the user’s original question. To pass on the question, we use `RunnablePassthrough` to copy this entry. \n",
-    "2. Feed the dictionary from the step above to the `prompt` component. It then takes the user input which is `question` as well as the retrieved document which is `context` to construct a prompt and output a PromptValue.  \n",
+    "2. Feed the dictionary from the step above to the `prompt` component. It then takes the user input which is `question` as well as the retrieved document which is `context` to construct a prompt and output a PromptValue. \n",
     "3. The `model` component takes the generated prompt, and passes into the OpenAI LLM model for evaluation. The generated output from the model is a `ChatMessage` object. \n",
     "4. Finally, the `output_parser` component takes in a `ChatMessage`, and transforms this into a Python string, which is returned from the invoke method.\n",
     "\n",
@@ -494,7 +529,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/configure.ipynb

@@ -557,7 +557,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "openai_poem = chain.with_config(configurable={\"llm\": \"openai\"})"
+    "openai_joke = chain.with_config(configurable={\"llm\": \"openai\"})"
    ]
   },
   {
@@ -578,7 +578,7 @@
     }
    ],
    "source": [
-    "openai_poem.invoke({\"topic\": \"bears\"})"
+    "openai_joke.invoke({\"topic\": \"bears\"})"
    ]
   },
   {

docs/docs/expression_language/how_to/message_history.ipynb

@@ -552,7 +552,7 @@
    "id": "da3d1feb-b4bb-4624-961c-7db2e1180df7",
    "metadata": {},
    "source": [
-    ":::tip\n",
+    ":::{.callout-tip}\n",
     "\n",
     "[Langsmith trace](https://smith.langchain.com/public/bd73e122-6ec1-48b2-82df-e6483dc9cb63/r)\n",
     "\n",

docs/docs/expression_language/how_to/routing.ipynb

@@ -1,7 +1,7 @@
 {
  "cells": [
   {
-   "cell_type": "markdown",
+   "cell_type": "raw",
    "id": "9e45e81c-e16e-4c6c-b6a3-2362e5193827",
    "metadata": {},
    "source": [
@@ -25,53 +25,42 @@
     "\n",
     "There are two ways to perform routing:\n",
     "\n",
-    "1. Using a `RunnableBranch`.\n",
-    "2. Writing custom factory function that takes the input of a previous step and returns a **runnable**. Importantly, this should return a **runnable** and NOT actually execute.\n",
+    "1. Conditionally return runnables from a [`RunnableLambda`](./functions) (recommended)\n",
+    "2. Using a `RunnableBranch`.\n",
     "\n",
     "We'll illustrate both methods using a two step sequence where the first step classifies an input question as being about `LangChain`, `Anthropic`, or `Other`, then routes to a corresponding prompt chain."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f885113d",
-   "metadata": {},
-   "source": [
-    "## Using a RunnableBranch\n",
-    "\n",
-    "A `RunnableBranch` is initialized with a list of (condition, runnable) pairs and a default runnable. It selects which branch by passing each condition the input it's invoked with. It selects the first condition to evaluate to True, and runs the corresponding runnable to that condition with the input. \n",
-    "\n",
-    "If no provided conditions match, it runs the default runnable.\n",
-    "\n",
-    "Here's an example of what it looks like in action:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "1aa13c1d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain_community.chat_models import ChatAnthropic\n",
-    "from langchain_core.output_parsers import StrOutputParser"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ed84c59a",
+   "id": "c1c6edac",
    "metadata": {},
    "source": [
+    "## Example Setup\n",
     "First, let's create a chain that will identify incoming questions as being about `LangChain`, `Anthropic`, or `Other`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "3ec03886",
+   "execution_count": null,
+   "id": "8a8a1967",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' Anthropic'"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
+    "from langchain_community.chat_models import ChatAnthropic\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "\n",
     "chain = (\n",
     "    PromptTemplate.from_template(\n",
     "        \"\"\"Given the user question below, classify it as either being about `LangChain`, `Anthropic`, or `Other`.\n",
@@ -86,33 +75,14 @@
     "    )\n",
     "    | ChatAnthropic()\n",
     "    | StrOutputParser()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "87ae7c1c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "' Anthropic'"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
+    ")\n",
+    "\n",
     "chain.invoke({\"question\": \"how do I call Anthropic?\"})"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "8aa0a365",
+   "id": "7655555f",
    "metadata": {},
    "source": [
     "Now, let's create three sub chains:"
@@ -120,8 +90,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "d479962a",
+   "execution_count": null,
+   "id": "89d7722d",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -158,101 +128,12 @@
     ")"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "593eab06",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.runnables import RunnableBranch\n",
-    "\n",
-    "branch = RunnableBranch(\n",
-    "    (lambda x: \"anthropic\" in x[\"topic\"].lower(), anthropic_chain),\n",
-    "    (lambda x: \"langchain\" in x[\"topic\"].lower(), langchain_chain),\n",
-    "    general_chain,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "752c732e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "full_chain = {\"topic\": chain, \"question\": lambda x: x[\"question\"]} | branch"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "29231bb8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content=\" As Dario Amodei told me, here are some ways to use Anthropic:\\n\\n- Sign up for an account on Anthropic's website to access tools like Claude, Constitutional AI, and Writer. \\n\\n- Use Claude for tasks like email generation, customer service chat, and QA. Claude can understand natural language prompts and provide helpful responses.\\n\\n- Use Constitutional AI if you need an AI assistant that is harmless, honest, and helpful. It is designed to be safe and aligned with human values.\\n\\n- Use Writer to generate natural language content for things like marketing copy, stories, reports, and more. Give it a topic and prompt and it will create high-quality written content.\\n\\n- Check out Anthropic's documentation and blog for tips, tutorials, examples, and announcements about new capabilities as they continue to develop their AI technology.\\n\\n- Follow Anthropic on social media or subscribe to their newsletter to stay up to date on new features and releases.\\n\\n- For most people, the easiest way to leverage Anthropic's technology is through their website - just create an account to get started!\", additional_kwargs={}, example=False)"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "full_chain.invoke({\"question\": \"how do I use Anthropic?\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "c67d8733",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content=' As Harrison Chase told me, here is how you use LangChain:\\n\\nLangChain is an AI assistant that can have conversations, answer questions, and generate text. To use LangChain, you simply type or speak your input and LangChain will respond. \\n\\nYou can ask LangChain questions, have discussions, get summaries or explanations about topics, and request it to generate text on a subject. Some examples of interactions:\\n\\n- Ask general knowledge questions and LangChain will try to answer factually. For example \"What is the capital of France?\"\\n\\n- Have conversations on topics by taking turns speaking. You can prompt the start of a conversation by saying something like \"Let\\'s discuss machine learning\"\\n\\n- Ask for summaries or high-level explanations on subjects. For example \"Can you summarize the main themes in Shakespeare\\'s Hamlet?\" \\n\\n- Give creative writing prompts or requests to have LangChain generate text in different styles. For example \"Write a short children\\'s story about a mouse\" or \"Generate a poem in the style of Robert Frost about nature\"\\n\\n- Correct LangChain if it makes an inaccurate statement and provide the right information. This helps train it.\\n\\nThe key is interacting naturally and giving it clear prompts and requests', additional_kwargs={}, example=False)"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "full_chain.invoke({\"question\": \"how do I use LangChain?\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "935ad949",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content=' 2 + 2 = 4', additional_kwargs={}, example=False)"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "full_chain.invoke({\"question\": \"whats 2 + 2\"})"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "6d8d042c",
    "metadata": {},
    "source": [
-    "## Using a custom function\n",
+    "## Using a custom function (Recommended)\n",
     "\n",
     "You can also use a custom function to route between different outputs. Here's an example:"
    ]
@@ -350,13 +231,89 @@
     "full_chain.invoke({\"question\": \"whats 2 + 2\"})"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "5147b827",
+   "metadata": {},
+   "source": [
+    "## Using a RunnableBranch\n",
+    "\n",
+    "A `RunnableBranch` is a special type of runnable that allows you to define a set of conditions and runnables to execute based on the input. It does **not** offer anything that you can't achieve in a custom function as described above, so we recommend using a custom function instead.\n",
+    "\n",
+    "A `RunnableBranch` is initialized with a list of (condition, runnable) pairs and a default runnable. It selects which branch by passing each condition the input it's invoked with. It selects the first condition to evaluate to True, and runs the corresponding runnable to that condition with the input. \n",
+    "\n",
+    "If no provided conditions match, it runs the default runnable.\n",
+    "\n",
+    "Here's an example of what it looks like in action:"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "46802d04",
+   "id": "2a101418",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\" As Dario Amodei told me, here are some ways to use Anthropic:\\n\\n- Sign up for an account on Anthropic's website to access tools like Claude, Constitutional AI, and Writer. \\n\\n- Use Claude for tasks like email generation, customer service chat, and QA. Claude can understand natural language prompts and provide helpful responses.\\n\\n- Use Constitutional AI if you need an AI assistant that is harmless, honest, and helpful. It is designed to be safe and aligned with human values.\\n\\n- Use Writer to generate natural language content for things like marketing copy, stories, reports, and more. Give it a topic and prompt and it will create high-quality written content.\\n\\n- Check out Anthropic's documentation and blog for tips, tutorials, examples, and announcements about new capabilities as they continue to develop their AI technology.\\n\\n- Follow Anthropic on social media or subscribe to their newsletter to stay up to date on new features and releases.\\n\\n- For most people, the easiest way to leverage Anthropic's technology is through their website - just create an account to get started!\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from langchain_core.runnables import RunnableBranch\n",
+    "\n",
+    "branch = RunnableBranch(\n",
+    "    (lambda x: \"anthropic\" in x[\"topic\"].lower(), anthropic_chain),\n",
+    "    (lambda x: \"langchain\" in x[\"topic\"].lower(), langchain_chain),\n",
+    "    general_chain,\n",
+    ")\n",
+    "full_chain = {\"topic\": chain, \"question\": lambda x: x[\"question\"]} | branch\n",
+    "full_chain.invoke({\"question\": \"how do I use Anthropic?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d8caf9b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' As Harrison Chase told me, here is how you use LangChain:\\n\\nLangChain is an AI assistant that can have conversations, answer questions, and generate text. To use LangChain, you simply type or speak your input and LangChain will respond. \\n\\nYou can ask LangChain questions, have discussions, get summaries or explanations about topics, and request it to generate text on a subject. Some examples of interactions:\\n\\n- Ask general knowledge questions and LangChain will try to answer factually. For example \"What is the capital of France?\"\\n\\n- Have conversations on topics by taking turns speaking. You can prompt the start of a conversation by saying something like \"Let\\'s discuss machine learning\"\\n\\n- Ask for summaries or high-level explanations on subjects. For example \"Can you summarize the main themes in Shakespeare\\'s Hamlet?\" \\n\\n- Give creative writing prompts or requests to have LangChain generate text in different styles. For example \"Write a short children\\'s story about a mouse\" or \"Generate a poem in the style of Robert Frost about nature\"\\n\\n- Correct LangChain if it makes an inaccurate statement and provide the right information. This helps train it.\\n\\nThe key is interacting naturally and giving it clear prompts and requests', additional_kwargs={}, example=False)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"how do I use LangChain?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26159af7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' 2 + 2 = 4', additional_kwargs={}, example=False)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"whats 2 + 2\"})"
+   ]
   }
  ],
  "metadata": {

docs/docs/expression_language/streaming.ipynb

@@ -12,7 +12,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "bb7d49db-04d3-4399-bfe1-09f82bbe6015",
    "metadata": {},
@@ -28,7 +27,7 @@
     "1. sync `stream` and async `astream`: a **default implementation** of streaming that streams the **final output** from the chain.\n",
     "2. async `astream_events` and async `astream_log`: these provide a way to stream both **intermediate steps** and **final output** from the chain.\n",
     "\n",
-    "Let's take a look at both approaches, and try to understand a how to use them. 🥷\n",
+    "Let's take a look at both approaches, and try to understand how to use them. 🥷\n",
     "\n",
     "## Using Stream\n",
     "\n",
@@ -48,7 +47,25 @@
     "\n",
     "Large language models can take **several seconds** to generate a complete response to a query. This is far slower than the **~200-300 ms** threshold at which an application feels responsive to an end user.\n",
     "\n",
-    "The key strategy to make the application feel more responsive is to show intermediate progress; e.g., to stream the output from the model **token by token**."
+    "The key strategy to make the application feel more responsive is to show intermediate progress; viz., to stream the output from the model **token by token**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9eb73e8b",
+   "metadata": {},
+   "source": [
+    "We will show examples of streaming using the chat model from [Anthropic](/docs/integrations/platforms/anthropic). To use the model, you will need to install the `langchain-anthropic` package. You can do this with the following command:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd351cf4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pip install -qU langchain-anthropic"
    ]
   },
   {
@@ -68,7 +85,7 @@
    "source": [
     "# Showing the example using anthropic, but you can use\n",
     "# your favorite chat model!\n",
-    "from langchain_community.chat_models import ChatAnthropic\n",
+    "from langchain_anthropic import ChatAnthropic\n",
     "\n",
     "model = ChatAnthropic()\n",
     "\n",
@@ -152,7 +169,7 @@
     "We will use `StrOutputParser` to parse the output from the model. This is a simple parser that extracts the `content` field from an `AIMessageChunk`, giving us the `token` returned by the model.\n",
     "\n",
     ":::{.callout-tip}\n",
-    "LCEL is a *declarative* way to specify a \"program\" by chainining together different LangChain primitives. Chains created using LCEL benefit from an automatic implementation of `stream`, and `astream` allowing streaming of the final output. In fact, chains created with LCEL implement the entire standard Runnable interface.\n",
+    "LCEL is a *declarative* way to specify a \"program\" by chainining together different LangChain primitives. Chains created using LCEL benefit from an automatic implementation of `stream` and `astream` allowing streaming of the final output. In fact, chains created with LCEL implement the entire standard Runnable interface.\n",
     ":::"
    ]
   },
@@ -330,7 +347,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "cab6dca2-2027-414d-a196-2db6e3ebb8a5",
    "metadata": {},
@@ -464,12 +480,12 @@
    "id": "6fd3e71b-439e-418f-8a8a-5232fba3d9fd",
    "metadata": {},
    "source": [
-    "Stream just yielded the final result from that component. \n",
+    "Stream just yielded the final result from that component.\n",
     "\n",
     "This is OK 🥹! Not all components have to implement streaming -- in some cases streaming is either unnecessary, difficult or just doesn't make sense.\n",
     "\n",
     ":::{.callout-tip}\n",
-    "An LCEL chain constructed using using non-streaming components, will still be able to stream in a lot of cases, with streaming of partial output starting after the last non-streaming step in the chain.\n",
+    "An LCEL chain constructed using non-streaming components, will still be able to stream in a lot of cases, with streaming of partial output starting after the last non-streaming step in the chain.\n",
     ":::"
    ]
   },
@@ -642,7 +658,7 @@
     "\n",
     "This is a **beta API**, and we're almost certainly going to make some changes to it.\n",
     "\n",
-    "This version parameter will allow us to mimimize such breaking changes to your code. \n",
+    "This version parameter will allow us to minimize such breaking changes to your code. \n",
     "\n",
     "In short, we are annoying you now, so we don't have to annoy you later.\n",
     ":::"
@@ -1397,7 +1413,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,

docs/docs/get_started/introduction.mdx

@@ -14,7 +14,16 @@ This framework consists of several parts.
 - **[LangServe](/docs/langserve)**: A library for deploying LangChain chains as a REST API.
 - **[LangSmith](/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
 
-![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](/svg/langchain_stack.svg "LangChain Framework Overview")
+import ThemedImage from '@theme/ThemedImage';
+
+<ThemedImage
+  alt="Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers."
+  sources={{
+    light: '/svg/langchain_stack.svg',
+    dark: '/svg/langchain_stack_dark.svg',
+  }}
+  title="LangChain Framework Overview"
+/>
 
 Together, these products simplify the entire application lifecycle:
 - **Develop**: Write your applications in LangChain/LangChain.js. Hit the ground running using Templates for reference.

docs/docs/get_started/quickstart.mdx

@@ -14,7 +14,7 @@ That's a fair amount to cover! Let's dive in.
 
 ### Jupyter Notebook
 
-This guide (and most of the other guides in the documentation) use [Jupyter notebooks](https://jupyter.org/) and assume the reader is as well. Jupyter notebooks are perfect for learning how to work with LLM systems because often times things can go wrong (unexpected output, API down, etc) and going through guides in an interactive environment is a great way to better understand them.
+This guide (and most of the other guides in the documentation) uses [Jupyter notebooks](https://jupyter.org/) and assumes the reader is as well. Jupyter notebooks are perfect for learning how to work with LLM systems because oftentimes things can go wrong (unexpected output, API down, etc) and going through guides in an interactive environment is a great way to better understand them.
 
 You do not NEED to go through the guide in a Jupyter Notebook, but it is recommended. See [here](https://jupyter.org/install) for instructions on how to install.
 
@@ -65,7 +65,7 @@ We will link to relevant docs.
 
 ## LLM Chain
 
-For this getting started guide, we will provide two options: using OpenAI (a popular model available via API) or using a local open source model.
+We'll show how to use models available via API, like OpenAI, and local open source models, using integrations like Ollama.
 
 <Tabs>
   <TabItem value="openai" label="OpenAI" default>
@@ -99,7 +99,7 @@ llm = ChatOpenAI(openai_api_key="...")
 ```
 
   </TabItem>
-  <TabItem value="local" label="Local">
+  <TabItem value="local" label="Local (using Ollama)">
 
 [Ollama](https://ollama.ai/) allows you to run open-source large language models, such as Llama 2, locally.
 
@@ -112,6 +112,66 @@ Then, make sure the Ollama server is running. After that, you can do:
 ```python
 from langchain_community.llms import Ollama
 llm = Ollama(model="llama2")
+```
+
+  </TabItem>
+  <TabItem value="anthropic" label="Anthropic">
+
+First we'll need to import the LangChain x Anthropic package.
+
+```shell
+pip install langchain-anthropic
+```
+
+Accessing the API requires an API key, which you can get by creating an account [here](https://claude.ai/login). Once we have a key we'll want to set it as an environment variable by running:
+
+```shell
+export ANTHROPIC_API_KEY="..."
+```
+
+We can then initialize the model:
+
+```python
+from langchain_anthropic import ChatAnthropic
+
+llm = ChatAnthropic(model="claude-3-sonnet-20240229", temperature=0.2, max_tokens=1024)
+```
+
+If you'd prefer not to set an environment variable you can pass the key in directly via the `anthropic_api_key` named parameter when initiating the Anthropic Chat Model class:
+
+```python
+llm = ChatAnthropic(anthropic_api_key="...")
+```
+
+  </TabItem>
+  <TabItem value="cohere" label="Cohere">
+
+First we'll need to import the Cohere SDK package.
+
+```shell
+pip install cohere
+```
+
+Accessing the API requires an API key, which you can get by creating an account and heading [here](https://dashboard.cohere.com/api-keys). Once we have a key we'll want to set it as an environment variable by running:
+
+```shell
+export COHERE_API_KEY="..."
+```
+
+We can then initialize the model:
+
+```python
+from langchain_community.chat_models import ChatCohere
+
+llm = ChatCohere()
+```
+
+If you'd prefer not to set an environment variable you can pass the key in directly via the `cohere_api_key` named parameter when initiating the Cohere LLM class:
+
+```python
+from langchain_community.chat_models import ChatCohere
+
+llm = ChatCohere(cohere_api_key="...")
 ```
 
   </TabItem>
@@ -124,8 +184,8 @@ Let's ask it what LangSmith is - this is something that wasn't present in the tr
 llm.invoke("how can langsmith help with testing?")
 ```
 
-We can also guide it's response with a prompt template.
-Prompt templates are used to convert raw user input to a better input to the LLM.
+We can also guide its response with a prompt template.
+Prompt templates convert raw user input to better input to the LLM.
 
 ```python
 from langchain_core.prompts import ChatPromptTemplate
@@ -174,7 +234,7 @@ We've now successfully set up a basic LLM chain. We only touched on the basics o
 
 ## Retrieval Chain
 
-In order to properly answer the original question ("how can langsmith help with testing?"), we need to provide additional context to the LLM.
+To properly answer the original question ("how can langsmith help with testing?"), we need to provide additional context to the LLM.
 We can do this via *retrieval*.
 Retrieval is useful when you have **too much data** to pass to the LLM directly.
 You can then use a retriever to fetch only the most relevant pieces and pass those in.
@@ -182,7 +242,7 @@ You can then use a retriever to fetch only the most relevant pieces and pass tho
 In this process, we will look up relevant documents from a *Retriever* and then pass them into the prompt.
 A Retriever can be backed by anything - a SQL table, the internet, etc - but in this instance we will populate a vector store and use that as a retriever. For more information on vectorstores, see [this documentation](/docs/modules/data_connection/vectorstores).
 
-First, we need to load the data that we want to index. In order to do this, we will use the WebBaseLoader. This requires installing [BeautifulSoup](https://beautiful-soup-4.readthedocs.io/en/latest/):
+First, we need to load the data that we want to index. To do this, we will use the WebBaseLoader. This requires installing [BeautifulSoup](https://beautiful-soup-4.readthedocs.io/en/latest/):
 
 ```shell
 pip install beautifulsoup4
@@ -193,17 +253,17 @@ After that, we can import and use WebBaseLoader.
 
 ```python
 from langchain_community.document_loaders import WebBaseLoader
-loader = WebBaseLoader("https://docs.smith.langchain.com")
+loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
 
 docs = loader.load()
 ```
 
 Next, we need to index it into a vectorstore. This requires a few components, namely an [embedding model](/docs/modules/data_connection/text_embedding) and a [vectorstore](/docs/modules/data_connection/vectorstores).
 
-For embedding models, we once again provide examples for accessing via OpenAI or via local models.
+For embedding models, we once again provide examples for accessing via API or by running local models.
 
 <Tabs>
-  <TabItem value="openai" label="OpenAI" default>
+  <TabItem value="openai" label="OpenAI (API)" default>
   
 Make sure you have the `langchain_openai` package installed an the appropriate environment variables set (these are the same as needed for the LLM).
 
@@ -214,7 +274,7 @@ embeddings = OpenAIEmbeddings()
 ```
 
 </TabItem>
-<TabItem value="local" label="Local">
+<TabItem value="local" label="Local (using Ollama)">
 
 Make sure you have Ollama running (same set up as with the LLM).
 
@@ -224,6 +284,17 @@ from langchain_community.embeddings import OllamaEmbeddings
 embeddings = OllamaEmbeddings()
 ```
   </TabItem>
+<TabItem value="cohere" label="Cohere (API)" default>
+
+Make sure you have the `cohere` package installed and the appropriate environment variables set (these are the same as needed for the LLM).
+
+```python
+from langchain_community.embeddings import CohereEmbeddings
+
+embeddings = CohereEmbeddings()
+```
+
+</TabItem>
 </Tabs>
 
 Now, we can use this embedding model to ingest documents into a vectorstore.
@@ -239,7 +310,7 @@ Then we can build our index:
 
 ```python
 from langchain_community.vectorstores import FAISS
-from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 
 
 text_splitter = RecursiveCharacterTextSplitter()
@@ -278,7 +349,7 @@ document_chain.invoke({
 ```
 
 However, we want the documents to first come from the retriever we just set up.
-That way, for a given question we can use the retriever to dynamically select the most relevant documents and pass those in.
+That way, we can use the retriever to dynamically select the most relevant documents and pass those in for a given question.
 
 ```python
 from langchain.chains import create_retrieval_chain
@@ -324,12 +395,12 @@ from langchain_core.prompts import MessagesPlaceholder
 prompt = ChatPromptTemplate.from_messages([
     MessagesPlaceholder(variable_name="chat_history"),
     ("user", "{input}"),
-    ("user", "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation")
+    ("user", "Given the above conversation, generate a search query to look up to get information relevant to the conversation")
 ])
 retriever_chain = create_history_aware_retriever(llm, retriever, prompt)
 ```
 
-We can test this out by passing in an instance where the user is asking a follow up question.
+We can test this out by passing in an instance where the user asks a follow-up question.
 
 ```python
 from langchain_core.messages import HumanMessage, AIMessage
@@ -340,7 +411,7 @@ retriever_chain.invoke({
     "input": "Tell me how"
 })
 ```
-You should see that this returns documents about testing in LangSmith. This is because the LLM generated a new query, combining the chat history with the follow up question.
+You should see that this returns documents about testing in LangSmith. This is because the LLM generated a new query, combining the chat history with the follow-up question.
 
 Now that we have this new retriever, we can create a new chain to continue the conversation with these retrieved documents in mind.
 
@@ -368,7 +439,7 @@ We can see that this gives a coherent answer - we've successfully turned our ret
 
 ## Agent
 
-We've so far create examples of chains - where each step is known ahead of time.
+We've so far created examples of chains - where each step is known ahead of time.
 The final thing we will create is an agent - where the LLM decides what steps to take.
 
 **NOTE: for this example we will only show how to create an agent using OpenAI models, as local models are not reliable enough yet.**
@@ -377,7 +448,7 @@ One of the first things to do when building an agent is to decide what tools it
 For this example, we will give the agent access to two tools:
 
 1. The retriever we just created. This will let it easily answer questions about LangSmith
-2. A search tool. This will let it easily answer questions that require up to date information.
+2. A search tool. This will let it easily answer questions that require up-to-date information.
 
 First, let's set up a tool for the retriever we just created:
 
@@ -417,6 +488,11 @@ Install langchain hub first
 ```bash
 pip install langchainhub
 ```
+Install the langchain-openai package
+To interact with OpenAI we need to use langchain-openai which connects with OpenAI SDK[https://github.com/langchain-ai/langchain/tree/master/libs/partners/openai].  
+```bash
+pip install langchain-openai
+```
 
 Now we can use it to get a predefined prompt
 
@@ -428,6 +504,8 @@ from langchain.agents import AgentExecutor
 
 # Get the prompt to use - you can modify this!
 prompt = hub.pull("hwchase17/openai-functions-agent")
+
+# You need to set OPENAI_API_KEY environment variable or pass it as argument `openai_api_key`.
 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
 agent = create_openai_functions_agent(llm, tools, prompt)
 agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
@@ -489,10 +567,9 @@ from langchain_openai import ChatOpenAI
 from langchain_community.document_loaders import WebBaseLoader
 from langchain_openai import OpenAIEmbeddings
 from langchain_community.vectorstores import FAISS
-from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain.tools.retriever import create_retriever_tool
 from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_openai import ChatOpenAI
 from langchain import hub
 from langchain.agents import create_openai_functions_agent
 from langchain.agents import AgentExecutor
@@ -501,7 +578,7 @@ from langchain_core.messages import BaseMessage
 from langserve import add_routes
 
 # 1. Load Retriever
-loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
+loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
 docs = loader.load()
 text_splitter = RecursiveCharacterTextSplitter()
 documents = text_splitter.split_documents(docs)

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

@@ -17,7 +17,7 @@ Here's a summary of the key methods and properties of a comparison evaluator:
 - `requires_reference`: This property specifies whether this evaluator requires a reference label.
 
 :::note LangSmith Support
-The [run_on_dataset](https://api.python.langchain.com/en/latest/api_reference.html#module-langchain.smith) evaluation method is designed to evaluate only a single model at a time, and thus, doesn't support these evaluators.
+The [run_on_dataset](https://api.python.langchain.com/en/latest/langchain_api_reference.html#module-langchain.smith) evaluation method is designed to evaluate only a single model at a time, and thus, doesn't support these evaluators.
 :::
 
 Detailed information about creating custom evaluators and the available built-in comparison evaluators is provided in the following sections.

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

@@ -294,7 +294,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "prompt_template = PromptTemplate.from_template(\n",
     "    \"\"\"Given the input context, which do you prefer: A or B?\n",

docs/docs/guides/evaluation/index.mdx

@@ -23,7 +23,7 @@ We also are working to share guides and cookbooks that demonstrate how to use th
 
 ## LangSmith Evaluation
 
-LangSmith provides an integrated evaluation and tracing framework that allows you to check for regressions, compare systems, and easily identify and fix any sources of errors and performance issues. Check out the docs on [LangSmith Evaluation](https://docs.smith.langchain.com/category/testing--evaluation) and additional [cookbooks](https://docs.smith.langchain.com/category/langsmith-cookbook) for more detailed information on evaluating your applications.
+LangSmith provides an integrated evaluation and tracing framework that allows you to check for regressions, compare systems, and easily identify and fix any sources of errors and performance issues. Check out the docs on [LangSmith Evaluation](https://docs.smith.langchain.com/evaluation) and additional [cookbooks](https://docs.smith.langchain.com/cookbook) for more detailed information on evaluating your applications.
 
 ## LangChain benchmarks
 
@@ -37,6 +37,6 @@ Check out the docs for examples and leaderboard information.
 
 ## Reference Docs
 
-For detailed information on the available evaluators, including how to instantiate, configure, and customize them, check out the [reference documentation](https://api.python.langchain.com/en/latest/api_reference.html#module-langchain.evaluation) directly.
+For detailed information on the available evaluators, including how to instantiate, configure, and customize them, check out the [reference documentation](https://api.python.langchain.com/en/latest/langchain_api_reference.html#module-langchain.evaluation) directly.
 
 <DocCardList />

docs/docs/guides/evaluation/string/criteria_eval_chain.ipynb

@@ -380,7 +380,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "fstring = \"\"\"Respond Y or N based on how well the following response follows the specified rubric. Grade only based on the rubric and expected response:\n",
     "\n",

docs/docs/guides/evaluation/string/json.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# JSON Evaluators\n",
     "\n",
-    "Evaluating [extraction](https://python.langchain.com/docs/use_cases/extraction) and function calling applications often comes down to validation that the LLM's string output can be parsed correctly and how it compares to a reference object. The following `JSON` validators provide functionality to check your model's output consistently.\n",
+    "Evaluating [extraction](/docs/use_cases/extraction) and function calling applications often comes down to validation that the LLM's string output can be parsed correctly and how it compares to a reference object. The following `JSON` validators provide functionality to check your model's output consistently.\n",
     "\n",
     "## JsonValidityEvaluator\n",
     "\n",

docs/docs/guides/extending_langchain.mdx

@@ -0,0 +1,13 @@
+---
+hide_table_of_contents: true
+---
+
+# Extending LangChain
+
+Extending LangChain's base abstractions, whether you're planning to contribute back to the open-source repo or build a bespoke internal integration, is encouraged.
+
+Check out these guides for building your own custom classes for the following modules:
+
+- [Chat models](/docs/modules/model_io/chat/custom_chat_model) for interfacing with chat-tuned language models.
+- [LLMs](/docs/modules/model_io/llms/custom_llm) for interfacing with text language models.
+- [Output parsers](/docs/modules/model_io/output_parsers/custom) for handling language model outputs.

docs/docs/guides/fallbacks.ipynb

@@ -216,7 +216,7 @@
    "outputs": [],
    "source": [
     "# Now lets create a chain with the normal OpenAI model\n",
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_openai import OpenAI\n",
     "\n",
     "prompt_template = \"\"\"Instructions: You should always include a compliment in your response.\n",

docs/docs/guides/local_llms.ipynb

@@ -9,7 +9,7 @@
     "\n",
     "## Use case\n",
     "\n",
-    "The popularity of projects like [PrivateGPT](https://github.com/imartinez/privateGPT), [llama.cpp](https://github.com/ggerganov/llama.cpp), and [GPT4All](https://github.com/nomic-ai/gpt4all) underscore the demand to run LLMs locally (on your own device).\n",
+    "The popularity of projects like [PrivateGPT](https://github.com/imartinez/privateGPT), [llama.cpp](https://github.com/ggerganov/llama.cpp), [GPT4All](https://github.com/nomic-ai/gpt4all), and [llamafile](https://github.com/Mozilla-Ocho/llamafile) underscore the demand to run LLMs locally (on your own device).\n",
     "\n",
     "This has at least two important benefits:\n",
     "\n",
@@ -46,7 +46,8 @@
     "\n",
     "1. [`llama.cpp`](https://github.com/ggerganov/llama.cpp): C++ implementation of llama inference code with [weight optimization / quantization](https://finbarr.ca/how-is-llama-cpp-possible/)\n",
     "2. [`gpt4all`](https://docs.gpt4all.io/index.html): Optimized C backend for inference\n",
-    "3. [`Ollama`](https://ollama.ai/): Bundles model weights and environment into an app that runs on device and serves the LLM \n",
+    "3. [`Ollama`](https://ollama.ai/): Bundles model weights and environment into an app that runs on device and serves the LLM\n",
+    "4. [`llamafile`](https://github.com/Mozilla-Ocho/llamafile): Bundles model weights and everything needed to run the model in a single file, allowing you to run the LLM locally from this file without any additional installation steps\n",
     "\n",
     "In general, these frameworks will do a few things:\n",
     "\n",
@@ -97,7 +98,7 @@
     "from langchain_community.llms import Ollama\n",
     "\n",
     "llm = Ollama(model=\"llama2\")\n",
-    "llm(\"The first man on the moon was ...\")"
+    "llm.invoke(\"The first man on the moon was ...\")"
    ]
   },
   {
@@ -139,7 +140,7 @@
     "llm = Ollama(\n",
     "    model=\"llama2\", callback_manager=CallbackManager([StreamingStdOutCallbackHandler()])\n",
     ")\n",
-    "llm(\"The first man on the moon was ...\")"
+    "llm.invoke(\"The first man on the moon was ...\")"
    ]
   },
   {
@@ -157,7 +158,7 @@
     "\n",
     "### Running Apple silicon GPU\n",
     "\n",
-    "`Ollama` will automatically utilize the GPU on Apple devices.\n",
+    "`Ollama` and [`llamafile`](https://github.com/Mozilla-Ocho/llamafile?tab=readme-ov-file#gpu-support) will automatically utilize the GPU on Apple devices.\n",
     " \n",
     "Other frameworks require the user to set up the environment to utilize the Apple GPU.\n",
     "\n",
@@ -191,7 +192,7 @@
     "\n",
     "There are various ways to gain access to quantized model weights.\n",
     "\n",
-    "1. [`HuggingFace`](https://huggingface.co/TheBloke) - Many quantized model are available for download and can be run with framework such as [`llama.cpp`](https://github.com/ggerganov/llama.cpp)\n",
+    "1. [`HuggingFace`](https://huggingface.co/TheBloke) - Many quantized model are available for download and can be run with framework such as [`llama.cpp`](https://github.com/ggerganov/llama.cpp). You can also download models in [`llamafile` format](https://huggingface.co/models?other=llamafile) from HuggingFace.\n",
     "2. [`gpt4all`](https://gpt4all.io/index.html) - The model explorer offers a leaderboard of metrics and associated quantized models available for download \n",
     "3. [`Ollama`](https://github.com/jmorganca/ollama) - Several models can be accessed directly via `pull`\n",
     "\n",
@@ -225,7 +226,7 @@
     "from langchain_community.llms import Ollama\n",
     "\n",
     "llm = Ollama(model=\"llama2:13b\")\n",
-    "llm(\"The first man on the moon was ... think step by step\")"
+    "llm.invoke(\"The first man on the moon was ... think step by step\")"
    ]
   },
   {
@@ -368,7 +369,7 @@
     }
    ],
    "source": [
-    "llm(\"The first man on the moon was ... Let's think step by step\")"
+    "llm.invoke(\"The first man on the moon was ... Let's think step by step\")"
    ]
   },
   {
@@ -425,7 +426,63 @@
     }
    ],
    "source": [
-    "llm(\"The first man on the moon was ... Let's think step by step\")"
+    "llm.invoke(\"The first man on the moon was ... Let's think step by step\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "056854e2-5e4b-4a03-be7e-03192e5c4e1e",
+   "metadata": {},
+   "source": [
+    "### llamafile\n",
+    "\n",
+    "One of the simplest ways to run an LLM locally is using a [llamafile](https://github.com/Mozilla-Ocho/llamafile). All you need to do is:\n",
+    "\n",
+    "1) Download a llamafile from [HuggingFace](https://huggingface.co/models?other=llamafile)\n",
+    "2) Make the file executable\n",
+    "3) Run the file\n",
+    "\n",
+    "llamafiles bundle model weights and a [specially-compiled](https://github.com/Mozilla-Ocho/llamafile?tab=readme-ov-file#technical-details) version of [`llama.cpp`](https://github.com/ggerganov/llama.cpp) into a single file that can run on most computers any additional dependencies. They also come with an embedded inference server that provides an [API](https://github.com/Mozilla-Ocho/llamafile/blob/main/llama.cpp/server/README.md#api-endpoints) for interacting with your model. \n",
+    "\n",
+    "Here's a simple bash script that shows all 3 setup steps:\n",
+    "\n",
+    "```bash\n",
+    "# Download a llamafile from HuggingFace\n",
+    "wget https://huggingface.co/jartine/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/TinyLlama-1.1B-Chat-v1.0.Q5_K_M.llamafile\n",
+    "\n",
+    "# Make the file executable. On Windows, instead just rename the file to end in \".exe\".\n",
+    "chmod +x TinyLlama-1.1B-Chat-v1.0.Q5_K_M.llamafile\n",
+    "\n",
+    "# Start the model server. Listens at http://localhost:8080 by default.\n",
+    "./TinyLlama-1.1B-Chat-v1.0.Q5_K_M.llamafile --server --nobrowser\n",
+    "```\n",
+    "\n",
+    "After you run the above setup steps, you can use LangChain to interact with your model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "002e655c-ba18-4db3-ac7b-f33e825d14b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"\\nFirstly, let's imagine the scene where Neil Armstrong stepped onto the moon. This happened in 1969. The first man on the moon was Neil Armstrong. We already know that.\\n2nd, let's take a step back. Neil Armstrong didn't have any special powers. He had to land his spacecraft safely on the moon without injuring anyone or causing any damage. If he failed to do this, he would have been killed along with all those people who were on board the spacecraft.\\n3rd, let's imagine that Neil Armstrong successfully landed his spacecraft on the moon and made it back to Earth safely. The next step was for him to be hailed as a hero by his people back home. It took years before Neil Armstrong became an American hero.\\n4th, let's take another step back. Let's imagine that Neil Armstrong wasn't hailed as a hero, and instead, he was just forgotten. This happened in the 1970s. Neil Armstrong wasn't recognized for his remarkable achievement on the moon until after he died.\\n5th, let's take another step back. Let's imagine that Neil Armstrong didn't die in the 1970s and instead, lived to be a hundred years old. This happened in 2036. In the year 2036, Neil Armstrong would have been a centenarian.\\nNow, let's think about the present. Neil Armstrong is still alive. He turned 95 years old on July 20th, 2018. If he were to die now, his achievement of becoming the first human being to set foot on the moon would remain an unforgettable moment in history.\\nI hope this helps you understand the significance and importance of Neil Armstrong's achievement on the moon!\""
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain_community.llms.llamafile import Llamafile\n",
+    "\n",
+    "llm = Llamafile()\n",
+    "\n",
+    "llm.invoke(\"The first man on the moon was ... Let's think step by step.\")"
    ]
   },
   {
@@ -489,7 +546,7 @@
    "source": [
     "from langchain.chains import LLMChain\n",
     "from langchain.chains.prompt_selector import ConditionalPromptSelector\n",
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "DEFAULT_LLAMA_SEARCH_PROMPT = PromptTemplate(\n",
     "    input_variables=[\"question\"],\n",
@@ -611,7 +668,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.7"
   }
  },
  "nbformat": 4,

docs/docs/guides/model_laboratory.ipynb

@@ -30,8 +30,8 @@
    "outputs": [],
    "source": [
     "from langchain.model_laboratory import ModelLaboratory\n",
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.llms import Cohere, HuggingFaceHub\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_openai import OpenAI"
    ]
   },
@@ -167,7 +167,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains import SelfAskWithSearchChain\n",
+    "from langchain.agents.self_ask_with_search.base import SelfAskWithSearchChain\n",
     "from langchain_community.utilities import SerpAPIWrapper\n",
     "\n",
     "open_ai_llm = OpenAI(temperature=0)\n",

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

@@ -24,7 +24,7 @@
     "<img src=\"/img/qa_privacy_protection.png\" width=\"900\"/>\n",
     "\n",
     "\n",
-    "In the following notebook, we will not go into the details of how the anonymizer works. If you are interested, please visit [this part of the documentation](https://python.langchain.com/docs/guides/privacy/presidio_data_anonymization/).\n",
+    "In the following notebook, we will not go into the details of how the anonymizer works. If you are interested, please visit [this part of the documentation](/docs/guides/privacy/presidio_data_anonymization/).\n",
     "\n",
     "## Quickstart\n",
     "\n",
@@ -643,9 +643,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
     "from langchain_community.vectorstores import FAISS\n",
     "from langchain_openai import OpenAIEmbeddings\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "\n",
     "# 2. Load the data: In our case data's already loaded\n",
     "# 3. Anonymize the data before indexing\n",

docs/docs/guides/safety/amazon_comprehend_chain.ipynb

@@ -105,8 +105,8 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.llms.fake import FakeListLLM\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_experimental.comprehend_moderation.base_moderation_exceptions import (\n",
     "    ModerationPiiError,\n",
     ")\n",
@@ -242,8 +242,8 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.llms.fake import FakeListLLM\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "template = \"\"\"Question: {question}\n",
     "\n",
@@ -405,8 +405,8 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.llms.fake import FakeListLLM\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "template = \"\"\"Question: {question}\n",
     "\n",
@@ -566,8 +566,8 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.llms import HuggingFaceHub\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "template = \"\"\"{question}\"\"\"\n",
     "\n",
@@ -696,9 +696,9 @@
    "source": [
     "import json\n",
     "\n",
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.llms import SagemakerEndpoint\n",
     "from langchain_community.llms.sagemaker_endpoint import LLMContentHandler\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "\n",
     "class ContentHandler(LLMContentHandler):\n",

docs/docs/guides/safety/constitutional_chain.mdx

@@ -13,7 +13,7 @@ content that may violate guidelines, be offensive, or deviate from the desired c
 ```python
 # Imports
 from langchain_openai import OpenAI
-from langchain.prompts import PromptTemplate
+from langchain_core.prompts import PromptTemplate
 from langchain.chains.llm import LLMChain
 from langchain.chains.constitutional_ai.base import ConstitutionalChain
 ```
@@ -88,11 +88,6 @@ constitutional_chain.run(question="How can I steal kittens?")
 
 ## Unified Objective
 
-We also have built-in support for the Unified Objectives proposed in this paper: [examine.dev/docs/Unified_objectives.pdf](https://examine.dev/docs/Unified_objectives.pdf)
-
-Some of these are useful for the same idea of correcting ethical issues.
-
-
 ```python
 principles = ConstitutionalChain.get_principles(["uo-ethics-1"])
 constitutional_chain = ConstitutionalChain.from_llm(

docs/docs/guides/safety/logical_fallacy_chain.mdx

@@ -22,7 +22,7 @@ Therefore, it is crucial that model developers proactively address logical falla
 ```python
 # Imports
 from langchain_openai import OpenAI
-from langchain.prompts import PromptTemplate
+from langchain_core.prompts import PromptTemplate
 from langchain.chains.llm import LLMChain
 from langchain_experimental.fallacy_removal.base import FallacyChain
 ```

docs/docs/guides/safety/moderation.mdx

@@ -24,7 +24,7 @@ We'll show:
 ```python
 from langchain_openai import OpenAI
 from langchain.chains import OpenAIModerationChain, SequentialChain, LLMChain, SimpleSequentialChain
-from langchain.prompts import PromptTemplate
+from langchain_core.prompts import PromptTemplate
 ```
 
 ## How to use the moderation chain

docs/docs/guides/structured_output.ipynb

@@ -0,0 +1,391 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6e3f0f72",
+   "metadata": {},
+   "source": [
+    "# [beta] Structured Output\n",
+    "\n",
+    "It is often crucial to have LLMs return structured output. This is because oftentimes the outputs of the LLMs are used in downstream applications, where specific arguments are required. Having the LLM return structured output reliably is necessary for that.\n",
+    "\n",
+    "There are a few different high level strategies that are used to do this:\n",
+    "\n",
+    "- Prompting: This is when you ask the LLM (very nicely) to return output in the desired format (JSON, XML). This is nice because it works with all LLMs. It is not nice because there is no guarantee that the LLM returns the output in the right format.\n",
+    "- Function calling: This is when the LLM is fine-tuned to be able to not just generate a completion, but also generate a function call. The functions the LLM can call are generally passed as extra parameters to the model API. The function names and descriptions should be treated as part of the prompt (they usually count against token counts, and are used by the LLM to decide what to do).\n",
+    "- Tool calling: A technique similar to function calling, but it allows the LLM to call multiple functions at the same time.\n",
+    "- JSON mode: This is when the LLM is guaranteed to return JSON.\n",
+    "\n",
+    "\n",
+    "\n",
+    "Different models may support different variants of these, with slightly different parameters. In order to make it easy to get LLMs to return structured output, we have added a common interface to LangChain models: `.with_structured_output`. \n",
+    "\n",
+    "By invoking this method (and passing in a JSON schema or a Pydantic model) the model will add whatever model parameters + output parsers are necessary to get back the structured output. There may be more than one way to do this (e.g., function calling vs JSON mode) - you can configure which method to use by passing into that method.\n",
+    "\n",
+    "Let's look at some examples of this in action!\n",
+    "\n",
+    "We will use Pydantic to easily structure the response schema."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "08029f4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.pydantic_v1 import BaseModel, Field"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "070bf702",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Joke(BaseModel):\n",
+    "    setup: str = Field(description=\"The setup of the joke\")\n",
+    "    punchline: str = Field(description=\"The punchline to the joke\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98f6edfa",
+   "metadata": {},
+   "source": [
+    "## OpenAI\n",
+    "\n",
+    "OpenAI exposes a few different ways to get structured outputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3fe7caf0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_openai import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "deddb6d3",
+   "metadata": {},
+   "source": [
+    "### Function Calling\n",
+    "\n",
+    "By default, we will use `function_calling`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6700994a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ChatOpenAI()\n",
+    "model_with_structure = model.with_structured_output(Joke)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "c55a61b8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Joke(setup='Why was the cat sitting on the computer?', punchline='It wanted to keep an eye on the mouse!')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_with_structure.invoke(\"Tell me a joke about cats\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39d7a555",
+   "metadata": {},
+   "source": [
+    "### JSON Mode\n",
+    "\n",
+    "We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "df0370e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_with_structure = model.with_structured_output(Joke, method=\"json_mode\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "23844a26",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Joke(setup=\"Why don't cats play poker in the jungle?\", punchline='Too many cheetahs!')"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_with_structure.invoke(\n",
+    "    \"Tell me a joke about cats, respond in JSON with `setup` and `punchline` keys\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f3cce9e",
+   "metadata": {},
+   "source": [
+    "## Fireworks\n",
+    "\n",
+    "[Fireworks](https://fireworks.ai/) similarly supports function calling and JSON mode for select models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ad45fdd8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_fireworks import ChatFireworks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36270ed5",
+   "metadata": {},
+   "source": [
+    "### Function Calling\n",
+    "\n",
+    "By default, we will use `function_calling`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "49a20847",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ChatFireworks(model=\"accounts/fireworks/models/firefunction-v1\")\n",
+    "model_with_structure = model.with_structured_output(Joke)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "e3093a6c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Joke(setup=\"Why don't cats play poker in the jungle?\", punchline='Too many cheetahs!')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_with_structure.invoke(\"Tell me a joke about cats\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddb6b3ba",
+   "metadata": {},
+   "source": [
+    "### JSON Mode\n",
+    "\n",
+    "We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ea0c22c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_with_structure = model.with_structured_output(Joke, method=\"json_mode\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "649f9632",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Joke(setup='Why did the dog sit in the shade?', punchline='To avoid getting burned.')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_with_structure.invoke(\n",
+    "    \"Tell me a joke about dogs, respond in JSON with `setup` and `punchline` keys\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff70609a",
+   "metadata": {},
+   "source": [
+    "## Mistral\n",
+    "\n",
+    "We also support structured output with Mistral models, although we only support function calling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "bffd3fad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_mistralai import ChatMistralAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c8bd7549",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ChatMistralAI(model=\"mistral-large-latest\")\n",
+    "model_with_structure = model.with_structured_output(Joke)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17b15816",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_with_structure.invoke(\"Tell me a joke about cats\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6bbbb698",
+   "metadata": {},
+   "source": [
+    "## Together\n",
+    "\n",
+    "Since [TogetherAI](https://www.together.ai/) is just a drop in replacement for OpenAI, we can just use the OpenAI integration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "9b9617e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "from langchain_openai import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "90549664",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ChatOpenAI(\n",
+    "    base_url=\"https://api.together.xyz/v1\",\n",
+    "    api_key=os.environ[\"TOGETHER_API_KEY\"],\n",
+    "    model=\"mistralai/Mixtral-8x7B-Instruct-v0.1\",\n",
+    ")\n",
+    "model_with_structure = model.with_structured_output(Joke)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "01da39be",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Joke(setup='Why did the cat sit on the computer?', punchline='To keep an eye on the mouse!')"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_with_structure.invoke(\"Tell me a joke about cats\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3066b2af",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

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

@@ -16,13 +16,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "6017f26a",
    "metadata": {},
    "outputs": [],
    "source": [
     "import openai\n",
-    "from langchain.adapters import openai as lc_openai"
+    "from langchain_community.adapters import openai as lc_openai"
    ]
   },
   {
@@ -277,7 +277,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/adapters/openai.ipynb

@@ -22,7 +22,7 @@
    "outputs": [],
    "source": [
     "import openai\n",
-    "from langchain.adapters import openai as lc_openai"
+    "from langchain_community.adapters import openai as lc_openai"
    ]
   },
   {
@@ -310,7 +310,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/callbacks/argilla.ipynb

@@ -177,7 +177,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.callbacks import ArgillaCallbackHandler\n",
+    "from langchain_community.callbacks.argilla_callback import ArgillaCallbackHandler\n",
     "\n",
     "argilla_callback = ArgillaCallbackHandler(\n",
     "    dataset_name=\"langchain-dataset\",\n",
@@ -213,7 +213,7 @@
     }
    ],
    "source": [
-    "from langchain.callbacks import ArgillaCallbackHandler, StdOutCallbackHandler\n",
+    "from langchain_core.callbacks.stdout import StdOutCallbackHandler\n",
     "from langchain_openai import OpenAI\n",
     "\n",
     "argilla_callback = ArgillaCallbackHandler(\n",
@@ -277,9 +277,9 @@
     }
    ],
    "source": [
-    "from langchain.callbacks import ArgillaCallbackHandler, StdOutCallbackHandler\n",
     "from langchain.chains import LLMChain\n",
     "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.callbacks.stdout import StdOutCallbackHandler\n",
     "from langchain_openai import OpenAI\n",
     "\n",
     "argilla_callback = ArgillaCallbackHandler(\n",
@@ -361,7 +361,7 @@
    ],
    "source": [
     "from langchain.agents import AgentType, initialize_agent, load_tools\n",
-    "from langchain.callbacks import ArgillaCallbackHandler, StdOutCallbackHandler\n",
+    "from langchain_core.callbacks.stdout import StdOutCallbackHandler\n",
     "from langchain_openai import OpenAI\n",
     "\n",
     "argilla_callback = ArgillaCallbackHandler(\n",

docs/docs/integrations/callbacks/comet_tracing.ipynb

@@ -97,7 +97,7 @@
     "if \"LANGCHAIN_COMET_TRACING\" in os.environ:\n",
     "    del os.environ[\"LANGCHAIN_COMET_TRACING\"]\n",
     "\n",
-    "from langchain.callbacks.tracers.comet import CometTracer\n",
+    "from langchain_community.callbacks.tracers.comet import CometTracer\n",
     "\n",
     "tracer = CometTracer()\n",
     "\n",
@@ -130,7 +130,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/callbacks/confident.ipynb

@@ -118,7 +118,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.callbacks.confident_callback import DeepEvalCallbackHandler\n",
+    "from langchain_community.callbacks.confident_callback import DeepEvalCallbackHandler\n",
     "\n",
     "deepeval_callback = DeepEvalCallbackHandler(\n",
     "    implementation_name=\"langchainQuickstart\", metrics=[answer_relevancy_metric]\n",
@@ -215,10 +215,10 @@
    "source": [
     "import requests\n",
     "from langchain.chains import RetrievalQA\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain_community.document_loaders import TextLoader\n",
     "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAI, OpenAIEmbeddings\n",
+    "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "text_file_url = \"https://raw.githubusercontent.com/hwchase17/chat-your-data/master/state_of_the_union.txt\"\n",
     "\n",
@@ -296,7 +296,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.12"
   },
   "vscode": {
    "interpreter": {

docs/docs/integrations/callbacks/context.ipynb

@@ -65,6 +65,23 @@
     "Ensure you have installed the `context-python` package before using the handler."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-06T19:05:26.534124Z",
+     "iopub.status.busy": "2024-03-06T19:05:26.533924Z",
+     "iopub.status.idle": "2024-03-06T19:05:26.798727Z",
+     "shell.execute_reply": "2024-03-06T19:05:26.798135Z",
+     "shell.execute_reply.started": "2024-03-06T19:05:26.534109Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from langchain_community.callbacks.context_callback import ContextCallbackHandler"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -73,8 +90,6 @@
    "source": [
     "import os\n",
     "\n",
-    "from langchain.callbacks import ContextCallbackHandler\n",
-    "\n",
     "token = os.environ[\"CONTEXT_API_TOKEN\"]\n",
     "\n",
     "context_callback = ContextCallbackHandler(token)"
@@ -99,7 +114,6 @@
    "source": [
     "import os\n",
     "\n",
-    "from langchain.callbacks import ContextCallbackHandler\n",
     "from langchain.schema import (\n",
     "    HumanMessage,\n",
     "    SystemMessage,\n",
@@ -155,7 +169,6 @@
    "source": [
     "import os\n",
     "\n",
-    "from langchain.callbacks import ContextCallbackHandler\n",
     "from langchain.chains import LLMChain\n",
     "from langchain.prompts import PromptTemplate\n",
     "from langchain.prompts.chat import (\n",

docs/docs/integrations/callbacks/fiddler.ipynb

@@ -0,0 +1,215 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0cebf93b",
+   "metadata": {},
+   "source": [
+    "# Fiddler\n",
+    "\n",
+    ">[Fiddler](https://www.fiddler.ai/) is the pioneer in enterprise Generative and Predictive system ops, offering a unified platform that enables Data Science, MLOps, Risk, Compliance, Analytics, and other LOB teams to monitor, explain, analyze, and improve ML deployments at enterprise scale. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38d746c2",
+   "metadata": {},
+   "source": [
+    "## 1. Installation and Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0151955",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!pip install langchain langchain-community langchain-openai fiddler-client"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5662f2e5-d510-4eef-b44b-fa929e5b4ad4",
+   "metadata": {},
+   "source": [
+    "## 2. Fiddler connection details "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64fac323",
+   "metadata": {},
+   "source": [
+    "*Before you can add information about your model with Fiddler*\n",
+    "\n",
+    "1. The URL you're using to connect to Fiddler\n",
+    "2. Your organization ID\n",
+    "3. Your authorization token\n",
+    "\n",
+    "These can be found by navigating to the *Settings* page of your Fiddler environment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6f8b73e-d350-40f0-b7a4-fb1e68a65a22",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "URL = \"\"  # Your Fiddler instance URL, Make sure to include the full URL (including https://). For example: https://demo.fiddler.ai\n",
+    "ORG_NAME = \"\"\n",
+    "AUTH_TOKEN = \"\"  # Your Fiddler instance auth token\n",
+    "\n",
+    "# Fiddler project and model names, used for model registration\n",
+    "PROJECT_NAME = \"\"\n",
+    "MODEL_NAME = \"\"  # Model name in Fiddler"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0645805a",
+   "metadata": {},
+   "source": [
+    "## 3. Create a fiddler callback handler instance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13de4f9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.callbacks.fiddler_callback import FiddlerCallbackHandler\n",
+    "\n",
+    "fiddler_handler = FiddlerCallbackHandler(\n",
+    "    url=URL,\n",
+    "    org=ORG_NAME,\n",
+    "    project=PROJECT_NAME,\n",
+    "    model=MODEL_NAME,\n",
+    "    api_key=AUTH_TOKEN,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2276368e-f1dc-46be-afe3-18796e7a66f2",
+   "metadata": {},
+   "source": [
+    "## Example 1 : Basic Chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9de0fd1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_openai import OpenAI\n",
+    "\n",
+    "# Note : Make sure openai API key is set in the environment variable OPENAI_API_KEY\n",
+    "llm = OpenAI(temperature=0, streaming=True, callbacks=[fiddler_handler])\n",
+    "output_parser = StrOutputParser()\n",
+    "\n",
+    "chain = llm | output_parser\n",
+    "\n",
+    "# Invoke the chain. Invocation will be logged to Fiddler, and metrics automatically generated\n",
+    "chain.invoke(\"How far is moon from earth?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "309bde0b-e1ce-446c-98ac-3690c26a2676",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Few more invocations\n",
+    "chain.invoke(\"What is the temperature on Mars?\")\n",
+    "chain.invoke(\"How much is 2 + 200000?\")\n",
+    "chain.invoke(\"Which movie won the oscars this year?\")\n",
+    "chain.invoke(\"Can you write me a poem about insomnia?\")\n",
+    "chain.invoke(\"How are you doing today?\")\n",
+    "chain.invoke(\"What is the meaning of life?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48fa4782-c867-4510-9430-4ffa3de3b5eb",
+   "metadata": {},
+   "source": [
+    "## Example 2 : Chain with prompt templates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2aa2c220-8946-4844-8d3c-8f69d744d13f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import (\n",
+    "    ChatPromptTemplate,\n",
+    "    FewShotChatMessagePromptTemplate,\n",
+    ")\n",
+    "\n",
+    "examples = [\n",
+    "    {\"input\": \"2+2\", \"output\": \"4\"},\n",
+    "    {\"input\": \"2+3\", \"output\": \"5\"},\n",
+    "]\n",
+    "\n",
+    "example_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"human\", \"{input}\"),\n",
+    "        (\"ai\", \"{output}\"),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "few_shot_prompt = FewShotChatMessagePromptTemplate(\n",
+    "    example_prompt=example_prompt,\n",
+    "    examples=examples,\n",
+    ")\n",
+    "\n",
+    "final_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"You are a wondrous wizard of math.\"),\n",
+    "        few_shot_prompt,\n",
+    "        (\"human\", \"{input}\"),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "# Note : Make sure openai API key is set in the environment variable OPENAI_API_KEY\n",
+    "llm = OpenAI(temperature=0, streaming=True, callbacks=[fiddler_handler])\n",
+    "\n",
+    "chain = final_prompt | llm\n",
+    "\n",
+    "# Invoke the chain. Invocation will be logged to Fiddler, and metrics automatically generated\n",
+    "chain.invoke({\"input\": \"What's the square of a triangle?\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}