maybe

Signed-off-by: Samhita Alla <aallasamhita@gmail.com>
Co-authored-by: Samhita Alla <aallasamhita@gmail.com>

.readthedocs.yaml

@@ -9,6 +9,9 @@ build:
   os: ubuntu-22.04
   tools:
     python: "3.11"
+  jobs:
+    pre_build:
+      - python docs/api_reference/create_api_rst.py
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:

docs/api_reference/_static/js/mendablesearch.js

@@ -1,57 +0,0 @@
-document.addEventListener('DOMContentLoaded', () => {
-  // Load the external dependencies
-  function loadScript(src, onLoadCallback) {
-    const script = document.createElement('script');
-    script.src = src;
-    script.onload = onLoadCallback;
-    document.head.appendChild(script);
-  }
-
-  function createRootElement() {
-    const rootElement = document.createElement('div');
-    rootElement.id = 'my-component-root';
-    document.body.appendChild(rootElement);
-    return rootElement;
-  }
-
-  
-
-  function initializeMendable() {
-    const rootElement = createRootElement();
-    const { MendableFloatingButton } = Mendable;
-    
-
-    const iconSpan1 = React.createElement('span', {
-    }, '🦜');
-
-    const iconSpan2 = React.createElement('span', {
-    }, '🔗');
-
-    const icon = React.createElement('p', {
-      style: { color: '#ffffff', fontSize: '22px',width: '48px', height: '48px', margin: '0px', padding: '0px', display: 'flex', alignItems: 'center', justifyContent: 'center', textAlign: 'center' },
-    }, [iconSpan1, iconSpan2]);
-    
-    const mendableFloatingButton = React.createElement(
-      MendableFloatingButton,
-      {
-        style: { darkMode: false, accentColor: '#010810' },
-        floatingButtonStyle: { color: '#ffffff', backgroundColor: '#010810' },
-        anon_key: '82842b36-3ea6-49b2-9fb8-52cfc4bde6bf', // Mendable Search Public ANON key, ok to be public
-        cmdShortcutKey:'j',
-        messageSettings: {
-          openSourcesInNewTab: false,
-          prettySources: true // Prettify the sources displayed now
-        },
-        icon: icon,
-      }
-    );
-
-    ReactDOM.render(mendableFloatingButton, rootElement);
-  }
-
-  loadScript('https://unpkg.com/react@17/umd/react.production.min.js', () => {
-    loadScript('https://unpkg.com/react-dom@17/umd/react-dom.production.min.js', () => {
-      loadScript('https://unpkg.com/@mendable/search@0.0.102/dist/umd/mendable.min.js', initializeMendable);
-    });
-  });
-});

docs/api_reference/agents.rst

@@ -1,12 +0,0 @@
-Agents
-==============
-
-Reference guide for Agents and associated abstractions.
-
-.. toctree::
-   :maxdepth: 1
-   :glob:
-
-   modules/agents
-   modules/tools
-   modules/agent_toolkits

docs/api_reference/conf.py

@@ -11,12 +11,13 @@
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
+import os
+import sys
 
 import toml
 
+sys.path.insert(0, os.path.abspath("."))
+
 with open("../../pyproject.toml") as f:
     data = toml.load(f)
 
@@ -45,11 +46,9 @@ extensions = [
     "sphinx.ext.napoleon",
     "sphinx.ext.viewcode",
     "sphinxcontrib.autodoc_pydantic",
-    "myst_nb",
     "sphinx_copybutton",
     "sphinx_panels",
     "IPython.sphinxext.ipython_console_highlighting",
-    "sphinx_tabs.tabs",
 ]
 source_suffix = [".rst"]
 
@@ -59,24 +58,22 @@ autodoc_pydantic_config_members = False
 autodoc_pydantic_model_show_config_summary = False
 autodoc_pydantic_model_show_validator_members = False
 autodoc_pydantic_model_show_validator_summary = False
-autodoc_pydantic_model_show_field_summary = False
-autodoc_pydantic_model_members = False
-autodoc_pydantic_model_undoc_members = False
-autodoc_pydantic_model_hide_paramlist = False
 autodoc_pydantic_model_signature_prefix = "class"
-autodoc_pydantic_field_signature_prefix = "attribute"
-autodoc_pydantic_model_summary_list_order = "bysource"
-autodoc_member_order = "bysource"
+autodoc_pydantic_field_signature_prefix = "param"
+autodoc_member_order = "groupwise"
+autoclass_content = "both"
+autodoc_typehints_format = "short"
+
 autodoc_default_options = {
     "members": True,
     "show-inheritance": True,
-    "undoc_members": True,
-    "inherited_members": "BaseModel",
+    "inherited-members": "BaseModel",
+    "undoc-members": True,
+    "special-members": "__call__",
 }
-autodoc_typehints = "description"
-
+# autodoc_typehints = "description"
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ["templates"]
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -89,14 +86,16 @@ exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = "sphinx_rtd_theme"
+html_theme = "scikit-learn-modern"
+html_theme_path = ["themes"]
 
-html_theme_options = {
-    "path_to_docs": "docs",
-    "repository_url": "https://github.com/hwchase17/langchain",
-    "use_repository_button": True,
-    # "style_nav_header_background": "white"
+# redirects dictionary maps from old links to new links
+html_additional_pages = {}
+redirects = {
+    "index": "api_reference",
 }
+for old_link in redirects:
+    html_additional_pages[old_link] = "redirects.html"
 
 html_context = {
     "display_github": True,  # Integrate GitHub
@@ -104,6 +103,7 @@ html_context = {
     "github_repo": "langchain",  # Repo name
     "github_version": "master",  # Version
     "conf_py_path": "/docs/api_reference",  # Path in the checkout to the docs root
+    "redirects": redirects,
 }
 
 # Add any paths that contain custom static files (such as style sheets) here,
@@ -116,10 +116,9 @@ html_static_path = ["_static"]
 html_css_files = [
     "css/custom.css",
 ]
+html_use_index = False
 
-html_js_files = [
-    "js/mendablesearch.js",
-]
-
-nb_execution_mode = "off"
 myst_enable_extensions = ["colon_fence"]
+
+# generate autosummary even if no references
+autosummary_generate = True

docs/api_reference/create_api_rst.py

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

docs/api_reference/data_connection.rst

@@ -1,13 +0,0 @@
-Data connection
-==============
-LangChain has a number of modules that help you load, structure, store, and retrieve documents.
-
-.. toctree::
-   :maxdepth: 1
-   :glob:
-
-   modules/document_loaders
-   modules/document_transformers
-   modules/embeddings
-   modules/vectorstores
-   modules/retrievers

docs/api_reference/index.rst

@@ -1,29 +1,8 @@
-API Reference
-==========================
-
-| Full documentation on all methods, classes, and APIs in the LangChain Python package.
+=============
+LangChain API
+=============
 
 .. toctree::
-   :maxdepth: 1
-   :caption: Abstractions
+    :maxdepth: 2
 
-   ./modules/base_classes.rst
-
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Core
-
-   ./model_io.rst
-   ./data_connection.rst
-   ./modules/chains.rst
-   ./agents.rst
-   ./modules/memory.rst
-   ./modules/callbacks.rst
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Additional
-
-   ./modules/utilities.rst
-   ./modules/experimental.rst
+    api_reference.rst

docs/api_reference/model_io.rst

@@ -1,12 +0,0 @@
-Model I/O
-==============
-
-LangChain provides interfaces and integrations for working with language models.
-
-.. toctree::
-   :maxdepth: 1
-   :glob:
-
-   ./prompts.rst
-   ./models.rst
-   ./modules/output_parsers.rst

docs/api_reference/models.rst

@@ -1,11 +0,0 @@
-Models
-==============
-
-LangChain provides interfaces and integrations for a number of different types of models.
-
-.. toctree::
-   :maxdepth: 1
-   :glob:
-
-   modules/llms
-   modules/chat_models

docs/api_reference/modules/agent_toolkits.rst

@@ -1,7 +0,0 @@
-Agent Toolkits
-===============================
-
-.. automodule:: langchain.agents.agent_toolkits
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/agents.rst

@@ -1,7 +0,0 @@
-Agents
-===============================
-
-.. automodule:: langchain.agents
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/base_classes.rst

@@ -1,5 +0,0 @@
-Base classes
-========================
-
-.. automodule:: langchain.schema
-   :inherited-members:

docs/api_reference/modules/callbacks.rst

@@ -1,7 +0,0 @@
-Callbacks
-=======================
-
-.. automodule:: langchain.callbacks
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/chains.rst

@@ -1,8 +0,0 @@
-Chains
-=======================
-
-.. automodule:: langchain.chains
-   :members:
-   :undoc-members:
-   :inherited-members: BaseModel
-

docs/api_reference/modules/chat_models.rst

@@ -1,7 +0,0 @@
-Chat Models
-===============================
-
-.. automodule:: langchain.chat_models
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/document_loaders.rst

@@ -1,7 +0,0 @@
-Document Loaders
-===============================
-
-.. automodule:: langchain.document_loaders
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/document_transformers.rst

@@ -1,13 +0,0 @@
-Document Transformers
-===============================
-
-.. automodule:: langchain.document_transformers
-   :members:
-   :undoc-members:
-
-Text Splitters
-------------------------------
-
-.. automodule:: langchain.text_splitter
-   :members:
-   :undoc-members:

docs/api_reference/modules/embeddings.rst

@@ -1,5 +0,0 @@
-Embeddings
-===========================
-
-.. automodule:: langchain.embeddings
-   :members:

docs/api_reference/modules/example_selector.rst

@@ -1,5 +0,0 @@
-Example Selector
-=========================================
-
-.. automodule:: langchain.prompts.example_selector
-   :members:

docs/api_reference/modules/experimental.rst

@@ -1,28 +0,0 @@
-====================
-Experimental
-====================
-
-This module contains experimental modules and reproductions of existing work using LangChain primitives.
-
-Autonomous agents
-------------------
-
-Here, we document the BabyAGI and AutoGPT classes from the langchain.experimental module.
-
-.. autoclass:: langchain.experimental.BabyAGI
-   :members:
-
-.. autoclass:: langchain.experimental.AutoGPT
-   :members:
-
-
-Generative agents
-------------------
-
-Here, we document the GenerativeAgent and GenerativeAgentMemory classes from the langchain.experimental module.
-
-.. autoclass:: langchain.experimental.GenerativeAgent
-   :members:
-
-.. autoclass:: langchain.experimental.GenerativeAgentMemory
-   :members:

docs/api_reference/modules/llms.rst

@@ -1,7 +0,0 @@
-LLMs
-=======================
-
-.. automodule:: langchain.llms
-   :members:
-   :inherited-members:
-   :special-members: __call__

docs/api_reference/modules/memory.rst

@@ -1,7 +0,0 @@
-Memory
-===============================
-
-.. automodule:: langchain.memory
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/output_parsers.rst

@@ -1,7 +0,0 @@
-Output Parsers
-===============================
-
-.. automodule:: langchain.output_parsers
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/prompts.rst

@@ -1,6 +0,0 @@
-Prompt Templates
-========================
-
-.. automodule:: langchain.prompts
-   :members:
-   :undoc-members:

docs/api_reference/modules/retrievers.rst

@@ -1,14 +0,0 @@
-Retrievers
-===============================
-
-.. automodule:: langchain.retrievers
-   :members:
-   :undoc-members:
-
-Document compressors
--------------------------------
-
-.. automodule:: langchain.retrievers.document_compressors
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/tools.rst

@@ -1,7 +0,0 @@
-Tools
-===============================
-
-.. automodule:: langchain.tools
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/utilities.rst

@@ -1,7 +0,0 @@
-Utilities
-===============================
-
-.. automodule:: langchain.utilities
-   :members:
-   :undoc-members:
-

docs/api_reference/modules/vectorstores.rst

@@ -1,6 +0,0 @@
-Vector Stores
-=============================
-
-.. automodule:: langchain.vectorstores
-   :members:
-   :undoc-members:

docs/api_reference/prompts.rst

@@ -1,11 +0,0 @@
-Prompts
-==============
-
-The reference guides here all relate to objects for working with Prompts.
-
-.. toctree::
-   :maxdepth: 1
-   :glob:
-
-   modules/prompts
-   modules/example_selector

docs/api_reference/templates/COPYRIGHT.txt

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

docs/api_reference/templates/class.rst

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

docs/api_reference/templates/redirects.html

@@ -0,0 +1,15 @@
+{% set redirect = pathto(redirects[pagename]) %}
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Refresh" content="0; url={{ redirect }}" />
+    <meta name="Description" content="scikit-learn: machine learning in Python">
+    <link rel="canonical" href="{{ redirect }}" />
+    <title>scikit-learn: machine learning in Python</title>
+  </head>
+  <body>
+    <p>You will be automatically redirected to the <a href="{{ redirect }}">new location of this page</a>.</p>
+  </body>
+</html>

docs/api_reference/themes/COPYRIGHT.txt

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

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

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

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

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

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

@@ -0,0 +1,85 @@
+{%- if pagename != 'index' and pagename != 'documentation' %}
+  {%- set nav_bar_class = "sk-docs-navbar" %}
+  {%- set top_container_cls = "sk-docs-container" %}
+{%- else %}
+  {%- set nav_bar_class = "sk-landing-navbar" %}
+  {%- set top_container_cls = "sk-landing-container" %}
+{%- endif %}
+
+{% if theme_link_to_live_contributing_page|tobool %}
+{# Link to development page for live builds #}
+  {%- set development_link = "https://scikit-learn.org/dev/developers/index.html" %}
+{# Open on a new development page in new window/tab for live builds #}
+  {%- set development_attrs = 'target="_blank" rel="noopener noreferrer"' %}
+{%- else %}
+  {%- set development_link = pathto('developers/index') %}
+  {%- set development_attrs = '' %}
+{%- endif %}
+
+{# title, link, link_attrs #}
+{%- set drop_down_navigation = [
+  ('Getting Started', pathto('getting_started'), ''),
+  ('Tutorial', pathto('tutorial/index'), ''),
+  ("What's new", pathto('whats_new/v' + version), ''),
+  ('Glossary', pathto('glossary'), ''),
+  ('Development', development_link, development_attrs),
+  ('FAQ', pathto('faq'), ''),
+  ('Support', pathto('support'), ''),
+  ('Related packages', pathto('related_projects'), ''),
+  ('Roadmap', pathto('roadmap'), ''),
+  ('Governance', pathto('governance'), ''),
+  ('About us', pathto('about'), ''),
+  ('GitHub', 'https://github.com/scikit-learn/scikit-learn', ''),
+  ('Other Versions and Download', 'https://scikit-learn.org/dev/versions.html', '')]
+-%}
+
+<nav id="navbar" class="{{ nav_bar_class }} navbar navbar-expand-md navbar-light bg-light py-0">
+  <div class="container-fluid {{ top_container_cls }} px-0">
+    {%- if logo_url %}
+      <a class="navbar-brand py-0" href="{{ pathto('index') }}">
+        <img
+          class="sk-brand-img"
+          src="{{ logo_url|e }}"
+          alt="logo"/>
+      </a>
+    {%- endif %}
+    <button
+      id="sk-navbar-toggler"
+      class="navbar-toggler"
+      type="button"
+      data-toggle="collapse"
+      data-target="#navbarSupportedContent"
+      aria-controls="navbarSupportedContent"
+      aria-expanded="false"
+      aria-label="Toggle navigation"
+    >
+      <span class="navbar-toggler-icon"></span>
+    </button>
+
+    <div class="sk-navbar-collapse collapse navbar-collapse" id="navbarSupportedContent">
+      <ul class="navbar-nav mr-auto">
+        <li class="nav-item">
+          <a class="sk-nav-link nav-link" href="{{ pathto('api_reference') }}">API</a>
+        </li>
+        <li class="nav-item">
+          <a class="sk-nav-link nav-link" target="_blank" rel="noopener noreferrer" href="https://python.langchain.com/">Python Docs</a>
+        </li>
+        {%- for title, link, link_attrs in drop_down_navigation %}
+        <li class="nav-item">
+          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="{{ link }}" {{ link_attrs }}>{{ title }}</a>
+        </li>
+        {%- endfor %}
+      </ul>
+      {%- if pagename != "search"%}
+      <div id="searchbox" role="search">
+          <div class="searchformwrapper">
+          <form class="search" action="{{ pathto('search') }}" method="get">
+            <input class="sk-search-text-input" type="text" name="q" aria-labelledby="searchlabel" />
+            <input class="sk-search-text-btn" type="submit" value="{{ _('Go') }}" />
+          </form>
+          </div>
+      </div>
+      {%- endif %}
+    </div>
+  </div>
+</nav>

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

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

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

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

docs/docs_skeleton/docs/modules/callbacks/integrations/promptlayer.ipynb

@@ -0,0 +1,216 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PromptLayer\n",
+    "\n",
+    "<img src=\"https://promptlayer.com/logo.png\"  height=\"300\">\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[PromptLayer](https://promptlayer.com) is a an observability platform for prompts and LLMs. In this guide we will go over how to setup the `PromptLayerCallbackHandler`. While PromptLayer does have LLMs that integrate directly with LangChain (eg [`PromptLayerOpenAI`](https://python.langchain.com/docs/modules/model_io/models/llms/integrations/promptlayer_openai)), this callback will be an easier and more feature rich way to integrate PromptLayer with any model on LangChain. \n",
+    "\n",
+    "This callback is also the recommended way to connect with PromptLayer when building Chains and Agents on LangChain."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Installation and Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install promptlayer --upgrade"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting API Credentials\n",
+    "\n",
+    "If you have not already create an account on [PromptLayer](https://www.promptlayer.com) and get an API key by clicking on the settings cog in the navbar\n",
+    "Set it as an environment variabled called `PROMPTLAYER_API_KEY`\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Usage\n",
+    "\n",
+    "To get started with `PromptLayerCallbackHandler` is fairly simple, it takes two optional arguments:\n",
+    "1. `pl_tags` - an optional list of strings that will be tags tracked on PromptLayer\n",
+    "2. `pl_id_callback` - an optional function that will get a `promptlayer_request_id` as an argument. This id can be used with all of PromptLayers tracking features to track, metadata, scores, and prompt usage."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simple Example\n",
+    "\n",
+    "In this simple example we use `PromptLayerCallbackHandler` with `ChatOpenAI`. We add a PromptLayer tag named `chatopenai`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"Sure, here's one:\\n\\nWhy did the tomato turn red?\\n\\nBecause it saw the salad dressing!\" additional_kwargs={} example=False\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.schema import (\n",
+    "    HumanMessage,\n",
+    ")\n",
+    "from langchain.callbacks import PromptLayerCallbackHandler\n",
+    "\n",
+    "chat_llm = ChatOpenAI(\n",
+    "    temperature=0,\n",
+    "    callbacks=[PromptLayerCallbackHandler(pl_tags=[\"chatopenai\"])],\n",
+    ")\n",
+    "llm_results = chat_llm(\n",
+    "    [\n",
+    "        HumanMessage(content=\"What comes after 1,2,3 ?\"),\n",
+    "        HumanMessage(content=\"Tell me another joke?\"),\n",
+    "    ]\n",
+    ")\n",
+    "print(llm_results)\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Full Featured Example\n",
+    "\n",
+    "In this example we unlock more of the power of PromptLayer.\n",
+    "\n",
+    "We are using the Prompt Registry and fetching the prompt called `example`.\n",
+    "\n",
+    "We also define a `pl_id_callback` function that tracks a score, metadata and the prompt used. Read more about tracking on [our docs](docs.promptlayer.com)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "prompt layer id  6050929\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'\\nToasterCo.'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.callbacks import PromptLayerCallbackHandler\n",
+    "import promptlayer\n",
+    "\n",
+    "def pl_id_callback(promptlayer_request_id):\n",
+    "    print(\"prompt layer id \", promptlayer_request_id)\n",
+    "    promptlayer.track.score(\n",
+    "        request_id=promptlayer_request_id, score=100\n",
+    "    )  # score is an integer 0-100\n",
+    "    promptlayer.track.metadata(\n",
+    "        request_id=promptlayer_request_id, metadata={\"foo\": \"bar\"}\n",
+    "    )  # metadata is a dictionary of key value pairs that is tracked on PromptLayer\n",
+    "    promptlayer.track.prompt(\n",
+    "        request_id=promptlayer_request_id,\n",
+    "        prompt_name=\"example\",\n",
+    "        prompt_input_variables={\"product\": \"toasters\"},\n",
+    "        version=1,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "openai_llm = OpenAI(\n",
+    "    model_name=\"text-davinci-002\",\n",
+    "    callbacks=[PromptLayerCallbackHandler(pl_id_callback=pl_id_callback)],\n",
+    ")\n",
+    "\n",
+    "example_prompt = promptlayer.prompts.get(\"example\", version=1, langchain=True)\n",
+    "openai_llm(example_prompt.format(product=\"toasters\"))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That is all it takes! After setup all your requests will show up on the PromptLayer dasahboard.\n",
+    "This callback also works with any LLM implemented on LangChain."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "c4fe2cd85a8d9e8baaec5340ce66faff1c77581a9f43e6c45e85e09b6fced008"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/docs_skeleton/docusaurus.config.js

@@ -7,7 +7,10 @@ const { ProvidePlugin } = require("webpack");
 const path = require("path");
 
 const examplesPath = path.resolve(__dirname, "..", "examples", "src");
-const snippetsPath = path.resolve(__dirname, "..", "snippets")
+const snippetsPath = path.resolve(__dirname, "..", "snippets");
+
+const baseLightCodeBlockTheme = require("prism-react-renderer/themes/vsLight");
+const baseDarkCodeBlockTheme = require("prism-react-renderer/themes/vsDark");
 
 /** @type {import('@docusaurus/types').Config} */
 const config = {
@@ -127,8 +130,20 @@ const config = {
         },
       },
       prism: {
-        theme: require("prism-react-renderer/themes/vsLight"),
-        darkTheme: require("prism-react-renderer/themes/vsDark"),
+        theme: {
+          ...baseLightCodeBlockTheme,
+          plain: {
+            ...baseLightCodeBlockTheme.plain,
+            backgroundColor: "#F5F5F5",
+          },
+        },
+        darkTheme: {
+          ...baseDarkCodeBlockTheme,
+          plain: {
+            ...baseDarkCodeBlockTheme.plain,
+            backgroundColor: "#222222",
+          },
+        },
       },
       image: "img/parrot-chainlink-icon.png",
       navbar: {

docs/extras/ecosystem/integrations/arthur_tracking.ipynb

@@ -0,0 +1,464 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "944e4194",
+   "metadata": {},
+   "source": [
+    "# Arthur LangChain integration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1ccdfe8",
+   "metadata": {},
+   "source": [
+    "[Arthur](https://www.arthur.ai/) is a model monitoring and observability platform.\n",
+    "\n",
+    "This notebook shows how to register LLMs (chat and non-chat) as models with the Arthur platform. Then we show how to set up langchain LLMs with an Arthur callback that will automatically log model inferences to Arthur.\n",
+    "\n",
+    "For more information about how to use the Arthur SDK, visit our [docs](http://docs.arthur.ai), in particular our [model onboarding guide](https://docs.arthur.ai/user-guide/walkthroughs/model-onboarding/index.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "961c6691",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.callbacks import ArthurCallbackHandler\n",
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "from langchain.chat_models import ChatOpenAI, ChatAnthropic\n",
+    "from langchain.schema import HumanMessage\n",
+    "from langchain.llms import OpenAI, Cohere, HuggingFacePipeline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a23d1963",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from arthurai import ArthurAI\n",
+    "from arthurai.common.constants import InputType, OutputType, Stage, ValueType\n",
+    "from arthurai.core.attributes import ArthurAttribute, AttributeCategory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d1b90c0",
+   "metadata": {},
+   "source": [
+    "# ArthurModel for chatbot with only input text and output text attributes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1a4a4a8a",
+   "metadata": {},
+   "source": [
+    "Connect to Arthur client"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f49e9b79",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "arthur_url = \"https://app.arthur.ai\"\n",
+    "arthur_login = \"your-username-here\"\n",
+    "arthur = ArthurAI(url=arthur_url, login=arthur_login)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6e063bf",
+   "metadata": {},
+   "source": [
+    "Before you can register model inferences to Arthur, you must have a registered model with an ID in the Arthur platform. We will provide this ID to the ArthurCallbackHandler.\n",
+    "\n",
+    "You can register a model with Arthur here in the notebook using this `register_chat_llm()` function. This function returns the ID of the model saved to the platform. To use the function, uncomment `arthur_model_chatbot_id = register_chat_llm()` in the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "31b17b5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def register_chat_llm():\n",
+    "\n",
+    "    arthur_model = arthur.model(\n",
+    "        display_name=\"LangChainChat\",\n",
+    "        input_type=InputType.NLP,\n",
+    "        output_type=OutputType.TokenSequence\n",
+    "    )\n",
+    "\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"my_input_text\",\n",
+    "        stage=Stage.ModelPipelineInput,\n",
+    "        value_type=ValueType.Unstructured_Text,\n",
+    "        categorical=True,\n",
+    "        is_unique=True\n",
+    "    ))\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"my_output_text\",\n",
+    "        stage=Stage.PredictedValue,\n",
+    "        value_type=ValueType.Unstructured_Text,\n",
+    "        categorical=True,\n",
+    "        is_unique=False,\n",
+    "    ))\n",
+    "    \n",
+    "    return arthur_model.save()\n",
+    "# arthur_model_chatbot_id = register_chat_llm()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d1d1e60",
+   "metadata": {},
+   "source": [
+    "Alternatively, you can set the `arthur_model_chatbot_id` variable to be the ID of your model on your [model dashboard](https://app.arthur.ai/)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "cdfa02c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "arthur_model_chatbot_id = \"your-model-id-here\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58be5234",
+   "metadata": {},
+   "source": [
+    "This function creates a Langchain chat LLM with the ArthurCallbackHandler to log inferences to Arthur. We provide our `arthur_model_chatbot_id`, as well as the Arthur url and login we are using."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "448a8fee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_langchain_chat_llm(chat_model=ChatOpenAI):\n",
+    "    if chat_model not in [ChatOpenAI, ChatAnthropic]:\n",
+    "        raise ValueError(\"For this notebook, use one of the chat models imported from langchain.chat_models\")\n",
+    "    return chat_model(\n",
+    "        streaming=True, \n",
+    "        temperature=0.1,\n",
+    "        callbacks=[\n",
+    "            StreamingStdOutCallbackHandler(), \n",
+    "            ArthurCallbackHandler.from_credentials(arthur_model_chatbot_id, arthur_url=arthur_url, arthur_login=arthur_login)\n",
+    "        ])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17c182da",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2dfc00ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat_llm = make_langchain_chat_llm()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "139291f2",
+   "metadata": {},
+   "source": [
+    "Run the chatbot (it will save the chat history in the `history` list so that the conversation can reference earlier messages)\n",
+    "\n",
+    "Type `q` to quit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "7480a443",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_langchain_chat_llm(llm):\n",
+    "    history = []\n",
+    "    while True:\n",
+    "        user_input = input(\"\\n>>> input >>>\\n>>>: \")\n",
+    "        if user_input == 'q': break\n",
+    "        history.append(HumanMessage(content=user_input))\n",
+    "        history.append(llm(history))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "6868ce71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_langchain_chat_llm(chat_llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0be7d01",
+   "metadata": {},
+   "source": [
+    "# ArthurModel with input text, output text, token likelihoods, finish reason, and amount of token usage attributes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ee4b741",
+   "metadata": {},
+   "source": [
+    "This function registers an LLM with additional metadata attributes to log to Arthur with each inference\n",
+    "\n",
+    "As above, you can register your callback handler for an LLM using this function here in the notebook or by pasting the ID of an already-registered model from your [model dashboard](https://app.arthur.ai/)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e671836c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def register_llm():\n",
+    "\n",
+    "    arthur_model = arthur.model(\n",
+    "        display_name=\"LangChainLLM\",\n",
+    "        input_type=InputType.NLP,\n",
+    "        output_type=OutputType.TokenSequence\n",
+    "    )\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"my_input_text\",\n",
+    "        stage=Stage.ModelPipelineInput,\n",
+    "        value_type=ValueType.Unstructured_Text,\n",
+    "        categorical=True,\n",
+    "        is_unique=True\n",
+    "    ))\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"my_output_text\",\n",
+    "        stage=Stage.PredictedValue,\n",
+    "        value_type=ValueType.Unstructured_Text,\n",
+    "        categorical=True,\n",
+    "        is_unique=False,\n",
+    "        token_attribute_link=\"my_output_likelihoods\"\n",
+    "    ))\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"my_output_likelihoods\",\n",
+    "        stage=Stage.PredictedValue,\n",
+    "        value_type=ValueType.TokenLikelihoods,\n",
+    "        token_attribute_link=\"my_output_text\"\n",
+    "    ))\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"finish_reason\",\n",
+    "        stage=Stage.NonInputData,\n",
+    "        value_type=ValueType.String,\n",
+    "        categorical=True,\n",
+    "        categories=[\n",
+    "            AttributeCategory(value='stop'),\n",
+    "            AttributeCategory(value='length'),\n",
+    "            AttributeCategory(value='content_filter'),\n",
+    "            AttributeCategory(value='null')\n",
+    "        ]\n",
+    "    ))\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"prompt_tokens\",\n",
+    "        stage=Stage.NonInputData,\n",
+    "        value_type=ValueType.Integer\n",
+    "    ))\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"completion_tokens\",\n",
+    "        stage=Stage.NonInputData,\n",
+    "        value_type=ValueType.Integer\n",
+    "    ))\n",
+    "    arthur_model._add_attribute_to_model(ArthurAttribute(\n",
+    "        name=\"duration\",\n",
+    "        stage=Stage.NonInputData,\n",
+    "        value_type=ValueType.Float\n",
+    "    ))\n",
+    "    \n",
+    "    return arthur_model.save()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2a6686f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "arthur_model_llm_id = \"your-model-id-here\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2dcacb96",
+   "metadata": {},
+   "source": [
+    "These functions create Langchain LLMs with the ArthurCallbackHandler to log inferences to Arthur.\n",
+    "\n",
+    "There are small differences in the underlying Langchain integrations with these libraries and the available metadata for model inputs & outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "34cf0072",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_langchain_openai_llm():\n",
+    "    return OpenAI(\n",
+    "        temperature=0.1,\n",
+    "        model_kwargs = {'logprobs': 3},\n",
+    "        callbacks=[\n",
+    "            ArthurCallbackHandler.from_credentials(arthur_model_llm_id, arthur_url=arthur_url, arthur_login=arthur_login)\n",
+    "        ])\n",
+    "\n",
+    "def make_langchain_cohere_llm():\n",
+    "    return Cohere(\n",
+    "        temperature=0.1,\n",
+    "        callbacks=[\n",
+    "            ArthurCallbackHandler.from_credentials(arthur_model_chatbot_id, arthur_url=arthur_url, arthur_login=arthur_login)\n",
+    "        ])\n",
+    "\n",
+    "def make_langchain_huggingface_llm():\n",
+    "    llm = HuggingFacePipeline.from_model_id(\n",
+    "        model_id=\"bert-base-uncased\", \n",
+    "        task=\"text-generation\", \n",
+    "        model_kwargs={\"temperature\":2.5, \"max_length\":64})\n",
+    "    llm.callbacks = [\n",
+    "        ArthurCallbackHandler.from_credentials(arthur_model_chatbot_id, arthur_url=arthur_url, arthur_login=arthur_login)\n",
+    "    ]\n",
+    "    return llm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "f40c3ce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai_llm = make_langchain_openai_llm()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "8476d531",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cohere_llm = make_langchain_cohere_llm()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7483b9d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "huggingface_llm = make_langchain_huggingface_llm()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c17d8e86",
+   "metadata": {},
+   "source": [
+    "Run the LLM (each completion is independent, no chat history is saved as we were doing above with the chat llms)\n",
+    "\n",
+    "Type `q` to quit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "72ee0790",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_langchain_llm(llm):\n",
+    "    while True:\n",
+    "        print(\"Type your text for completion:\\n\")\n",
+    "        user_input = input(\"\\n>>> input >>>\\n>>>: \")\n",
+    "        if user_input == 'q': break\n",
+    "        print(llm(user_input), \"\\n================\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "fb864057",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_langchain_llm(openai_llm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "e6673769",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_langchain_llm(cohere_llm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "85541f1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_langchain_llm(huggingface_llm)"
+   ]
+  }
+ ],
+ "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/ecosystem/integrations/cassandra.mdx

@@ -1,19 +1,21 @@
 # Cassandra
 
->[Cassandra](https://en.wikipedia.org/wiki/Apache_Cassandra) is a free and open-source, distributed, wide-column 
+>[Apache Cassandra®](https://cassandra.apache.org/) is a free and open-source, distributed, wide-column 
 > store, NoSQL database management system designed to handle large amounts of data across many commodity servers, 
-> providing high availability with no single point of failure. `Cassandra` offers support for clusters spanning 
+> providing high availability with no single point of failure. Cassandra offers support for clusters spanning 
 > multiple datacenters, with asynchronous masterless replication allowing low latency operations for all clients. 
-> `Cassandra` was designed to implement a combination of `Amazon's Dynamo` distributed storage and replication 
-> techniques combined with `Google's Bigtable` data and storage engine model.
+> Cassandra was designed to implement a combination of _Amazon's Dynamo_ distributed storage and replication 
+> techniques combined with _Google's Bigtable_ data and storage engine model.
  
 ## Installation and Setup
 
 ```bash
-pip install cassandra-drive
+pip install cassandra-driver
+pip install cassio
 ```
 
 
+
 ## Memory
 
 See a [usage example](/docs/modules/memory/integrations/cassandra_chat_message_history.html).

docs/extras/ecosystem/integrations/flyte.mdx

@@ -0,0 +1,153 @@
+# Flyte
+
+> [Flyte](https://github.com/flyteorg/flyte) is an open-source orchestrator that facilitates building production-grade data and ML pipelines.
+> It is built for scalability and reproducibility, leveraging Kubernetes as its underlying platform.
+
+The purpose of this notebook is to demonstrate the integration of a `FlyteCallback` into your Flyte task, enabling you to effectively monitor and track your LangChain experiments.
+
+## Installation & Setup
+
+- Install the Flytekit library by running the command `pip install flytekit`.
+- Install the Flytekit-Envd plugin by running the command `pip install flytekitplugins-envd`.
+- Install LangChain by running the command `pip install langchain`.
+- Install [Docker](https://docs.docker.com/engine/install/) on your system.
+
+## Flyte Tasks
+
+A Flyte [task](https://docs.flyte.org/projects/cookbook/en/latest/auto/core/flyte_basics/task.html) serves as the foundational building block of Flyte.
+To execute LangChain experiments, you need to write Flyte tasks that define the specific steps and operations involved.
+
+NOTE: The [getting started guide](https://docs.flyte.org/projects/cookbook/en/latest/index.html) offers detailed, step-by-step instructions on installing Flyte locally and running your initial Flyte pipeline.
+
+First, import the necessary dependencies to support your LangChain experiments.
+
+```python
+import os
+
+from flytekit import ImageSpec, task
+from langchain.agents import AgentType, initialize_agent, load_tools
+from langchain.callbacks import FlyteCallbackHandler
+from langchain.chains import LLMChain
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.schema import HumanMessage
+```
+
+Set up the necessary environment variables to utilize the OpenAI API and Serp API:
+
+```python
+# Set OpenAI API key
+os.environ["OPENAI_API_KEY"] = "<your_openai_api_key>"
+
+# Set Serp API key
+os.environ["SERPAPI_API_KEY"] = "<your_serp_api_key>"
+```
+
+Replace `<your_openai_api_key>` and `<your_serp_api_key>` with your respective API keys obtained from OpenAI and Serp API.
+
+To guarantee reproducibility of your pipelines, Flyte tasks are containerized.
+Each Flyte task must be associated with an image, which can either be shared across the entire Flyte [workflow](https://docs.flyte.org/projects/cookbook/en/latest/auto/core/flyte_basics/basic_workflow.html) or provided separately for each task.
+
+To streamline the process of supplying the required dependencies for each Flyte task, you can initialize an [`ImageSpec`](https://docs.flyte.org/projects/cookbook/en/latest/auto/core/image_spec/image_spec.html) object.
+This approach automatically triggers a Docker build, alleviating the need for users to manually create a Docker image.
+
+```python
+custom_image = ImageSpec(
+    name="langchain-flyte",
+    packages=[
+        "langchain",
+        "openai",
+        "spacy",
+        "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.5.0/en_core_web_sm-3.5.0.tar.gz",
+        "textstat",
+        "google-search-results",
+    ],
+    registry="<your-registry>",
+)
+```
+
+You have the flexibility to push the Docker image to a registry of your preference.
+[Docker Hub](https://hub.docker.com/) or [GitHub Container Registry (GHCR)](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry) is a convenient option to begin with.
+
+Once you have selected a registry, you can proceed to create Flyte tasks that log the LangChain metrics to Flyte Deck.
+
+The following examples demonstrate tasks related to OpenAI LLM, chains and agent with tools:
+
+### LLM
+
+```python
+@task(disable_deck=False, container_image=custom_image)
+def langchain_llm() -> str:
+    llm = ChatOpenAI(
+        model_name="gpt-3.5-turbo",
+        temperature=0.2,
+        callbacks=[FlyteCallbackHandler()],
+    )
+    return llm([HumanMessage(content="Tell me a joke")]).content
+```
+
+### Chain
+
+```python
+@task(disable_deck=False, container_image=custom_image)
+def langchain_chain() -> list[dict[str, str]]:
+    template = """You are a playwright. Given the title of play, it is your job to write a synopsis for that title.
+Title: {title}
+Playwright: This is a synopsis for the above play:"""
+    llm = ChatOpenAI(
+        model_name="gpt-3.5-turbo",
+        temperature=0,
+        callbacks=[FlyteCallbackHandler()],
+    )
+    prompt_template = PromptTemplate(input_variables=["title"], template=template)
+    synopsis_chain = LLMChain(
+        llm=llm, prompt=prompt_template, callbacks=[FlyteCallbackHandler()]
+    )
+    test_prompts = [
+        {
+            "title": "documentary about good video games that push the boundary of game design"
+        },
+    ]
+    return synopsis_chain.apply(test_prompts)
+```
+
+### Agent
+
+```python
+@task(disable_deck=False, container_image=custom_image)
+def langchain_agent() -> str:
+    llm = OpenAI(
+        model_name="gpt-3.5-turbo",
+        temperature=0,
+        callbacks=[FlyteCallbackHandler()],
+    )
+    tools = load_tools(
+        ["serpapi", "llm-math"], llm=llm, callbacks=[FlyteCallbackHandler()]
+    )
+    agent = initialize_agent(
+        tools,
+        llm,
+        agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+        callbacks=[FlyteCallbackHandler()],
+        verbose=True,
+    )
+    return agent.run(
+        "Who is Leonardo DiCaprio's girlfriend? Could you calculate her current age and raise it to the power of 0.43?"
+    )
+```
+
+These tasks serve as a starting point for running your LangChain experiments within Flyte.
+
+## Execute the Flyte Tasks on Kubernetes
+
+To execute the Flyte tasks on the configured Flyte backend, use the following command:
+
+```bash
+pyflyte run --image <your-image> langchain_flyte.py langchain_llm
+```
+
+This command will initiate the execution of the `langchain_llm` task on the Flyte backend. You can trigger the remaining two tasks in a similar manner.
+
+The metrics will be displayed on the Flyte UI as follows:
+
+![LangChain LLM](https://ik.imagekit.io/c8zl7irwkdda/Screenshot_2023-06-20_at_1.23.29_PM_MZYeG0dKa.png?updatedAt=1687247642993)

docs/extras/ecosystem/integrations/grobid.mdx

@@ -0,0 +1,44 @@
+# Grobid
+
+This page covers how to use the Grobid to parse articles for LangChain.
+It is seperated into two parts: installation and running the server
+
+## Installation and Setup
+#Ensure You have Java installed
+!apt-get install -y openjdk-11-jdk -q
+!update-alternatives --set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java
+
+#Clone and install the Grobid Repo
+import os
+!git clone https://github.com/kermitt2/grobid.git
+os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-11-openjdk-amd64"
+os.chdir('grobid')
+!./gradlew clean install
+
+#Run the server, 
+get_ipython().system_raw('nohup ./gradlew run > grobid.log 2>&1 &')
+
+You can now use the GrobidParser to produce documents
+```python
+from langchain.document_loaders.parsers import GrobidParser
+from langchain.document_loaders.generic import GenericLoader
+
+#Produce chunks from article paragraphs
+loader = GenericLoader.from_filesystem(
+    "/Users/31treehaus/Desktop/Papers/",
+    glob="*",
+    suffixes=[".pdf"],
+    parser= GrobidParser(segment_sentences=False)
+)
+docs = loader.load()
+
+#Produce chunks from article sentences
+loader = GenericLoader.from_filesystem(
+    "/Users/31treehaus/Desktop/Papers/",
+    glob="*",
+    suffixes=[".pdf"],
+    parser= GrobidParser(segment_sentences=True)
+)
+docs = loader.load()
+```
+Chunk metadata will include bboxes although these are a bit funky to parse, see https://grobid.readthedocs.io/en/latest/Coordinates-in-PDF/

docs/extras/ecosystem/integrations/unstructured.mdx

@@ -23,11 +23,15 @@ its dependencies running locally.
 If you want to get up and running with less set up, you can
 simply run `pip install unstructured` and use `UnstructuredAPIFileLoader` or
 `UnstructuredAPIFileIOLoader`. That will process your document using the hosted Unstructured API.
-Note that currently (as of 1 May 2023) the Unstructured API is open, but it will soon require
-an API. The [Unstructured documentation page](https://unstructured-io.github.io/) will have
-instructions on how to generate an API key once they're available. Check out the instructions
-[here](https://github.com/Unstructured-IO/unstructured-api#dizzy-instructions-for-using-the-docker-image)
-if you'd like to self-host the Unstructured API or run it locally.
+
+
+The Unstructured API requires API keys to make requests.
+You can generate a free API key [here](https://www.unstructured.io/api-key) and start using it today!
+Checkout the README [here](https://github.com/Unstructured-IO/unstructured-api) here to get started making API calls.
+We'd love to hear your feedback, let us know how it goes in our [community slack](https://join.slack.com/t/unstructuredw-kbe4326/shared_invite/zt-1x7cgo0pg-PTptXWylzPQF9xZolzCnwQ).
+And stay tuned for improvements to both quality and performance!
+Check out the instructions
+[here](https://github.com/Unstructured-IO/unstructured-api#dizzy-instructions-for-using-the-docker-image) if you'd like to self-host the Unstructured API or run it locally.
 
 ## Wrappers
 

docs/extras/guides/evaluation/comparisons.ipynb

@@ -243,8 +243,8 @@
     "            pred_a, pred_b = res_b, res_a\n",
     "            a, b = \"b\", \"a\"\n",
     "        eval_res = eval_chain.evaluate_string_pairs(\n",
-    "            output_a=pred_a['output'] if isinstance(pred_a, dict) else str(pred_a),\n",
-    "            output_b=pred_b['output'] if isinstance(pred_b, dict) else str(pred_b),\n",
+    "            prediction=pred_a['output'] if isinstance(pred_a, dict) else str(pred_a),\n",
+    "            prediction_b=pred_b['output'] if isinstance(pred_b, dict) else str(pred_b),\n",
     "            input=input_\n",
     "        )\n",
     "        if eval_res[\"value\"] == \"A\":\n",

docs/extras/modules/agents/how_to/custom-functions-with-openai-functions-agent.ipynb

@@ -0,0 +1,386 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "g9EmNu5DD9YI"
+   },
+   "source": [
+    "# Custom functions with OpenAI Functions Agent\n",
+    "\n",
+    "This notebook goes through how to integrate custom functions with OpenAI Functions agent."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LFKylC3CPtTl"
+   },
+   "source": [
+    "Install libraries which are required to run this example notebook\n",
+    "\n",
+    "`pip install -q openai langchain yfinance`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "E2DqzmEGDPak"
+   },
+   "source": [
+    "## Define custom functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "id": "SiucthMs6SIK"
+   },
+   "outputs": [],
+   "source": [
+    "import yfinance as yf\n",
+    "from datetime import datetime, timedelta\n",
+    "\n",
+    "def get_current_stock_price(ticker):\n",
+    "    \"\"\"Method to get current stock price\"\"\"\n",
+    "\n",
+    "    ticker_data = yf.Ticker(ticker)\n",
+    "    recent = ticker_data.history(period='1d')\n",
+    "    return {\n",
+    "        'price': recent.iloc[0]['Close'],\n",
+    "        'currency': ticker_data.info['currency']\n",
+    "    }\n",
+    "\n",
+    "def get_stock_performance(ticker, days):\n",
+    "    \"\"\"Method to get stock price change in percentage\"\"\"\n",
+    "\n",
+    "    past_date = datetime.today() - timedelta(days=days)\n",
+    "    ticker_data = yf.Ticker(ticker)\n",
+    "    history = ticker_data.history(start=past_date)\n",
+    "    old_price = history.iloc[0]['Close']\n",
+    "    current_price = history.iloc[-1]['Close']\n",
+    "    return {\n",
+    "        'percent_change': ((current_price - old_price)/old_price)*100\n",
+    "        }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "vRLINGvQR1rO",
+    "outputId": "68230a4b-dda2-4273-b956-7439661e3785"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'price': 334.57000732421875, 'currency': 'USD'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "get_current_stock_price('MSFT')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "57T190q235mD",
+    "outputId": "c6ee66ec-0659-4632-85d1-263b08826e68"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'percent_change': 1.014466941163018}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "get_stock_performance('MSFT', 30)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MT8QsdyBDhwg"
+   },
+   "source": [
+    "## Make custom tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "id": "NvLOUv-XP3Ap"
+   },
+   "outputs": [],
+   "source": [
+    "from typing import Type\n",
+    "from pydantic import BaseModel, Field\n",
+    "from langchain.tools import BaseTool\n",
+    "\n",
+    "class CurrentStockPriceInput(BaseModel):\n",
+    "    \"\"\"Inputs for get_current_stock_price\"\"\"\n",
+    "    ticker: str = Field(description=\"Ticker symbol of the stock\")\n",
+    "\n",
+    "class CurrentStockPriceTool(BaseTool):\n",
+    "    name = \"get_current_stock_price\"\n",
+    "    description = \"\"\"\n",
+    "        Useful when you want to get current stock price.\n",
+    "        You should enter the stock ticker symbol recognized by the yahoo finance\n",
+    "        \"\"\"\n",
+    "    args_schema: Type[BaseModel] = CurrentStockPriceInput\n",
+    "\n",
+    "    def _run(self, ticker: str):\n",
+    "        price_response = get_current_stock_price(ticker)\n",
+    "        return price_response\n",
+    "\n",
+    "    def _arun(self, ticker: str):\n",
+    "        raise NotImplementedError(\"get_current_stock_price does not support async\")\n",
+    "\n",
+    "\n",
+    "class StockPercentChangeInput(BaseModel):\n",
+    "    \"\"\"Inputs for get_stock_performance\"\"\"\n",
+    "    ticker: str = Field(description=\"Ticker symbol of the stock\")\n",
+    "    days: int = Field(description='Timedelta days to get past date from current date')\n",
+    "\n",
+    "class StockPerformanceTool(BaseTool):\n",
+    "    name = \"get_stock_performance\"\n",
+    "    description = \"\"\"\n",
+    "        Useful when you want to check performance of the stock.\n",
+    "        You should enter the stock ticker symbol recognized by the yahoo finance.\n",
+    "        You should enter days as number of days from today from which performance needs to be check.\n",
+    "        output will be the change in the stock price represented as a percentage.\n",
+    "        \"\"\"\n",
+    "    args_schema: Type[BaseModel] = StockPercentChangeInput\n",
+    "\n",
+    "    def _run(self, ticker: str, days: int):\n",
+    "        response = get_stock_performance(ticker, days)\n",
+    "        return response\n",
+    "\n",
+    "    def _arun(self, ticker: str):\n",
+    "        raise NotImplementedError(\"get_stock_performance does not support async\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PVKoqeCyFKHF"
+   },
+   "source": [
+    "## Create Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "yY7qNB7vSQGh"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentType\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.agents import initialize_agent\n",
+    "\n",
+    "llm = ChatOpenAI(\n",
+    "    model=\"gpt-3.5-turbo-0613\",\n",
+    "    temperature=0\n",
+    ")\n",
+    "\n",
+    "tools = [\n",
+    "    CurrentStockPriceTool(),\n",
+    "    StockPerformanceTool()\n",
+    "]\n",
+    "\n",
+    "agent = initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 321
+    },
+    "id": "4X96xmgwRkcC",
+    "outputId": "a91b13ef-9643-4f60-d067-c4341e0b285e"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `get_current_stock_price` with `{'ticker': 'MSFT'}`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3m{'price': 334.57000732421875, 'currency': 'USD'}\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `get_stock_performance` with `{'ticker': 'MSFT', 'days': 180}`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\u001b[33;1m\u001b[1;3m{'percent_change': 40.163963297187905}\u001b[0m\u001b[32;1m\u001b[1;3mThe current price of Microsoft stock is $334.57 USD. \n",
+      "\n",
+      "Over the past 6 months, Microsoft stock has performed well with a 40.16% increase in its price.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The current price of Microsoft stock is $334.57 USD. \\n\\nOver the past 6 months, Microsoft stock has performed well with a 40.16% increase in its price.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run(\"What is the current price of Microsoft stock? How it has performed over past 6 months?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 285
+    },
+    "id": "nkZ_vmAcT7Al",
+    "outputId": "092ebc55-4d28-4a4b-aa2a-98ae47ceec20"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `get_current_stock_price` with `{'ticker': 'GOOGL'}`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3m{'price': 118.33000183105469, 'currency': 'USD'}\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `get_current_stock_price` with `{'ticker': 'META'}`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3m{'price': 287.04998779296875, 'currency': 'USD'}\u001b[0m\u001b[32;1m\u001b[1;3mThe recent stock price of Google (GOOGL) is $118.33 USD and the recent stock price of Meta (META) is $287.05 USD.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The recent stock price of Google (GOOGL) is $118.33 USD and the recent stock price of Meta (META) is $287.05 USD.'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run(\"Give me recent stock prices of Google and Meta?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 466
+    },
+    "id": "jLU-HjMq7n1o",
+    "outputId": "a42194dd-26ed-4b5a-d4a2-1038420045c4"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `get_stock_performance` with `{'ticker': 'MSFT', 'days': 90}`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\u001b[33;1m\u001b[1;3m{'percent_change': 18.043096235165596}\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `get_stock_performance` with `{'ticker': 'GOOGL', 'days': 90}`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\u001b[33;1m\u001b[1;3m{'percent_change': 17.286155760642853}\u001b[0m\u001b[32;1m\u001b[1;3mIn the past 3 months, Microsoft (MSFT) has performed better than Google (GOOGL). Microsoft's stock price has increased by 18.04% while Google's stock price has increased by 17.29%.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"In the past 3 months, Microsoft (MSFT) has performed better than Google (GOOGL). Microsoft's stock price has increased by 18.04% while Google's stock price has increased by 17.29%.\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run('In the past 3 months, which stock between Microsoft and Google has performed the best?')"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

docs/extras/modules/agents/tools/integrations/zapier.ipynb

@@ -21,7 +21,7 @@
     "\n",
     "2. User-facing (Oauth): for production scenarios where you are deploying an end-user facing application and LangChain needs access to end-user's exposed actions and connected accounts on Zapier.com\n",
     "\n",
-    "This quick start will focus on the server-side use case for brevity. Review [full docs](https://nla.zapier.com/start/) for user-facing oauth developer support.\n",
+    "This quick start will focus mostly on the server-side use case for brevity. Jump to [Example Using OAuth Access Token](#oauth) to see a short example how to set up Zapier for user-facing situations. Review [full docs](https://nla.zapier.com/start/) for full user-facing oauth developer support.\n",
     "\n",
     "This example goes over how to use the Zapier integration with a `SimpleSequentialChain`, then an `Agent`.\n",
     "In code, below:"
@@ -149,7 +149,7 @@
    "id": "bcdea831",
    "metadata": {},
    "source": [
-    "# Example with SimpleSequentialChain\n",
+    "## Example with SimpleSequentialChain\n",
     "If you need more explicit control, use a chain, like below."
    ]
   },
@@ -323,12 +323,34 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "id": "09ff954e-45f2-4595-92ea-91627abde4a0",
    "metadata": {},
+   "source": [
+    "## <a id=\"oauth\">Example Using OAuth Access Token</a>\n",
+    "The below snippet shows how to initialize the wrapper with a procured OAuth access token. Note the argument being passed in as opposed to setting an environment variable. Review the [authentication docs](https://nla.zapier.com/docs/authentication/#oauth-credentials) for full user-facing oauth developer support.\n",
+    "\n",
+    "The developer is tasked with handling the OAuth handshaking to procure and refresh the access token."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c6835c8",
+   "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "llm = OpenAI(temperature=0)\n",
+    "zapier = ZapierNLAWrapper(zapier_nla_oauth_access_token='<fill in access token here>')\n",
+    "toolkit = ZapierToolkit.from_zapier_nla_wrapper(zapier)\n",
+    "agent = initialize_agent(\n",
+    "    toolkit.get_tools(), llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True\n",
+    ")\n",
+    "\n",
+    "agent.run(\n",
+    "    \"Summarize the last email I received regarding Silicon Valley Bank. Send the summary to the #test-zapier channel in slack.\"\n",
+    ")"
+   ]
   }
  ],
  "metadata": {

docs/extras/modules/callbacks/integrations/promptlayer.ipynb

@@ -0,0 +1,211 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PromptLayer\n",
+    "\n",
+    "<img src=\"https://promptlayer.com/logo.png\"  height=\"300\">\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[PromptLayer](https://promptlayer.com) is a an observability platform for prompts and LLMs. In this guide we will go over how to setup the `PromptLayerCallbackHandler`. While PromptLayer does have LLMs that integrate directly with LangChain (eg [`PromptLayerOpenAI`](https://python.langchain.com/docs/modules/model_io/models/llms/integrations/promptlayer_openai)), this callback will be an easier and more feature rich way to integrate PromptLayer with any model on LangChain. \n",
+    "\n",
+    "This callback is also the recommended way to connect with PromptLayer when building Chains and Agents on LangChain."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Installation and Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install promptlayer --upgrade"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Getting API Credentials\n",
+    "\n",
+    "If you have not already create an account on [PromptLayer](https://www.promptlayer.com) and get an API key by clicking on the settings cog in the navbar\n",
+    "Set it as an environment variabled called `PROMPTLAYER_API_KEY`\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Usage\n",
+    "\n",
+    "To get started with `PromptLayerCallbackHandler` is fairly simple, it takes two optional arguments:\n",
+    "1. `pl_tags` - an optional list of strings that will be tags tracked on PromptLayer\n",
+    "2. `pl_id_callback` - an optional function that will get a `promptlayer_request_id` as an argument. This id can be used with all of PromptLayers tracking features to track, metadata, scores, and prompt usage."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simple Example\n",
+    "\n",
+    "In this simple example we use `PromptLayerCallbackHandler` with `ChatOpenAI`. We add a PromptLayer tag named `chatopenai`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\"Sure, here's one:\\n\\nWhy did the tomato turn red?\\n\\nBecause it saw the salad dressing!\" additional_kwargs={} example=False\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.schema import (\n",
+    "    HumanMessage,\n",
+    ")\n",
+    "from langchain.callbacks import PromptLayerCallbackHandler\n",
+    "\n",
+    "chat_llm = ChatOpenAI(\n",
+    "    temperature=0,\n",
+    "    callbacks=[PromptLayerCallbackHandler(pl_tags=[\"chatopenai\"])],\n",
+    ")\n",
+    "llm_results = chat_llm(\n",
+    "    [\n",
+    "        HumanMessage(content=\"What comes after 1,2,3 ?\"),\n",
+    "        HumanMessage(content=\"Tell me another joke?\"),\n",
+    "    ]\n",
+    ")\n",
+    "print(llm_results)\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Full Featured Example\n",
+    "\n",
+    "In this example we unlock more of the power of PromptLayer.\n",
+    "\n",
+    "We are using the Prompt Registry and fetching the prompt called `example`.\n",
+    "\n",
+    "We also define a `pl_id_callback` function that tracks a score, metadata and the prompt used. Read more about tracking on [our docs](docs.promptlayer.com)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "prompt layer id  6050929\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'\\nToasterCo.'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.callbacks import PromptLayerCallbackHandler\n",
+    "import promptlayer\n",
+    "\n",
+    "def pl_id_callback(promptlayer_request_id):\n",
+    "    print(\"prompt layer id \", promptlayer_request_id)\n",
+    "    promptlayer.track.score(\n",
+    "        request_id=promptlayer_request_id, score=100\n",
+    "    )  # score is an integer 0-100\n",
+    "    promptlayer.track.metadata(\n",
+    "        request_id=promptlayer_request_id, metadata={\"foo\": \"bar\"}\n",
+    "    )  # metadata is a dictionary of key value pairs that is tracked on PromptLayer\n",
+    "    promptlayer.track.prompt(\n",
+    "        request_id=promptlayer_request_id,\n",
+    "        prompt_name=\"example\",\n",
+    "        prompt_input_variables={\"product\": \"toasters\"},\n",
+    "        version=1,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "openai_llm = OpenAI(\n",
+    "    model_name=\"text-davinci-002\",\n",
+    "    callbacks=[PromptLayerCallbackHandler(pl_id_callback=pl_id_callback)],\n",
+    ")\n",
+    "\n",
+    "example_prompt = promptlayer.prompts.get(\"example\", version=1, langchain=True)\n",
+    "openai_llm(example_prompt.format(product=\"toasters\"))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That is all it takes! After setup all your requests will show up on the PromptLayer dasahboard.\n",
+    "This callback also works with any LLM implemented on LangChain."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "c4fe2cd85a8d9e8baaec5340ce66faff1c77581a9f43e6c45e85e09b6fced008"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/extras/modules/data_connection/document_loaders/integrations/example_data/README.org

@@ -0,0 +1,27 @@
+* Example Docs
+
+The sample docs directory contains the following files:
+
+-  ~example-10k.html~ - A 10-K SEC filing in HTML format
+-  ~layout-parser-paper.pdf~ - A PDF copy of the layout parser paper
+-  ~factbook.xml~ / ~factbook.xsl~ - Example XML/XLS files that you
+   can use to test stylesheets
+
+These documents can be used to test out the parsers in the library. In
+addition, here are instructions for pulling in some sample docs that are
+too big to store in the repo.
+
+** XBRL 10-K
+
+You can get an example 10-K in inline XBRL format using the following
+~curl~. Note, you need to have the user agent set in the header or the
+SEC site will reject your request.
+
+#+BEGIN_SRC bash
+
+   curl -O \
+     -A '${organization} ${email}'
+     https://www.sec.gov/Archives/edgar/data/311094/000117184321001344/0001171843-21-001344.txt
+#+END_SRC
+
+You can parse this document using the HTML parser.

docs/extras/modules/data_connection/document_loaders/integrations/example_data/source_code/example.js

@@ -0,0 +1,17 @@
+class MyClass {
+  constructor(name) {
+    this.name = name;
+  }
+
+  greet() {
+    console.log(`Hello, ${this.name}!`);
+  }
+}
+
+function main() {
+  const name = prompt("Enter your name:");
+  const obj = new MyClass(name);
+  obj.greet();
+}
+
+main();

docs/extras/modules/data_connection/document_loaders/integrations/example_data/source_code/example.py

@@ -0,0 +1,16 @@
+class MyClass:
+    def __init__(self, name):
+        self.name = name
+
+    def greet(self):
+        print(f"Hello, {self.name}!")
+
+
+def main():
+    name = input("Enter your name: ")
+    obj = MyClass(name)
+    obj.greet()
+
+
+if __name__ == "__main__":
+    main()

docs/extras/modules/data_connection/document_loaders/integrations/grobid.ipynb

@@ -0,0 +1,180 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bdccb278",
+   "metadata": {},
+   "source": [
+    "# Grobid\n",
+    "\n",
+    "GROBID is a machine learning library for extracting, parsing, and re-structuring raw documents.\n",
+    "\n",
+    "It is particularly good for sturctured PDFs, like academic papers.\n",
+    "\n",
+    "This loader uses GROBIB to parse PDFs into `Documents` that retain metadata associated with the section of text.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "For users on `Mac` - \n",
+    "\n",
+    "(Note: additional instructions can be found [here](https://python.langchain.com/docs/ecosystem/integrations/grobid.mdx).)\n",
+    "\n",
+    "Install Java (Apple Silicon):\n",
+    "```\n",
+    "$ arch -arm64 brew install openjdk@11\n",
+    "$ brew --prefix openjdk@11\n",
+    "/opt/homebrew/opt/openjdk@ 11\n",
+    "```\n",
+    "\n",
+    "In `~/.zshrc`:\n",
+    "```\n",
+    "export JAVA_HOME=/opt/homebrew/opt/openjdk@11\n",
+    "export PATH=$JAVA_HOME/bin:$PATH\n",
+    "```\n",
+    "\n",
+    "Then, in Terminal:\n",
+    "```\n",
+    "$ source ~/.zshrc\n",
+    "```\n",
+    "\n",
+    "Confirm install:\n",
+    "```\n",
+    "$ which java\n",
+    "/opt/homebrew/opt/openjdk@11/bin/java\n",
+    "$ java -version \n",
+    "openjdk version \"11.0.19\" 2023-04-18\n",
+    "OpenJDK Runtime Environment Homebrew (build 11.0.19+0)\n",
+    "OpenJDK 64-Bit Server VM Homebrew (build 11.0.19+0, mixed mode)\n",
+    "```\n",
+    "\n",
+    "Then, get [Grobid](https://grobid.readthedocs.io/en/latest/Install-Grobid/#getting-grobid):\n",
+    "```\n",
+    "$ curl -LO https://github.com/kermitt2/grobid/archive/0.7.3.zip\n",
+    "$ unzip 0.7.3.zip\n",
+    "```\n",
+    "                   \n",
+    "Build\n",
+    "```\n",
+    "$ ./gradlew clean install\n",
+    "```\n",
+    "\n",
+    "Then, run the server:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2d8992fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! get_ipython().system_raw('nohup ./gradlew run > grobid.log 2>&1 &')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b41bfb1",
+   "metadata": {},
+   "source": [
+    "Now, we can use the data loader."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "640e9a4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders.parsers import GrobidParser\n",
+    "from langchain.document_loaders.generic import GenericLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ecdc1fb9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = GenericLoader.from_filesystem(\n",
+    "    \"../Papers/\",\n",
+    "    glob=\"*\",\n",
+    "    suffixes=[\".pdf\"],\n",
+    "    parser= GrobidParser(segment_sentences=False)\n",
+    ")\n",
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "efe9e356",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Unlike Chinchilla, PaLM, or GPT-3, we only use publicly available data, making our work compatible with open-sourcing, while most existing models rely on data which is either not publicly available or undocumented (e.g.\"Books -2TB\" or \"Social media conversations\").There exist some exceptions, notably OPT (Zhang et al., 2022), GPT-NeoX (Black et al., 2022), BLOOM (Scao et al., 2022) and GLM (Zeng et al., 2022), but none that are competitive with PaLM-62B or Chinchilla.'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[3].page_content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5be03d17",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'text': 'Unlike Chinchilla, PaLM, or GPT-3, we only use publicly available data, making our work compatible with open-sourcing, while most existing models rely on data which is either not publicly available or undocumented (e.g.\"Books -2TB\" or \"Social media conversations\").There exist some exceptions, notably OPT (Zhang et al., 2022), GPT-NeoX (Black et al., 2022), BLOOM (Scao et al., 2022) and GLM (Zeng et al., 2022), but none that are competitive with PaLM-62B or Chinchilla.',\n",
+       " 'para': '2',\n",
+       " 'bboxes': \"[[{'page': '1', 'x': '317.05', 'y': '509.17', 'h': '207.73', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '522.72', 'h': '220.08', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '536.27', 'h': '218.27', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '549.82', 'h': '218.65', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '563.37', 'h': '136.98', 'w': '9.46'}], [{'page': '1', 'x': '446.49', 'y': '563.37', 'h': '78.11', 'w': '9.46'}, {'page': '1', 'x': '304.69', 'y': '576.92', 'h': '138.32', 'w': '9.46'}], [{'page': '1', 'x': '447.75', 'y': '576.92', 'h': '76.66', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '590.47', 'h': '219.63', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '604.02', 'h': '218.27', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '617.56', 'h': '218.27', 'w': '9.46'}, {'page': '1', 'x': '306.14', 'y': '631.11', 'h': '220.18', 'w': '9.46'}]]\",\n",
+       " 'pages': \"('1', '1')\",\n",
+       " 'section_title': 'Introduction',\n",
+       " 'section_number': '1',\n",
+       " 'paper_title': 'LLaMA: Open and Efficient Foundation Language Models',\n",
+       " 'file_path': '/Users/31treehaus/Desktop/Papers/2302.13971.pdf'}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[3].metadata"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/larksuite.ipynb

@@ -0,0 +1,103 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "33205b12",
+   "metadata": {},
+   "source": [
+    "# LarkSuite (FeiShu)\n",
+    "\n",
+    ">[LarkSuite](https://www.larksuite.com/) is an enterprise collaboration platform developed by ByteDance.\n",
+    "\n",
+    "This notebook covers how to load data from the `LarkSuite` REST API into a format that can be ingested into LangChain, along with example usage for text summarization.\n",
+    "\n",
+    "The LarkSuite API requires an access token (tenant_access_token or user_access_token), checkout [LarkSuite open platform document](https://open.larksuite.com/document) for API details."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "90b69c94",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-19T10:05:03.645161Z",
+     "start_time": "2023-06-19T10:04:49.541968Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from getpass import getpass\n",
+    "from langchain.document_loaders.larksuite import LarkSuiteDocLoader\n",
+    "\n",
+    "DOMAIN = input(\"larksuite domain\")\n",
+    "ACCESS_TOKEN = getpass(\"larksuite tenant_access_token or user_access_token\")\n",
+    "DOCUMENT_ID = input(\"larksuite document id\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "13deb0f5",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-19T10:05:36.016495Z",
+     "start_time": "2023-06-19T10:05:35.360884Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Document(page_content='Test Doc\\nThis is a Test Doc\\n\\n1\\n2\\n3\\n\\n', metadata={'document_id': 'V76kdbd2HoBbYJxdiNNccajunPf', 'revision_id': 11, 'title': 'Test Doc'})]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pprint import pprint\n",
+    "\n",
+    "larksuite_loader = LarkSuiteDocLoader(DOMAIN, ACCESS_TOKEN, DOCUMENT_ID)\n",
+    "docs = larksuite_loader.load()\n",
+    "\n",
+    "pprint(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ccc1e2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# see https://python.langchain.com/docs/use_cases/summarization for more details\n",
+    "from langchain.chains.summarize import load_summarize_chain\n",
+    "\n",
+    "chain = load_summarize_chain(llm, chain_type=\"map_reduce\")\n",
+    "chain.run(docs)"
+   ]
+  }
+ ],
+ "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.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/org_mode.ipynb

@@ -0,0 +1,88 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Org-mode\n",
+    "\n",
+    ">A [Org Mode document](https://en.wikipedia.org/wiki/Org-mode) is a document editing, formatting, and organizing mode, designed for notes, planning, and authoring within the free software text editor Emacs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## `UnstructuredOrgModeLoader`\n",
+    "\n",
+    "You can load data from Org-mode files with `UnstructuredOrgModeLoader` using the following workflow."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import UnstructuredOrgModeLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = UnstructuredOrgModeLoader(\n",
+    "    file_path=\"example_data/README.org\", mode=\"elements\"\n",
+    ")\n",
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page_content='Example Docs' metadata={'source': 'example_data/README.org', 'filename': 'README.org', 'file_directory': 'example_data', 'filetype': 'text/org', 'page_number': 1, 'category': 'Title'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(docs[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.8.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/extras/modules/data_connection/document_loaders/integrations/source_code.ipynb

@@ -0,0 +1,419 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "213a38a2",
+   "metadata": {},
+   "source": [
+    "# Source Code\n",
+    "\n",
+    "This notebook covers how to load source code files using a special approach with language parsing: each top-level function and class in the code is loaded into separate documents. Any remaining code top-level code outside the already loaded functions and classes will be loaded into a seperate document.\n",
+    "\n",
+    "This approach can potentially improve the accuracy of QA models over source code. Currently, the supported languages for code parsing are Python and JavaScript. The language used for parsing can be configured, along with the minimum number of lines required to activate the splitting based on syntax."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fa47b2e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install esprima"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "beb55c2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "from pprint import pprint\n",
+    "from langchain.text_splitter import Language\n",
+    "from langchain.document_loaders.generic import GenericLoader\n",
+    "from langchain.document_loaders.parsers import LanguageParser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "64056e07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = GenericLoader.from_filesystem(\n",
+    "    \"./example_data/source_code\",\n",
+    "    glob=\"*\",\n",
+    "    suffixes=[\".py\", \".js\"],\n",
+    "    parser=LanguageParser()\n",
+    ")\n",
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8af79bd7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "85edf3fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'content_type': 'functions_classes',\n",
+      " 'language': <Language.PYTHON: 'python'>,\n",
+      " 'source': 'example_data/source_code/example.py'}\n",
+      "{'content_type': 'functions_classes',\n",
+      " 'language': <Language.PYTHON: 'python'>,\n",
+      " 'source': 'example_data/source_code/example.py'}\n",
+      "{'content_type': 'simplified_code',\n",
+      " 'language': <Language.PYTHON: 'python'>,\n",
+      " 'source': 'example_data/source_code/example.py'}\n",
+      "{'content_type': 'functions_classes',\n",
+      " 'language': <Language.JS: 'js'>,\n",
+      " 'source': 'example_data/source_code/example.js'}\n",
+      "{'content_type': 'functions_classes',\n",
+      " 'language': <Language.JS: 'js'>,\n",
+      " 'source': 'example_data/source_code/example.js'}\n",
+      "{'content_type': 'simplified_code',\n",
+      " 'language': <Language.JS: 'js'>,\n",
+      " 'source': 'example_data/source_code/example.js'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "for document in docs:\n",
+    "    pprint(document.metadata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "f44e3e37",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "class MyClass:\n",
+      "    def __init__(self, name):\n",
+      "        self.name = name\n",
+      "\n",
+      "    def greet(self):\n",
+      "        print(f\"Hello, {self.name}!\")\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "def main():\n",
+      "    name = input(\"Enter your name: \")\n",
+      "    obj = MyClass(name)\n",
+      "    obj.greet()\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "# Code for: class MyClass:\n",
+      "\n",
+      "\n",
+      "# Code for: def main():\n",
+      "\n",
+      "\n",
+      "if __name__ == \"__main__\":\n",
+      "    main()\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "class MyClass {\n",
+      "  constructor(name) {\n",
+      "    this.name = name;\n",
+      "  }\n",
+      "\n",
+      "  greet() {\n",
+      "    console.log(`Hello, ${this.name}!`);\n",
+      "  }\n",
+      "}\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "function main() {\n",
+      "  const name = prompt(\"Enter your name:\");\n",
+      "  const obj = new MyClass(name);\n",
+      "  obj.greet();\n",
+      "}\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "// Code for: class MyClass {\n",
+      "\n",
+      "// Code for: function main() {\n",
+      "\n",
+      "main();\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\n\\n--8<--\\n\\n\".join([document.page_content for document in docs]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "69aad0ed",
+   "metadata": {},
+   "source": [
+    "The parser can be disabled for small files. \n",
+    "\n",
+    "The parameter `parser_threshold` indicates the minimum number of lines that the source code file must have to be segmented using the parser."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ae024794",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = GenericLoader.from_filesystem(\n",
+    "    \"./example_data/source_code\",\n",
+    "    glob=\"*\",\n",
+    "    suffixes=[\".py\"],\n",
+    "    parser=LanguageParser(language=Language.PYTHON, parser_threshold=1000)\n",
+    ")\n",
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5d3b372a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "89e546ad",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "class MyClass:\n",
+      "    def __init__(self, name):\n",
+      "        self.name = name\n",
+      "\n",
+      "    def greet(self):\n",
+      "        print(f\"Hello, {self.name}!\")\n",
+      "\n",
+      "\n",
+      "def main():\n",
+      "    name = input(\"Enter your name: \")\n",
+      "    obj = MyClass(name)\n",
+      "    obj.greet()\n",
+      "\n",
+      "\n",
+      "if __name__ == \"__main__\":\n",
+      "    main()\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9c71e61",
+   "metadata": {},
+   "source": [
+    "## Splitting\n",
+    "\n",
+    "Additional splitting could be needed for those functions, classes, or scripts that are too big."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "adbaa79f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = GenericLoader.from_filesystem(\n",
+    "    \"./example_data/source_code\",\n",
+    "    glob=\"*\",\n",
+    "    suffixes=[\".js\"],\n",
+    "    parser=LanguageParser(language=Language.JS)\n",
+    ")\n",
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "c44c0d3f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.text_splitter import (\n",
+    "    RecursiveCharacterTextSplitter,\n",
+    "    Language,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b1e0053d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "js_splitter = RecursiveCharacterTextSplitter.from_language(\n",
+    "    language=Language.JS, chunk_size=60, chunk_overlap=0\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "7dbe6188",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = js_splitter.split_documents(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8a80d089",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "000a6011",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "class MyClass {\n",
+      "  constructor(name) {\n",
+      "    this.name = name;\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "}\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "greet() {\n",
+      "    console.log(`Hello, ${this.name}!`);\n",
+      "  }\n",
+      "}\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "function main() {\n",
+      "  const name = prompt(\"Enter your name:\");\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "const obj = new MyClass(name);\n",
+      "  obj.greet();\n",
+      "}\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "// Code for: class MyClass {\n",
+      "\n",
+      "// Code for: function main() {\n",
+      "\n",
+      "--8<--\n",
+      "\n",
+      "main();\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\n\\n--8<--\\n\\n\".join([document.page_content for document in result]))"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/tencent_cos_directory.ipynb

@@ -0,0 +1,116 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a634365e",
+   "metadata": {},
+   "source": [
+    "# Tencent COS Directory\n",
+    "\n",
+    "This covers how to load document objects from a `Tencent COS Directory`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "85e97267",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#! pip install cos-python-sdk-v5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2f0cd6a5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TencentCOSDirectoryLoader\n",
+    "from qcloud_cos import CosConfig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "321cc7f1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "conf = CosConfig(\n",
+    "        Region=\"your cos region\",\n",
+    "        SecretId=\"your cos secret_id\",\n",
+    "        SecretKey=\"your cos secret_key\",\n",
+    "    )\n",
+    "loader = TencentCOSDirectoryLoader(conf=conf, bucket=\"you_cos_bucket\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c50d2c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0690c40a",
+   "metadata": {},
+   "source": [
+    "## Specifying a prefix\n",
+    "You can also specify a prefix for more finegrained control over what files to load."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "72d44781",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = TencentCOSDirectoryLoader(conf=conf, bucket=\"you_cos_bucket\", prefix=\"fake\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d3c32db",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "loader.load()"
+   ]
+  }
+ ],
+ "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/tencent_cos_file.ipynb

@@ -0,0 +1,91 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a634365e",
+   "metadata": {},
+   "source": [
+    "# Tencent COS File\n",
+    "\n",
+    "This covers how to load document object from a `Tencent COS File`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "85e97267",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#! pip install cos-python-sdk-v5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2f0cd6a5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TencentCOSFileLoader\n",
+    "from qcloud_cos import CosConfig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "321cc7f1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "conf = CosConfig(\n",
+    "        Region=\"your cos region\",\n",
+    "        SecretId=\"your cos secret_id\",\n",
+    "        SecretKey=\"your cos secret_key\",\n",
+    "    )\n",
+    "loader = TencentCOSFileLoader(conf=conf, bucket=\"you_cos_bucket\", key=\"fake.docx\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c50d2c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0690c40a",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/unstructured_file.ipynb

@@ -226,7 +226,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "8de9ef16",
    "metadata": {},
@@ -303,7 +302,7 @@
    "source": [
     "## Unstructured API\n",
     "\n",
-    "If you want to get up and running with less set up, you can simply run `pip install unstructured` and use `UnstructuredAPIFileLoader` or `UnstructuredAPIFileIOLoader`. That will process your document using the hosted Unstructured API. Note that currently (as of 11 May 2023) the Unstructured API is open, but it will soon require an API. The [Unstructured documentation](https://unstructured-io.github.io/) page will have instructions on how to generate an API key once they’re available. Check out the instructions [here](https://github.com/Unstructured-IO/unstructured-api#dizzy-instructions-for-using-the-docker-image) if you’d like to self-host the Unstructured API or run it locally."
+    "If you want to get up and running with less set up, you can simply run `pip install unstructured` and use `UnstructuredAPIFileLoader` or `UnstructuredAPIFileIOLoader`. That will process your document using the hosted Unstructured API. You can generate a free Unstructured API key [here](https://www.unstructured.io/api-key/). The [Unstructured documentation](https://unstructured-io.github.io/) page will have instructions on how to generate an API key once they’re available. Check out the instructions [here](https://github.com/Unstructured-IO/unstructured-api#dizzy-instructions-for-using-the-docker-image) if you’d like to self-host the Unstructured API or run it locally."
    ]
   },
   {

docs/extras/modules/data_connection/document_loaders/integrations/web_base.ipynb

@@ -224,13 +224,33 @@
     "docs"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Using proxies\n",
+    "\n",
+    "Sometimes you might need to use proxies to get around IP blocks. You can pass in a dictionary of proxies to the loader (and `requests` underneath) to use them."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "1dd8ab23",
-   "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "loader = WebBaseLoader(\n",
+    "    \"https://www.walmart.com/search?q=parrots\", proxies={\n",
+    "        \"http\": \"http://{username}:{password}:@proxy.service.com:6666/\",\n",
+    "        \"https\": \"https://{username}:{password}:@proxy.service.com:6666/\"\n",
+    "    }\n",
+    ")\n",
+    "docs = loader.load()\n"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   }
  ],
  "metadata": {

docs/extras/modules/data_connection/retrievers/how_to/MultiQueryRetriever.ipynb

@@ -0,0 +1,214 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8cc82b48",
+   "metadata": {},
+   "source": [
+    "# MultiQueryRetriever\n",
+    "\n",
+    "Distance-based vector database retrieval embeds (represents) queries in high-dimensional space and finds similar embedded documents based on \"distance\". But, retrieval may produce difference results with subtle changes in query wording or if the embeddings do not capture the semantics of the data well. Prompt engineering / tuning is sometimes done to manually address these problems, but can be tedious.\n",
+    "\n",
+    "The `MultiQueryRetriever` automates the process of prompt tuning by using an LLM to generate multiple queries from different perspectives for a given user input query. For each query, it retrieves a set of relevant documents and takes the unique union across all queries to get a larger set of potentially relevant documents. By generating multiple perspectives on the same question, the `MultiQueryRetriever` might be able to overcome some of the limitations of the distance-based retrieval and get a richer set of results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c2f3f5f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Build a sample vectorDB\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain.document_loaders import PyPDFLoader\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "\n",
+    "# Load PDF\n",
+    "path=\"path-to-files\"\n",
+    "loaders = [\n",
+    "    PyPDFLoader(path+\"docs/cs229_lectures/MachineLearning-Lecture01.pdf\"),\n",
+    "    PyPDFLoader(path+\"docs/cs229_lectures/MachineLearning-Lecture02.pdf\"),\n",
+    "    PyPDFLoader(path+\"docs/cs229_lectures/MachineLearning-Lecture03.pdf\")\n",
+    "]\n",
+    "docs = []\n",
+    "for loader in loaders:\n",
+    "    docs.extend(loader.load())\n",
+    "    \n",
+    "# Split\n",
+    "text_splitter = RecursiveCharacterTextSplitter(chunk_size = 1500,chunk_overlap = 150)\n",
+    "splits = text_splitter.split_documents(docs)\n",
+    "\n",
+    "# VectorDB\n",
+    "embedding = OpenAIEmbeddings()\n",
+    "vectordb = Chroma.from_documents(documents=splits,embedding=embedding)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cca8f56c",
+   "metadata": {},
+   "source": [
+    "`Simple usage`\n",
+    "\n",
+    "Specify the LLM to use for query generation, and the retriver will do the rest."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "edbca101",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.retrievers.multi_query import MultiQueryRetriever\n",
+    "question=\"What does the course say about regression?\"\n",
+    "num_queries=3\n",
+    "llm = ChatOpenAI(temperature=0)\n",
+    "retriever_from_llm = MultiQueryRetriever.from_llm(retriever=vectordb.as_retriever(),llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e5203612",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:root:Generated queries: [\"1. What is the course's perspective on regression?\", '2. How does the course discuss regression?', '3. What information does the course provide about regression?']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "unique_docs = retriever_from_llm.get_relevant_documents(question=\"What does the course say about regression?\")\n",
+    "len(unique_docs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c54a282f",
+   "metadata": {},
+   "source": [
+    "`Supplying your own prompt`\n",
+    "\n",
+    "You can also supply a prompt along with an output parser to split the results into a list of queries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d9afb0ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List\n",
+    "from langchain import LLMChain\n",
+    "from pydantic import BaseModel, Field\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.output_parsers import PydanticOutputParser\n",
+    "\n",
+    "# Output parser will split the LLM result into a list of queries\n",
+    "class LineList(BaseModel):\n",
+    "    # \"lines\" is the key (attribute name) of the parsed output\n",
+    "    lines: List[str] = Field(description=\"Lines of text\")\n",
+    "\n",
+    "class LineListOutputParser(PydanticOutputParser):\n",
+    "    def __init__(self) -> None:\n",
+    "        super().__init__(pydantic_object=LineList)\n",
+    "    def parse(self, text: str) -> LineList:\n",
+    "        lines = text.strip().split(\"\\n\")\n",
+    "        return LineList(lines=lines)\n",
+    "\n",
+    "output_parser = LineListOutputParser()\n",
+    "    \n",
+    "QUERY_PROMPT = PromptTemplate(\n",
+    "    input_variables=[\"question\"],\n",
+    "    template=\"\"\"You are an AI language model assistant. Your task is to generate five \n",
+    "    different versions of the given user question to retrieve relevant documents from a vector \n",
+    "    database. By generating multiple perspectives on the user question, your goal is to help\n",
+    "    the user overcome some of the limitations of the distance-based similarity search. \n",
+    "    Provide these alternative questions seperated by newlines.\n",
+    "    Original question: {question}\"\"\",\n",
+    ")\n",
+    "llm = ChatOpenAI(temperature=0)\n",
+    "\n",
+    "# Chain\n",
+    "llm_chain = LLMChain(llm=llm,prompt=QUERY_PROMPT,output_parser=output_parser)\n",
+    " \n",
+    "# Other inputs\n",
+    "question=\"What does the course say about regression?\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6660d7ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:root:Generated queries: [\"1. What is the course's perspective on regression?\", '2. Can you provide information on regression as discussed in the course?', '3. How does the course cover the topic of regression?', \"4. What are the course's teachings on regression?\", '5. In relation to the course, what is mentioned about regression?']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "8"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Run\n",
+    "retriever = MultiQueryRetriever(retriever=vectordb.as_retriever(), \n",
+    "                                llm_chain=llm_chain,\n",
+    "                                parser_key=\"lines\") # \"lines\" is the key (attribute name) of the parsed output\n",
+    "\n",
+    "# Results\n",
+    "unique_docs = retriever.get_relevant_documents(question=\"What does the course say about regression?\")\n",
+    "len(unique_docs)"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/vectorstores/integrations/clickhouse.ipynb

@@ -0,0 +1,399 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "683953b3",
+   "metadata": {},
+   "source": [
+    "# ClickHouse Vector Search\n",
+    "\n",
+    "> [ClickHouse](https://clickhouse.com/) is the fastest and most resource efficient open-source database for real-time apps and analytics with full SQL support and a wide range of functions to assist users in writing analytical queries. Lately added data structures and distance search functions (like `L2Distance`) as well as [approximate nearest neighbor search indexes](https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/annindexes) enable ClickHouse to be used as a high performance and scalable vector database to store and search vectors with SQL.\n",
+    "\n",
+    "This notebook shows how to use functionality related to the `ClickHouse` vector search."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43ead5d5-2c1f-4dce-a69a-cb00e4f9d6f0",
+   "metadata": {},
+   "source": [
+    "## Setting up envrionments"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2c434bc",
+   "metadata": {},
+   "source": [
+    "Setting up local clickhouse server with docker (optional)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "249a7751",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:43:43.035606Z",
+     "start_time": "2023-06-03T08:43:42.618531Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "! docker run -d -p 8123:8123 -p9000:9000 --name langchain-clickhouse-server --ulimit nofile=262144:262144 clickhouse/clickhouse-server:23.4.2.11"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7bd3c1c0",
+   "metadata": {},
+   "source": [
+    "Setup up clickhouse client driver"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d614bf8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install clickhouse-connect"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15a1d477-9cdb-4d82-b019-96951ecb2b72",
+   "metadata": {},
+   "source": [
+    "We want to use OpenAIEmbeddings so we have to get the OpenAI API Key."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "91003ea5-0c8c-436c-a5de-aaeaeef2f458",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:49:35.383673Z",
+     "start_time": "2023-06-03T08:49:33.984547Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "if not os.environ['OPENAI_API_KEY']:\n",
+    "    os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "aac9563e",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:33:31.554934Z",
+     "start_time": "2023-06-03T08:33:31.549590Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import Clickhouse, ClickhouseSettings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a3c3999a",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:33:32.527387Z",
+     "start_time": "2023-06-03T08:33:32.501312Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TextLoader\n",
+    "loader = TextLoader('../../../state_of_the_union.txt')\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6e104aee",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:33:35.503823Z",
+     "start_time": "2023-06-03T08:33:33.745832Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Inserting data...: 100%|██████████| 42/42 [00:00<00:00, 2801.49it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for d in docs:\n",
+    "    d.metadata = {'some': 'metadata'}\n",
+    "settings = ClickhouseSettings(table=\"clickhouse_vector_search_example\")\n",
+    "docsearch = Clickhouse.from_documents(docs, embeddings, config=settings)\n",
+    "\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = docsearch.similarity_search(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9c608226",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3a8b105",
+   "metadata": {},
+   "source": [
+    "## Get connection info and data schema"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "69996818",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:28:58.252991Z",
+     "start_time": "2023-06-03T08:28:58.197560Z"
+    },
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[92m\u001b[1mdefault.clickhouse_vector_search_example @ localhost:8123\u001b[0m\n",
+      "\n",
+      "\u001b[1musername: None\u001b[0m\n",
+      "\n",
+      "Table Schema:\n",
+      "---------------------------------------------------\n",
+      "|\u001b[94mid                      \u001b[0m|\u001b[96mNullable(String)        \u001b[0m|\n",
+      "|\u001b[94mdocument                \u001b[0m|\u001b[96mNullable(String)        \u001b[0m|\n",
+      "|\u001b[94membedding               \u001b[0m|\u001b[96mArray(Float32)          \u001b[0m|\n",
+      "|\u001b[94mmetadata                \u001b[0m|\u001b[96mObject('json')          \u001b[0m|\n",
+      "|\u001b[94muuid                    \u001b[0m|\u001b[96mUUID                    \u001b[0m|\n",
+      "---------------------------------------------------\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(str(docsearch))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "324ac147",
+   "metadata": {},
+   "source": [
+    "### Clickhouse table schema"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5bd7c5b",
+   "metadata": {},
+   "source": [
+    "> Clickhouse table will be automatically created if not exist by default. Advanced users could pre-create the table with optimized settings. For distributed Clickhouse cluster with sharding, table engine should be configured as `Distributed`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "54f4f561",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Clickhouse Table DDL:\n",
+      "\n",
+      "CREATE TABLE IF NOT EXISTS default.clickhouse_vector_search_example(\n",
+      "    id Nullable(String),\n",
+      "    document Nullable(String),\n",
+      "    embedding Array(Float32),\n",
+      "    metadata JSON,\n",
+      "    uuid UUID DEFAULT generateUUIDv4(),\n",
+      "    CONSTRAINT cons_vec_len CHECK length(embedding) = 1536,\n",
+      "    INDEX vec_idx embedding TYPE annoy(100,'L2Distance') GRANULARITY 1000\n",
+      ") ENGINE = MergeTree ORDER BY uuid SETTINGS index_granularity = 8192\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Clickhouse Table DDL:\\n\\n{docsearch.schema}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f59360c0",
+   "metadata": {},
+   "source": [
+    "## Filtering\n",
+    "\n",
+    "You can have direct access to ClickHouse SQL where statement. You can write `WHERE` clause following standard SQL.\n",
+    "\n",
+    "**NOTE**: Please be aware of SQL injection, this interface must not be directly called by end-user.\n",
+    "\n",
+    "If you custimized your `column_map` under your setting, you search with filter like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "232055f6",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:29:36.680805Z",
+     "start_time": "2023-06-03T08:29:34.963676Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Inserting data...: 100%|██████████| 42/42 [00:00<00:00, 6939.56it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.vectorstores import Clickhouse, ClickhouseSettings\n",
+    "from langchain.document_loaders import TextLoader\n",
+    "\n",
+    "loader = TextLoader('../../../state_of_the_union.txt')\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()\n",
+    "\n",
+    "for i, d in enumerate(docs):\n",
+    "    d.metadata = {'doc_id': i}\n",
+    "\n",
+    "docsearch = Clickhouse.from_documents(docs, embeddings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ddbcee77",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:29:43.487436Z",
+     "start_time": "2023-06-03T08:29:43.040831Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.6779101415357189 {'doc_id': 0} Madam Speaker, Madam...\n",
+      "0.6997970363474885 {'doc_id': 8} And so many families...\n",
+      "0.7044504914336727 {'doc_id': 1} Groups of citizens b...\n",
+      "0.7053558702165094 {'doc_id': 6} And I’m taking robus...\n"
+     ]
+    }
+   ],
+   "source": [
+    "meta = docsearch.metadata_column\n",
+    "output = docsearch.similarity_search_with_relevance_scores('What did the president say about Ketanji Brown Jackson?', \n",
+    "                                                           k=4, where_str=f\"{meta}.doc_id<10\")\n",
+    "for d, dist in output:\n",
+    "    print(dist, d.metadata, d.page_content[:20] + '...')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a359ed74",
+   "metadata": {},
+   "source": [
+    "## Deleting your data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fb6a9d36",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-03T08:30:24.822384Z",
+     "start_time": "2023-06-03T08:30:24.798571Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "docsearch.drop()"
+   ]
+  }
+ ],
+ "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.11.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/vectorstores/integrations/mongodb_atlas_vector_search.ipynb

@@ -0,0 +1,169 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "683953b3",
+   "metadata": {},
+   "source": [
+    "# MongoDB Atlas Vector Search\n",
+    "\n",
+    ">[MongoDB Atlas](https://www.mongodb.com/docs/atlas/) is a document database managed in the cloud. It also enables Lucene and its vector search feature.\n",
+    "\n",
+    "This notebook shows how to use the functionality related to the `MongoDB Atlas Vector Search` feature where you can store your embeddings in MongoDB documents and create a Lucene vector index to perform a KNN search.\n",
+    "\n",
+    "It uses the [knnBeta Operator](https://www.mongodb.com/docs/atlas/atlas-search/knn-beta) available in MongoDB Atlas Search. This feature is in early access and available only for evaluation purposes, to validate functionality, and to gather feedback from a small closed group of early access users. It is not recommended for production deployments as we may introduce breaking changes.\n",
+    "\n",
+    "To use MongoDB Atlas, you must have first deployed a cluster. Free clusters are available. \n",
+    "Here is the MongoDB Atlas [quick start](https://www.mongodb.com/docs/atlas/getting-started/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4c41cad-08ef-4f72-a545-2151e4598efe",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "!pip install pymongo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1e38361-c1fe-4ac6-86e9-c90ebaf7ae87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "MONGODB_ATLAS_URI = os.environ['MONGODB_ATLAS_URI']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "320af802-9271-46ee-948f-d2453933d44b",
+   "metadata": {},
+   "source": [
+    "We want to use `OpenAIEmbeddings` so we have to get the OpenAI API Key. Make sure the environment variable `OPENAI_API_KEY` is set up before proceeding."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f3ecc42",
+   "metadata": {},
+   "source": [
+    "Now, let's create a Lucene vector index on your cluster. In the below example, `embedding` is the name of the field that contains the embedding vector. Please refer to the [documentation](https://www.mongodb.com/docs/atlas/atlas-search/define-field-mappings-for-vector-search) to get more details on how to define an Atlas Search index.\n",
+    "You can name the index `langchain_demo` and create the index on the namespace `lanchain_db.langchain_col`. Finally, write the following definition in the JSON editor:\n",
+    "\n",
+    "```json\n",
+    "{\n",
+    "  \"mappings\": {\n",
+    "    \"dynamic\": true,\n",
+    "    \"fields\": {\n",
+    "      \"embedding\": {\n",
+    "        \"dimensions\": 1536,\n",
+    "        \"similarity\": \"cosine\",\n",
+    "        \"type\": \"knnVector\"\n",
+    "      }\n",
+    "    }\n",
+    "  }\n",
+    "}\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "aac9563e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import MongoDBAtlasVectorSearch\n",
+    "from langchain.document_loaders import TextLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a3c3999a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TextLoader\n",
+    "loader = TextLoader('../../../state_of_the_union.txt')\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e104aee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pymongo import MongoClient\n",
+    "\n",
+    "# initialize MongoDB python client\n",
+    "client = MongoClient(MONGODB_ATLAS_CONNECTION_STRING)\n",
+    "\n",
+    "db_name = \"lanchain_db\"\n",
+    "collection_name = \"langchain_col\"\n",
+    "collection = client[db_name][collection_name]\n",
+    "index_name = \"langchain_demo\"\n",
+    "\n",
+    "# insert the documents in MongoDB Atlas with their embedding\n",
+    "docsearch = MongoDBAtlasVectorSearch.from_documents(\n",
+    "    docs,\n",
+    "    embeddings,\n",
+    "    collection=collection,\n",
+    "    index_name=index_name\n",
+    ")\n",
+    "\n",
+    "# perform a similarity search between the embedding of the query and the embeddings of the documents\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = docsearch.similarity_search(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c608226",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(docs[0].page_content)"
+   ]
+  }
+ ],
+ "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.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/vectorstores/integrations/qdrant.ipynb

@@ -626,6 +626,44 @@
    "source": [
     "## Customizing Qdrant\n",
     "\n",
+    "There are some options to use an existing Qdrant collection within your Langchain application. In such cases you may need to define how to map Qdrant point into the Langchain `Document`.\n",
+    "\n",
+    "### Named vectors\n",
+    "\n",
+    "Qdrant supports [multiple vectors per point](https://qdrant.tech/documentation/concepts/collections/#collection-with-multiple-vectors) by named vectors. Langchain requires just a single embedding per document and, by default, uses a single vector. However, if you work with a collection created externally or want to have the named vector used, you can configure it by providing its name.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "Qdrant.from_documents(\n",
+    "    docs,\n",
+    "    embeddings,\n",
+    "    location=\":memory:\",\n",
+    "    collection_name=\"my_documents_2\",\n",
+    "    vector_name=\"custom_vector\",\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "As a Langchain user, you won't see any difference whether you use named vectors or not. Qdrant integration will handle the conversion under the hood."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Metadata\n",
+    "\n",
     "Qdrant stores your vector embeddings along with the optional JSON-like payload. Payloads are optional, but since LangChain assumes the embeddings are generated from the documents, we keep the context data, so you can extract the original texts as well.\n",
     "\n",
     "By default, your document is going to be stored in the following payload structure:\n",
@@ -639,8 +677,11 @@
     "}\n",
     "```\n",
     "\n",
-    "You can, however, decide to use different keys for the page content and metadata. That's useful if you already have a collection that you'd like to reuse. You can always change the "
-   ]
+    "You can, however, decide to use different keys for the page content and metadata. That's useful if you already have a collection that you'd like to reuse."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",

docs/extras/modules/memory/integrations/cassandra_chat_message_history.ipynb

@@ -1,34 +1,116 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
-   "id": "91c6a7ef",
+   "id": "90cd3ded",
    "metadata": {},
    "source": [
     "# Cassandra Chat Message History\n",
     "\n",
+    ">[Apache Cassandra®](https://cassandra.apache.org) is a NoSQL, row-oriented, highly scalable and highly available database, well suited for storing large amounts of data.\n",
+    "\n",
+    "Cassandra is a good choice for storing chat message history because it is easy to scale and can handle a large number of writes.\n",
+    "\n",
     "This notebook goes over how to use Cassandra to store chat message history.\n",
     "\n",
-    "Cassandra is a distributed database that is well suited for storing large amounts of data. \n",
-    "\n",
-    "It is a good choice for storing chat message history because it is easy to scale and can handle a large number of writes.\n"
+    "To run this notebook you need either a running Cassandra cluster or a DataStax Astra DB instance running in the cloud (you can get one for free at [datastax.com](https://astra.datastax.com)). Check [cassio.org](https://cassio.org/start_here/) for more information."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "47a601d2",
+   "execution_count": null,
+   "id": "d7092199",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# List of contact points to try connecting to Cassandra cluster.\n",
-    "contact_points = [\"cassandra\"]"
+    "!pip install \"cassio>=0.0.6\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3d97b65",
+   "metadata": {},
+   "source": [
+    "### Please provide database connection parameters and secrets:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
+   "id": "163d97f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "database_mode = (input('\\n(C)assandra or (A)stra DB? ')).upper()\n",
+    "\n",
+    "keyspace_name = input('\\nKeyspace name? ')\n",
+    "\n",
+    "if database_mode == 'A':\n",
+    "    ASTRA_DB_APPLICATION_TOKEN = getpass.getpass('\\nAstra DB Token (\"AstraCS:...\") ')\n",
+    "    #\n",
+    "    ASTRA_DB_SECURE_BUNDLE_PATH = input('Full path to your Secure Connect Bundle? ')\n",
+    "elif database_mode == 'C':\n",
+    "    CASSANDRA_CONTACT_POINTS = input('Contact points? (comma-separated, empty for localhost) ').strip()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55860b2d",
+   "metadata": {},
+   "source": [
+    "#### depending on whether local or cloud-based Astra DB, create the corresponding database connection \"Session\" object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8dff2798",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cassandra.cluster import Cluster\n",
+    "from cassandra.auth import PlainTextAuthProvider\n",
+    "\n",
+    "if database_mode == 'C':\n",
+    "    if CASSANDRA_CONTACT_POINTS:\n",
+    "        cluster = Cluster([\n",
+    "            cp.strip()\n",
+    "            for cp in CASSANDRA_CONTACT_POINTS.split(',')\n",
+    "            if cp.strip()\n",
+    "        ])\n",
+    "    else:\n",
+    "        cluster = Cluster()\n",
+    "    session = cluster.connect()\n",
+    "elif database_mode == 'A':\n",
+    "    ASTRA_DB_CLIENT_ID = \"token\"\n",
+    "    cluster = Cluster(\n",
+    "        cloud={\n",
+    "            \"secure_connect_bundle\": ASTRA_DB_SECURE_BUNDLE_PATH,\n",
+    "        },\n",
+    "        auth_provider=PlainTextAuthProvider(\n",
+    "            ASTRA_DB_CLIENT_ID,\n",
+    "            ASTRA_DB_APPLICATION_TOKEN,\n",
+    "        ),\n",
+    "    )\n",
+    "    session = cluster.connect()\n",
+    "else:\n",
+    "    raise NotImplementedError"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36c163e8",
+   "metadata": {},
+   "source": [
+    "### Creation and usage of the Chat Message History"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "id": "d15e3302",
    "metadata": {},
    "outputs": [],
@@ -36,7 +118,9 @@
     "from langchain.memory import CassandraChatMessageHistory\n",
     "\n",
     "message_history = CassandraChatMessageHistory(\n",
-    "    contact_points=contact_points, session_id=\"test-session\"\n",
+    "    session_id=\"test-session\",\n",
+    "    session=session,\n",
+    "    keyspace=keyspace_name,\n",
     ")\n",
     "\n",
     "message_history.add_user_message(\"hi!\")\n",
@@ -46,22 +130,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "64fc465e",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[HumanMessage(content='hi!', additional_kwargs={}, example=False),\n",
-       " AIMessage(content='whats up?', additional_kwargs={}, example=False)]"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "message_history.messages"
    ]
@@ -83,7 +155,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,

docs/extras/modules/model_io/models/llms/integrations/octoai.ipynb

@@ -0,0 +1,126 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## OctoAI Compute Service\n",
+    "This example goes over how to use LangChain to interact with `OctoAI` [LLM endpoints](https://octoai.cloud/templates)\n",
+    "## Environment setup\n",
+    "\n",
+    "To run our example app, there are four simple steps to take:\n",
+    "\n",
+    "1. Clone the MPT-7B demo template to your OctoAI account by visiting <https://octoai.cloud/templates/mpt-7b-demo> then clicking \"Clone Template.\" \n",
+    "   1. If you want to use a different LLM model, you can also containerize the model and make a custom OctoAI endpoint yourself, by following [Build a Container from Python](doc:create-custom-endpoints-from-python-code) and [Create a Custom Endpoint from a Container](doc:create-custom-endpoints-from-a-container)\n",
+    "   \n",
+    "2. Paste your Endpoint URL in the code cell below\n",
+    "\n",
+    "3. Get an API Token from [your OctoAI account page](https://octoai.cloud/settings).\n",
+    "   \n",
+    "4. Paste your API key in in the code cell below"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"OCTOAI_API_TOKEN\"] = \"OCTOAI_API_TOKEN\"\n",
+    "os.environ[\"ENDPOINT_URL\"] = \"https://mpt-7b-demo-kk0powt97tmb.octoai.cloud/generate\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms.octoai_endpoint import OctoAIEndpoint\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Below is an instruction that describes a task. Write a response that appropriately completes the request.\\n Instruction:\\n{question}\\n Response: \"\"\"\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OctoAIEndpoint(\n",
+    "        model_kwargs={\n",
+    "            \"max_new_tokens\": 200,\n",
+    "            \"temperature\": 0.75,\n",
+    "            \"top_p\": 0.95,\n",
+    "            \"repetition_penalty\": 1,\n",
+    "            \"seed\": None,\n",
+    "            \"stop\": [],\n",
+    "        },\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nLeonardo da Vinci was an Italian polymath and painter regarded by many as one of the greatest painters of all time. He is best known for his masterpieces including Mona Lisa, The Last Supper, and The Virgin of the Rocks. He was a draftsman, sculptor, architect, and one of the most important figures in the history of science. Da Vinci flew gliders, experimented with water turbines and windmills, and invented the catapult and a joystick-type human-powered aircraft control. He may have pioneered helicopters. As a scholar, he was interested in anatomy, geology, botany, engineering, mathematics, and astronomy.\\nOther painters and patrons claimed to be more talented, but Leonardo da Vinci was an incredibly productive artist, sculptor, engineer, anatomist, and scientist.'"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "question = \"Who was leonardo davinci?\"\n",
+    "\n",
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
+    "\n",
+    "llm_chain.run(question)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "langchain",
+   "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.16"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "97697b63fdcee0a640856f91cb41326ad601964008c341809e43189d1cab1047"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/extras/use_cases/apis.mdx

@@ -9,7 +9,7 @@ If you are just getting started, and you have relatively simple apis, you should
 Chains are a sequence of predetermined steps, so they are good to get started with as they give you more control and let you 
 understand what is happening better.
 
-- [API Chain](/docs/modules/chains/how_to/api.html)
+- [API Chain](/docs/modules/chains/popular/api.html)
 
 ## Agents
 

docs/extras/use_cases/question_answering/document-context-aware-QA.ipynb

@@ -30,14 +30,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "2e587f65",
    "metadata": {},
    "outputs": [],
    "source": [
     "# Load Notion page as a markdownfile file\n",
     "from langchain.document_loaders import NotionDirectoryLoader\n",
-    "path='.../Notion_Folder_With_Markdown_File'\n",
+    "path='../Notion_DB/'\n",
     "loader = NotionDirectoryLoader(path)\n",
     "docs = loader.load()\n",
     "md_file=docs[0].page_content"
@@ -45,7 +45,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "1cd3fd7e",
    "metadata": {},
    "outputs": [],
@@ -69,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 26,
    "id": "7fbff95f",
    "metadata": {},
    "outputs": [],
@@ -110,8 +110,10 @@
    "outputs": [],
    "source": [
     "# Build vectorstore and keep the metadata\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.vectorstores import Chroma\n",
-    "vectorstore = Chroma.from_documents(texts=all_splits,metadatas=all_metadatas,embedding=OpenAIEmbeddings())"
+    "vectorstore = Chroma.from_documents(documents=all_splits,\n",
+    "                                    embedding=OpenAIEmbeddings())"
    ]
   },
   {
@@ -157,6 +159,37 @@
     "We can see that we can query *only for texts* in the `Introduction` of the document!"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "d688db6e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query='Introduction' filter=Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='Section', value='Introduction') limit=None\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='![Untitled](Auto-Evaluation%20of%20Metadata%20Filtering%2018502448c85240828f33716740f9574b/Untitled.png)', metadata={'Section': 'Introduction'}),\n",
+       " Document(page_content='Q+A systems often use a two-step approach: retrieve relevant text chunks and then synthesize them into an answer. There many ways to approach this. For example, we recently [discussed](https://blog.langchain.dev/auto-evaluation-of-anthropic-100k-context-window/) the Retriever-Less option (at bottom in the below diagram), highlighting the Anthropic 100k context window model. Metadata filtering is an alternative approach that pre-filters chunks based on a user-defined criteria in a VectorDB using', metadata={'Section': 'Introduction'}),\n",
+       " Document(page_content='metadata tags prior to semantic search.', metadata={'Section': 'Introduction'})]"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Test\n",
+    "retriever.get_relevant_documents(\"Summarize the Introduction section of the document\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 29,
@@ -287,6 +320,11 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.9.16"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
+   }
   }
  },
  "nbformat": 4,

docs/requirements.txt

@@ -11,5 +11,4 @@ myst_nb
 sphinx_copybutton
 pydata-sphinx-theme==0.13.1
 nbdoc
-urllib3<2
-sphinx_tabs
+urllib3<2

langchain/agents/__init__.py

@@ -32,6 +32,7 @@ from langchain.agents.load_tools import (
 from langchain.agents.loading import load_agent
 from langchain.agents.mrkl.base import MRKLChain, ZeroShotAgent
 from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
+from langchain.agents.openai_functions_multi_agent.base import OpenAIMultiFunctionsAgent
 from langchain.agents.react.base import ReActChain, ReActTextWorldAgent
 from langchain.agents.self_ask_with_search.base import SelfAskWithSearchChain
 from langchain.agents.structured_chat.base import StructuredChatAgent
@@ -49,6 +50,7 @@ __all__ = [
     "LLMSingleActionAgent",
     "MRKLChain",
     "OpenAIFunctionsAgent",
+    "OpenAIMultiFunctionsAgent",
     "ReActChain",
     "ReActTextWorldAgent",
     "SelfAskWithSearchChain",

langchain/agents/agent_toolkits/zapier/toolkit.py

@@ -29,6 +29,23 @@ class ZapierToolkit(BaseToolkit):
         ]
         return cls(tools=tools)
 
+    @classmethod
+    async def async_from_zapier_nla_wrapper(
+        cls, zapier_nla_wrapper: ZapierNLAWrapper
+    ) -> "ZapierToolkit":
+        """Create a toolkit from a ZapierNLAWrapper."""
+        actions = await zapier_nla_wrapper.alist()
+        tools = [
+            ZapierNLARunAction(
+                action_id=action["id"],
+                zapier_description=action["description"],
+                params_schema=action["params"],
+                api_wrapper=zapier_nla_wrapper,
+            )
+            for action in actions
+        ]
+        return cls(tools=tools)
+
     def get_tools(self) -> List[BaseTool]:
         """Get the tools in the toolkit."""
         return self.tools

langchain/cache.py

@@ -262,7 +262,9 @@ class RedisSemanticCache(BaseCache):
             score_threshold (float, 0.2):
 
         Example:
+
         .. code-block:: python
+
             import langchain
 
             from langchain.cache import RedisSemanticCache

langchain/callbacks/__init__.py

@@ -3,9 +3,11 @@
 from langchain.callbacks.aim_callback import AimCallbackHandler
 from langchain.callbacks.argilla_callback import ArgillaCallbackHandler
 from langchain.callbacks.arize_callback import ArizeCallbackHandler
+from langchain.callbacks.arthur_callback import ArthurCallbackHandler
 from langchain.callbacks.clearml_callback import ClearMLCallbackHandler
 from langchain.callbacks.comet_ml_callback import CometCallbackHandler
 from langchain.callbacks.file import FileCallbackHandler
+from langchain.callbacks.flyte_callback import FlyteCallbackHandler
 from langchain.callbacks.human import HumanApprovalCallbackHandler
 from langchain.callbacks.infino_callback import InfinoCallbackHandler
 from langchain.callbacks.manager import (
@@ -15,6 +17,7 @@ from langchain.callbacks.manager import (
 )
 from langchain.callbacks.mlflow_callback import MlflowCallbackHandler
 from langchain.callbacks.openai_info import OpenAICallbackHandler
+from langchain.callbacks.promptlayer_callback import PromptLayerCallbackHandler
 from langchain.callbacks.stdout import StdOutCallbackHandler
 from langchain.callbacks.streaming_aiter import AsyncIteratorCallbackHandler
 from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
@@ -29,22 +32,25 @@ __all__ = [
     "AimCallbackHandler",
     "ArgillaCallbackHandler",
     "ArizeCallbackHandler",
-    "AsyncIteratorCallbackHandler",
+    "PromptLayerCallbackHandler",
+    "ArthurCallbackHandler",
     "ClearMLCallbackHandler",
     "CometCallbackHandler",
     "FileCallbackHandler",
-    "FinalStreamingStdOutCallbackHandler",
     "HumanApprovalCallbackHandler",
     "InfinoCallbackHandler",
     "MlflowCallbackHandler",
     "OpenAICallbackHandler",
     "StdOutCallbackHandler",
+    "AsyncIteratorCallbackHandler",
     "StreamingStdOutCallbackHandler",
-    "StreamlitCallbackHandler",
+    "FinalStreamingStdOutCallbackHandler",
     "LLMThoughtLabeler",
+    "StreamlitCallbackHandler",
     "WandbCallbackHandler",
     "WhyLabsCallbackHandler",
     "get_openai_callback",
     "tracing_enabled",
     "wandb_tracing_enabled",
+    "FlyteCallbackHandler",
 ]

langchain/callbacks/arthur_callback.py

@@ -0,0 +1,302 @@
+"""ArthurAI's Callback Handler."""
+from __future__ import annotations
+
+import os
+import uuid
+from collections import defaultdict
+from datetime import datetime
+from time import time
+from typing import TYPE_CHECKING, Any, DefaultDict, Dict, List, Optional, Union
+
+import numpy as np
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.schema import AgentAction, AgentFinish, LLMResult
+
+if TYPE_CHECKING:
+    import arthurai
+    from arthurai.core.models import ArthurModel
+
+PROMPT_TOKENS = "prompt_tokens"
+COMPLETION_TOKENS = "completion_tokens"
+TOKEN_USAGE = "token_usage"
+FINISH_REASON = "finish_reason"
+DURATION = "duration"
+
+
+def _lazy_load_arthur() -> arthurai:
+    """Lazy load Arthur."""
+    try:
+        import arthurai
+    except ImportError as e:
+        raise ImportError(
+            "To use the ArthurCallbackHandler you need the"
+            " `arthurai` package. Please install it with"
+            " `pip install arthurai`.",
+            e,
+        )
+
+    return arthurai
+
+
+class ArthurCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs to Arthur platform.
+
+    Arthur helps enterprise teams optimize model operations
+    and performance at scale. The Arthur API tracks model
+    performance, explainability, and fairness across tabular,
+    NLP, and CV models. Our API is model- and platform-agnostic,
+    and continuously scales with complex and dynamic enterprise needs.
+    To learn more about Arthur, visit our website at
+    https://www.arthur.ai/ or read the Arthur docs at
+    https://docs.arthur.ai/
+    """
+
+    def __init__(
+        self,
+        arthur_model: ArthurModel,
+    ) -> None:
+        """Initialize callback handler."""
+        super().__init__()
+        arthurai = _lazy_load_arthur()
+        Stage = arthurai.common.constants.Stage
+        ValueType = arthurai.common.constants.ValueType
+        self.arthur_model = arthur_model
+        # save the attributes of this model to be used when preparing
+        # inferences to log to Arthur in on_llm_end()
+        self.attr_names = set([a.name for a in self.arthur_model.get_attributes()])
+        self.input_attr = [
+            x
+            for x in self.arthur_model.get_attributes()
+            if x.stage == Stage.ModelPipelineInput
+            and x.value_type == ValueType.Unstructured_Text
+        ][0].name
+        self.output_attr = [
+            x
+            for x in self.arthur_model.get_attributes()
+            if x.stage == Stage.PredictedValue
+            and x.value_type == ValueType.Unstructured_Text
+        ][0].name
+        self.token_likelihood_attr = None
+        if (
+            len(
+                [
+                    x
+                    for x in self.arthur_model.get_attributes()
+                    if x.value_type == ValueType.TokenLikelihoods
+                ]
+            )
+            > 0
+        ):
+            self.token_likelihood_attr = [
+                x
+                for x in self.arthur_model.get_attributes()
+                if x.value_type == ValueType.TokenLikelihoods
+            ][0].name
+
+        self.run_map: DefaultDict[str, Any] = defaultdict(dict)
+
+    @classmethod
+    def from_credentials(
+        cls,
+        model_id: str,
+        arthur_url: Optional[str] = "https://app.arthur.ai",
+        arthur_login: Optional[str] = None,
+        arthur_password: Optional[str] = None,
+    ) -> ArthurCallbackHandler:
+        """Initialize callback handler from Arthur credentials.
+
+        Args:
+            model_id (str): The ID of the arthur model to log to.
+            arthur_url (str, optional): The URL of the Arthur instance to log to.
+                Defaults to "https://app.arthur.ai".
+            arthur_login (str, optional): The login to use to connect to Arthur.
+                Defaults to None.
+            arthur_password (str, optional): The password to use to connect to
+                Arthur. Defaults to None.
+
+        Returns:
+            ArthurCallbackHandler: The initialized callback handler.
+        """
+        arthurai = _lazy_load_arthur()
+        ArthurAI = arthurai.ArthurAI
+        ResponseClientError = arthurai.common.exceptions.ResponseClientError
+
+        # connect to Arthur
+        if arthur_login is None:
+            try:
+                arthur_api_key = os.environ["ARTHUR_API_KEY"]
+            except KeyError:
+                raise ValueError(
+                    "No Arthur authentication provided. Either give"
+                    " a login to the ArthurCallbackHandler"
+                    " or set an ARTHUR_API_KEY as an environment variable."
+                )
+            arthur = ArthurAI(url=arthur_url, access_key=arthur_api_key)
+        else:
+            if arthur_password is None:
+                arthur = ArthurAI(url=arthur_url, login=arthur_login)
+            else:
+                arthur = ArthurAI(
+                    url=arthur_url, login=arthur_login, password=arthur_password
+                )
+        # get model from Arthur by the provided model ID
+        try:
+            arthur_model = arthur.get_model(model_id)
+        except ResponseClientError:
+            raise ValueError(
+                f"Was unable to retrieve model with id {model_id} from Arthur."
+                " Make sure the ID corresponds to a model that is currently"
+                " registered with your Arthur account."
+            )
+        return cls(arthur_model)
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """On LLM start, save the input prompts"""
+        run_id = kwargs["run_id"]
+        self.run_map[run_id]["input_texts"] = prompts
+        self.run_map[run_id]["start_time"] = time()
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """On LLM end, send data to Arthur."""
+        try:
+            import pytz  # type: ignore[import]
+        except ImportError as e:
+            raise ImportError(
+                "Could not import pytz. Please install it with 'pip install pytz'."
+            ) from e
+
+        run_id = kwargs["run_id"]
+
+        # get the run params from this run ID,
+        # or raise an error if this run ID has no corresponding metadata in self.run_map
+        try:
+            run_map_data = self.run_map[run_id]
+        except KeyError as e:
+            raise KeyError(
+                "This function has been called with a run_id"
+                " that was never registered in on_llm_start()."
+                " Restart and try running the LLM again"
+            ) from e
+
+        # mark the duration time between on_llm_start() and on_llm_end()
+        time_from_start_to_end = time() - run_map_data["start_time"]
+
+        # create inferences to log to Arthur
+        inferences = []
+        for i, generations in enumerate(response.generations):
+            for generation in generations:
+                inference = {
+                    "partner_inference_id": str(uuid.uuid4()),
+                    "inference_timestamp": datetime.now(tz=pytz.UTC),
+                    self.input_attr: run_map_data["input_texts"][i],
+                    self.output_attr: generation.text,
+                }
+
+                if generation.generation_info is not None:
+                    # add finish reason to the inference
+                    # if generation info contains a finish reason and
+                    # if the ArthurModel was registered to monitor finish_reason
+                    if (
+                        FINISH_REASON in generation.generation_info
+                        and FINISH_REASON in self.attr_names
+                    ):
+                        inference[FINISH_REASON] = generation.generation_info[
+                            FINISH_REASON
+                        ]
+
+                    # add token likelihoods data to the inference if the ArthurModel
+                    # was registered to monitor token likelihoods
+                    logprobs_data = generation.generation_info["logprobs"]
+                    if (
+                        logprobs_data is not None
+                        and self.token_likelihood_attr is not None
+                    ):
+                        logprobs = logprobs_data["top_logprobs"]
+                        likelihoods = [
+                            {k: np.exp(v) for k, v in logprobs[i].items()}
+                            for i in range(len(logprobs))
+                        ]
+                        inference[self.token_likelihood_attr] = likelihoods
+
+                # add token usage counts to the inference if the
+                # ArthurModel was registered to monitor token usage
+                if (
+                    isinstance(response.llm_output, dict)
+                    and TOKEN_USAGE in response.llm_output
+                ):
+                    token_usage = response.llm_output[TOKEN_USAGE]
+                    if (
+                        PROMPT_TOKENS in token_usage
+                        and PROMPT_TOKENS in self.attr_names
+                    ):
+                        inference[PROMPT_TOKENS] = token_usage[PROMPT_TOKENS]
+                    if (
+                        COMPLETION_TOKENS in token_usage
+                        and COMPLETION_TOKENS in self.attr_names
+                    ):
+                        inference[COMPLETION_TOKENS] = token_usage[COMPLETION_TOKENS]
+
+                # add inference duration to the inference if the ArthurModel
+                # was registered to monitor inference duration
+                if DURATION in self.attr_names:
+                    inference[DURATION] = time_from_start_to_end
+
+                inferences.append(inference)
+
+        # send inferences to arthur
+        self.arthur_model.send_inferences(inferences)
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """On chain start, do nothing."""
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """On chain end, do nothing."""
+
+    def on_llm_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        """Do nothing when LLM outputs an error."""
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """On new token, pass."""
+
+    def on_chain_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        """Do nothing when LLM chain outputs an error."""
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool starts."""
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Do nothing when agent takes a specific action."""
+
+    def on_tool_end(
+        self,
+        output: str,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool ends."""
+
+    def on_tool_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        """Do nothing when tool outputs an error."""
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """Do nothing"""
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Do nothing"""

langchain/callbacks/flyte_callback.py

@@ -0,0 +1,366 @@
+"""FlyteKit callback handler."""
+from __future__ import annotations
+
+import logging
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Union
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.callbacks.utils import (
+    BaseMetadataCallbackHandler,
+    flatten_dict,
+    import_pandas,
+    import_spacy,
+    import_textstat,
+)
+from langchain.schema import AgentAction, AgentFinish, LLMResult
+
+if TYPE_CHECKING:
+    import flytekit
+    from flytekitplugins.deck import renderer
+
+logger = logging.getLogger(__name__)
+
+
+def import_flytekit() -> Tuple[flytekit, renderer]:
+    try:
+        import flytekit  # noqa: F401
+        from flytekitplugins.deck import renderer  # noqa: F401
+    except ImportError:
+        raise ImportError(
+            "To use the flyte callback manager you need"
+            "to have the `flytekit` and `flytekitplugins-deck-standard`"
+            "packages installed. Please install them with `pip install flytekit`"
+            "and `pip install flytekitplugins-deck-standard`."
+        )
+    return flytekit, renderer
+
+
+def analyze_text(
+    text: str,
+    nlp: Any = None,
+) -> dict:
+    """Analyze text using textstat and spacy.
+
+    Parameters:
+        text (str): The text to analyze.
+        nlp (spacy.lang): The spacy language model to use for visualization.
+
+    Returns:
+        (dict): A dictionary containing the complexity metrics and visualization
+            files serialized to HTML string.
+    """
+    resp: Dict[str, Any] = {}
+    textstat = import_textstat()
+    text_complexity_metrics = {
+        "flesch_reading_ease": textstat.flesch_reading_ease(text),
+        "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
+        "smog_index": textstat.smog_index(text),
+        "coleman_liau_index": textstat.coleman_liau_index(text),
+        "automated_readability_index": textstat.automated_readability_index(text),
+        "dale_chall_readability_score": textstat.dale_chall_readability_score(text),
+        "difficult_words": textstat.difficult_words(text),
+        "linsear_write_formula": textstat.linsear_write_formula(text),
+        "gunning_fog": textstat.gunning_fog(text),
+        "fernandez_huerta": textstat.fernandez_huerta(text),
+        "szigriszt_pazos": textstat.szigriszt_pazos(text),
+        "gutierrez_polini": textstat.gutierrez_polini(text),
+        "crawford": textstat.crawford(text),
+        "gulpease_index": textstat.gulpease_index(text),
+        "osman": textstat.osman(text),
+    }
+    resp.update({"text_complexity_metrics": text_complexity_metrics})
+    resp.update(text_complexity_metrics)
+
+    if nlp is not None:
+        spacy = import_spacy()
+        doc = nlp(text)
+        dep_out = spacy.displacy.render(  # type: ignore
+            doc, style="dep", jupyter=False, page=True
+        )
+
+        ent_out = spacy.displacy.render(  # type: ignore
+            doc, style="ent", jupyter=False, page=True
+        )
+
+        text_visualizations = {
+            "dependency_tree": dep_out,
+            "entities": ent_out,
+        }
+
+        resp.update(text_visualizations)
+
+    return resp
+
+
+class FlyteCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
+    """This callback handler is designed specifically for usage within a Flyte task."""
+
+    def __init__(self) -> None:
+        """Initialize callback handler."""
+        import_textstat()  # Raise error since it is required
+        flytekit, renderer = import_flytekit()
+        self.pandas = import_pandas()
+
+        spacy = None
+        try:
+            spacy = import_spacy()
+        except ImportError:
+            logger.warning(
+                "Spacy library is not installed. \
+                It may result in the inability to log \
+                certain metrics that can be captured with Spacy."
+            )
+
+        super().__init__()
+
+        self.nlp = None
+        if spacy:
+            try:
+                self.nlp = spacy.load("en_core_web_sm")
+            except OSError:
+                logger.warning(
+                    "FlyteCallbackHandler uses spacy's en_core_web_sm model"
+                    " for certain metrics. To download,"
+                    " run the following command in your terminal:"
+                    " `python -m spacy download en_core_web_sm` command."
+                )
+
+        self.table_renderer = renderer.TableRenderer
+        self.markdown_renderer = renderer.MarkdownRenderer
+
+        self.deck = flytekit.Deck(
+            "LangChain Metrics",
+            self.markdown_renderer().to_html("## LangChain Metrics"),
+        )
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+
+        self.step += 1
+        self.llm_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        prompt_responses = []
+        for prompt in prompts:
+            prompt_responses.append(prompt)
+
+        resp.update({"prompts": prompt_responses})
+
+        self.deck.append(self.markdown_renderer().to_html("### LLM Start"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.step += 1
+        self.llm_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_end"})
+        resp.update(flatten_dict(response.llm_output or {}))
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### LLM End"))
+        self.deck.append(self.table_renderer().to_html(self.pandas.DataFrame([resp])))
+
+        for generations in response.generations:
+            for generation in generations:
+                generation_resp = deepcopy(resp)
+                generation_resp.update(flatten_dict(generation.dict()))
+                if self.nlp:
+                    generation_resp.update(
+                        analyze_text(
+                            generation.text,
+                            nlp=self.nlp,
+                        )
+                    )
+
+                    complexity_metrics: Dict[str, float] = generation_resp.pop("text_complexity_metrics")  # type: ignore  # noqa: E501
+                    self.deck.append(
+                        self.markdown_renderer().to_html("#### Text Complexity Metrics")
+                    )
+                    self.deck.append(
+                        self.table_renderer().to_html(
+                            self.pandas.DataFrame([complexity_metrics])
+                        )
+                        + "\n"
+                    )
+
+                    dependency_tree = generation_resp["dependency_tree"]
+                    self.deck.append(
+                        self.markdown_renderer().to_html("#### Dependency Tree")
+                    )
+                    self.deck.append(dependency_tree)
+
+                    entities = generation_resp["entities"]
+                    self.deck.append(self.markdown_renderer().to_html("#### Entities"))
+                    self.deck.append(entities)
+                else:
+                    self.deck.append(
+                        self.markdown_renderer().to_html("#### Generated Response")
+                    )
+                    self.deck.append(self.markdown_renderer().to_html(generation.text))
+
+    def on_llm_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        """Run when LLM errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        self.step += 1
+        self.chain_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_chain_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        chain_input = ",".join([f"{k}={v}" for k, v in inputs.items()])
+        input_resp = deepcopy(resp)
+        input_resp["inputs"] = chain_input
+
+        self.deck.append(self.markdown_renderer().to_html("### Chain Start"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([input_resp])) + "\n"
+        )
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends running."""
+        self.step += 1
+        self.chain_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        chain_output = ",".join([f"{k}={v}" for k, v in outputs.items()])
+        resp.update({"action": "on_chain_end", "outputs": chain_output})
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Chain End"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_chain_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        """Run when chain errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_start", "input_str": input_str})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Tool Start"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_tool_end(self, output: str, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        self.step += 1
+        self.tool_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_end", "output": output})
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Tool End"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_tool_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        """Run when tool errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when agent is ending.
+        """
+        self.step += 1
+        self.text_ctr += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_text", "text": text})
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### On Text"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        self.step += 1
+        self.agent_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_finish",
+                "output": finish.return_values["output"],
+                "log": finish.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Agent Finish"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_action",
+                "tool": action.tool,
+                "tool_input": action.tool_input,
+                "log": action.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Agent Action"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )

langchain/callbacks/manager.py

@@ -379,8 +379,8 @@ class BaseRunManager(RunManagerMixin):
         handlers: List[BaseCallbackHandler],
         inheritable_handlers: List[BaseCallbackHandler],
         parent_run_id: Optional[UUID] = None,
-        tags: List[str],
-        inheritable_tags: List[str],
+        tags: Optional[List[str]] = None,
+        inheritable_tags: Optional[List[str]] = None,
     ) -> None:
         """Initialize the run manager.
 
@@ -391,15 +391,15 @@ class BaseRunManager(RunManagerMixin):
                 The list of inheritable handlers.
             parent_run_id (UUID, optional): The ID of the parent run.
                 Defaults to None.
-            tags (List[str]): The list of tags.
-            inheritable_tags (List[str]): The list of inheritable tags.
+            tags (Optional[List[str]]): The list of tags.
+            inheritable_tags (Optional[List[str]]): The list of inheritable tags.
         """
         self.run_id = run_id
         self.handlers = handlers
         self.inheritable_handlers = inheritable_handlers
-        self.tags = tags
-        self.inheritable_tags = inheritable_tags
         self.parent_run_id = parent_run_id
+        self.tags = tags or []
+        self.inheritable_tags = inheritable_tags or []
 
     @classmethod
     def get_noop_manager(cls: Type[BRM]) -> BRM:

langchain/callbacks/openai_info.py

@@ -96,7 +96,7 @@ def get_openai_token_cost_for_model(
             f"Unknown model: {model_name}. Please provide a valid OpenAI model name."
             "Known models are: " + ", ".join(MODEL_COST_PER_1K_TOKENS.keys())
         )
-    return MODEL_COST_PER_1K_TOKENS[model_name] * num_tokens / 1000
+    return MODEL_COST_PER_1K_TOKENS[model_name] * (num_tokens / 1000)
 
 
 class OpenAICallbackHandler(BaseCallbackHandler):

langchain/callbacks/promptlayer_callback.py

@@ -0,0 +1,160 @@
+"""Callback handler for promptlayer."""
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple
+from uuid import UUID
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.schema import (
+    AIMessage,
+    BaseMessage,
+    ChatGeneration,
+    ChatMessage,
+    HumanMessage,
+    LLMResult,
+    SystemMessage,
+)
+
+if TYPE_CHECKING:
+    import promptlayer
+
+
+def _lazy_import_promptlayer() -> promptlayer:
+    """Lazy import promptlayer to avoid circular imports."""
+    try:
+        import promptlayer
+    except ImportError:
+        raise ImportError(
+            "The PromptLayerCallbackHandler requires the promptlayer package. "
+            " Please install it with `pip install promptlayer`."
+        )
+    return promptlayer
+
+
+class PromptLayerCallbackHandler(BaseCallbackHandler):
+    """Callback handler for promptlayer."""
+
+    def __init__(
+        self,
+        pl_id_callback: Optional[Callable[..., Any]] = None,
+        pl_tags: Optional[List[str]] = [],
+    ) -> None:
+        """Initialize the PromptLayerCallbackHandler."""
+        _lazy_import_promptlayer()
+        self.pl_id_callback = pl_id_callback
+        self.pl_tags = pl_tags
+        self.runs: Dict[UUID, Dict[str, Any]] = {}
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        self.runs[run_id] = {
+            "messages": [self._create_message_dicts(m)[0] for m in messages],
+            "invocation_params": kwargs.get("invocation_params", {}),
+            "name": ".".join(serialized["id"]),
+            "request_start_time": datetime.datetime.now().timestamp(),
+            "tags": tags,
+        }
+
+    def on_llm_start(
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        self.runs[run_id] = {
+            "prompts": prompts,
+            "invocation_params": kwargs.get("invocation_params", {}),
+            "name": ".".join(serialized["id"]),
+            "request_start_time": datetime.datetime.now().timestamp(),
+            "tags": tags,
+        }
+
+    def on_llm_end(
+        self,
+        response: LLMResult,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        from promptlayer.utils import get_api_key, promptlayer_api_request
+
+        run_info = self.runs.get(run_id, {})
+        if not run_info:
+            return
+        run_info["request_end_time"] = datetime.datetime.now().timestamp()
+        for i in range(len(response.generations)):
+            generation = response.generations[i][0]
+
+            resp = {
+                "text": generation.text,
+                "llm_output": response.llm_output,
+            }
+            model_params = run_info.get("invocation_params", {})
+            is_chat_model = run_info.get("messages", None) is not None
+            model_input = (
+                run_info.get("messages", [])[i]
+                if is_chat_model
+                else [run_info.get("prompts", [])[i]]
+            )
+            model_response = (
+                [self._convert_message_to_dict(generation.message)]
+                if is_chat_model and isinstance(generation, ChatGeneration)
+                else resp
+            )
+
+            pl_request_id = promptlayer_api_request(
+                run_info.get("name"),
+                "langchain",
+                model_input,
+                model_params,
+                self.pl_tags,
+                model_response,
+                run_info.get("request_start_time"),
+                run_info.get("request_end_time"),
+                get_api_key(),
+                return_pl_id=bool(self.pl_id_callback is not None),
+                metadata={
+                    "_langchain_run_id": str(run_id),
+                    "_langchain_parent_run_id": str(parent_run_id),
+                    "_langchain_tags": str(run_info.get("tags", [])),
+                },
+            )
+
+            if self.pl_id_callback:
+                self.pl_id_callback(pl_request_id)
+
+    def _convert_message_to_dict(self, message: BaseMessage) -> Dict[str, Any]:
+        if isinstance(message, HumanMessage):
+            message_dict = {"role": "user", "content": message.content}
+        elif isinstance(message, AIMessage):
+            message_dict = {"role": "assistant", "content": message.content}
+        elif isinstance(message, SystemMessage):
+            message_dict = {"role": "system", "content": message.content}
+        elif isinstance(message, ChatMessage):
+            message_dict = {"role": message.role, "content": message.content}
+        else:
+            raise ValueError(f"Got unknown type {message}")
+        if "name" in message.additional_kwargs:
+            message_dict["name"] = message.additional_kwargs["name"]
+        return message_dict
+
+    def _create_message_dicts(
+        self, messages: List[BaseMessage]
+    ) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        params: Dict[str, Any] = {}
+        message_dicts = [self._convert_message_to_dict(m) for m in messages]
+        return message_dicts, params

langchain/callbacks/streaming_aiter_final_only.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from langchain.callbacks.streaming_aiter import AsyncIteratorCallbackHandler
+from langchain.schema import LLMResult
+
+DEFAULT_ANSWER_PREFIX_TOKENS = ["Final", "Answer", ":"]
+
+
+class AsyncFinalIteratorCallbackHandler(AsyncIteratorCallbackHandler):
+    """Callback handler that returns an async iterator.
+    Only the final output of the agent will be iterated.
+    """
+
+    def append_to_last_tokens(self, token: str) -> None:
+        self.last_tokens.append(token)
+        self.last_tokens_stripped.append(token.strip())
+        if len(self.last_tokens) > len(self.answer_prefix_tokens):
+            self.last_tokens.pop(0)
+            self.last_tokens_stripped.pop(0)
+
+    def check_if_answer_reached(self) -> bool:
+        if self.strip_tokens:
+            return self.last_tokens_stripped == self.answer_prefix_tokens_stripped
+        else:
+            return self.last_tokens == self.answer_prefix_tokens
+
+    def __init__(
+        self,
+        *,
+        answer_prefix_tokens: Optional[List[str]] = None,
+        strip_tokens: bool = True,
+        stream_prefix: bool = False,
+    ) -> None:
+        """Instantiate AsyncFinalIteratorCallbackHandler.
+
+        Args:
+            answer_prefix_tokens: Token sequence that prefixes the answer.
+                Default is ["Final", "Answer", ":"]
+            strip_tokens: Ignore white spaces and new lines when comparing
+                answer_prefix_tokens to last tokens? (to determine if answer has been
+                reached)
+            stream_prefix: Should answer prefix itself also be streamed?
+        """
+        super().__init__()
+        if answer_prefix_tokens is None:
+            self.answer_prefix_tokens = DEFAULT_ANSWER_PREFIX_TOKENS
+        else:
+            self.answer_prefix_tokens = answer_prefix_tokens
+        if strip_tokens:
+            self.answer_prefix_tokens_stripped = [
+                token.strip() for token in self.answer_prefix_tokens
+            ]
+        else:
+            self.answer_prefix_tokens_stripped = self.answer_prefix_tokens
+        self.last_tokens = [""] * len(self.answer_prefix_tokens)
+        self.last_tokens_stripped = [""] * len(self.answer_prefix_tokens)
+        self.strip_tokens = strip_tokens
+        self.stream_prefix = stream_prefix
+        self.answer_reached = False
+
+    async def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        # If two calls are made in a row, this resets the state
+        self.done.clear()
+        self.answer_reached = False
+
+    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        if self.answer_reached:
+            self.done.set()
+
+    async def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        # Remember the last n tokens, where n = len(answer_prefix_tokens)
+        self.append_to_last_tokens(token)
+
+        # Check if the last n tokens match the answer_prefix_tokens list ...
+        if self.check_if_answer_reached():
+            self.answer_reached = True
+            if self.stream_prefix:
+                for t in self.last_tokens:
+                    self.queue.put_nowait(t)
+            return
+
+        # If yes, then put tokens from now on
+        if self.answer_reached:
+            self.queue.put_nowait(token)

langchain/chains/graph_qa/prompts.py

@@ -53,15 +53,16 @@ NEBULAGRAPH_EXTRA_INSTRUCTIONS = """
 Instructions:
 
 First, generate cypher then convert it to NebulaGraph Cypher dialect(rather than standard):
-1. it requires explicit label specification when referring to node properties: v.`Foo`.name
-2. it uses double equals sign for comparison: `==` rather than `=`
+1. it requires explicit label specification only when referring to node properties: v.`Foo`.name
+2. note explicit label specification is not needed for edge properties, so it's e.name instead of e.`Bar`.name
+3. it uses double equals sign for comparison: `==` rather than `=`
 For instance:
 ```diff
-< MATCH (p:person)-[:directed]->(m:movie) WHERE m.name = 'The Godfather II'
-< RETURN p.name;
+< MATCH (p:person)-[e:directed]->(m:movie) WHERE m.name = 'The Godfather II'
+< RETURN p.name, e.year, m.name;
 ---
-> MATCH (p:`person`)-[:directed]->(m:`movie`) WHERE m.`movie`.`name` == 'The Godfather II'
-> RETURN p.`person`.`name`;
+> MATCH (p:`person`)-[e:directed]->(m:`movie`) WHERE m.`movie`.`name` == 'The Godfather II'
+> RETURN p.`person`.`name`, e.year, m.`movie`.`name`;
 ```\n"""
 
 NGQL_GENERATION_TEMPLATE = CYPHER_GENERATION_TEMPLATE.replace(

langchain/chains/openai_functions/extraction.py

@@ -78,9 +78,9 @@ def create_extraction_chain_pydantic(
     class PydanticSchema(BaseModel):
         info: List[pydantic_schema]  # type: ignore
 
-    openai_schema = PydanticSchema.schema()
+    openai_schema = pydantic_schema.schema()
     openai_schema = _resolve_schema_references(
-        openai_schema, openai_schema["definitions"]
+        openai_schema, openai_schema.get("definitions", {})
     )
 
     function = _get_extraction_function(openai_schema)

langchain/client/runner_utils.py

@@ -42,7 +42,6 @@ from langchain.schema import (
 logger = logging.getLogger(__name__)
 
 MODEL_OR_CHAIN_FACTORY = Union[Callable[[], Chain], BaseLanguageModel]
-MODEL_OR_CHAIN_FACTORY_EXTENDED = Union[Callable[[], Chain], BaseLanguageModel, Chain]
 
 
 class InputFormatError(Exception):
@@ -140,6 +139,7 @@ async def _arun_llm(
     *,
     tags: Optional[List[str]] = None,
     callbacks: Callbacks = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Union[LLMResult, ChatResult]:
     """
     Asynchronously run the language model.
@@ -149,6 +149,7 @@ async def _arun_llm(
         inputs: The input dictionary.
         tags: Optional tags to add to the run.
         callbacks: Optional callbacks to use during the run.
+        input_mapper: Optional function to map inputs to the expected format.
 
     Returns:
         The LLMResult or ChatResult.
@@ -156,7 +157,13 @@ async def _arun_llm(
         ValueError: If the LLM type is unsupported.
         InputFormatError: If the input format is invalid.
     """
-    if isinstance(llm, BaseLLM):
+    if input_mapper is not None:
+        if not isinstance(llm, (BaseLLM, BaseChatModel)):
+            raise ValueError(f"Unsupported LLM type {type(llm).__name__}")
+        llm_output = await llm.agenerate(
+            input_mapper(inputs), callbacks=callbacks, tags=tags
+        )
+    elif isinstance(llm, BaseLLM):
         try:
             llm_prompts = _get_prompts(inputs)
             llm_output = await llm.agenerate(
@@ -192,6 +199,7 @@ async def _arun_llm_or_chain(
     *,
     tags: Optional[List[str]] = None,
     callbacks: Optional[List[BaseCallbackHandler]] = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
     """
     Asynchronously run the Chain or language model.
@@ -202,6 +210,7 @@ async def _arun_llm_or_chain(
         n_repetitions: The number of times to run the model on each example.
         tags: Optional tags to add to the run.
         callbacks: Optional callbacks to use during the run.
+        input_mapper: Optional function to map the input to the expected format.
 
     Returns:
         A list of outputs.
@@ -224,12 +233,17 @@ async def _arun_llm_or_chain(
                     example.inputs,
                     tags=tags,
                     callbacks=callbacks,
+                    input_mapper=input_mapper,
                 )
             else:
                 chain = llm_or_chain_factory()
-                output = await chain.acall(
-                    example.inputs, callbacks=callbacks, tags=tags
-                )
+                if input_mapper is not None:
+                    inputs_ = input_mapper(example.inputs)
+                else:
+                    inputs_ = example.inputs
+                    if len(inputs_) == 1:
+                        inputs_ = next(iter(inputs_.values()))
+                output = await chain.acall(inputs_, callbacks=callbacks, tags=tags)
             outputs.append(output)
         except Exception as e:
             logger.warning(f"Chain failed for example {example.id}. Error: {e}")
@@ -324,7 +338,7 @@ async def _callbacks_initializer(
 
 async def arun_on_examples(
     examples: Iterator[Example],
-    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY_EXTENDED,
+    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     *,
     concurrency_level: int = 5,
     num_repetitions: int = 1,
@@ -333,6 +347,7 @@ async def arun_on_examples(
     client: Optional[LangChainPlusClient] = None,
     tags: Optional[List[str]] = None,
     run_evaluators: Optional[Sequence[RunEvaluator]] = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Dict[str, Any]:
     """
     Asynchronously run the chain on examples and store traces
@@ -340,12 +355,9 @@ async def arun_on_examples(
 
     Args:
         examples: Examples to run the model or chain over.
-        llm_or_chain_factory: Language model, Chain, or Chain constructor
-            You can pass chains without memory directly. For chains and
-            agents with memory, it is recommended to pass in a factory
-            function to construct a new instance of the chain for each example.
-            This permits independent evaluations on each example without
-            carrying over state.
+        llm_or_chain_factory: Language model or Chain constructor to run
+            over the dataset. The Chain constructor is used to permit
+            independent calls on each example without carrying over state.
         concurrency_level: The number of async tasks to run concurrently.
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
@@ -357,12 +369,16 @@ async def arun_on_examples(
             client will be created using the credentials in the environment.
         tags: Tags to add to each run in the project.
         run_evaluators: Evaluators to run on the results of the chain.
+        input_mapper: function to map to the inputs dictionary from an Example
+            to the format expected by the model to be evaluated. This is useful if
+            your model needs to deserialize more complex schema or if your dataset
+            has inputs with keys that differ from what is expected by your chain
+            or agent.
 
     Returns:
         A dictionary mapping example ids to the model outputs.
     """
-    llm_or_chain_factory_ = _wrap_chain(llm_or_chain_factory)
-    project_name = _get_project_name(project_name, llm_or_chain_factory_, None)
+    project_name = _get_project_name(project_name, llm_or_chain_factory, None)
     client_ = client or LangChainPlusClient()
     client_.create_project(project_name, mode="eval")
 
@@ -377,10 +393,11 @@ async def arun_on_examples(
         """Process a single example."""
         result = await _arun_llm_or_chain(
             example,
-            llm_or_chain_factory_,
+            llm_or_chain_factory,
             num_repetitions,
             tags=tags,
             callbacks=callbacks,
+            input_mapper=input_mapper,
         )
         results[str(example.id)] = result
         job_state["num_processed"] += 1
@@ -411,6 +428,7 @@ def run_llm(
     callbacks: Callbacks,
     *,
     tags: Optional[List[str]] = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Union[LLMResult, ChatResult]:
     """
     Run the language model on the example.
@@ -420,14 +438,18 @@ def run_llm(
         inputs: The input dictionary.
         callbacks: The callbacks to use during the run.
         tags: Optional tags to add to the run.
-
+        input_mapper: function to map to the inputs dictionary from an Example
     Returns:
         The LLMResult or ChatResult.
     Raises:
         ValueError: If the LLM type is unsupported.
         InputFormatError: If the input format is invalid.
     """
-    if isinstance(llm, BaseLLM):
+    if input_mapper is not None:
+        if not isinstance(llm, (BaseLLM, BaseChatModel)):
+            raise ValueError(f"Unsupported LLM type {type(llm).__name__}")
+        llm_output = llm.generate(input_mapper(inputs), callbacks=callbacks, tags=tags)
+    elif isinstance(llm, BaseLLM):
         try:
             llm_prompts = _get_prompts(inputs)
             llm_output = llm.generate(llm_prompts, callbacks=callbacks, tags=tags)
@@ -459,6 +481,7 @@ def run_llm_or_chain(
     *,
     tags: Optional[List[str]] = None,
     callbacks: Optional[List[BaseCallbackHandler]] = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
     """
     Run the Chain or language model synchronously.
@@ -487,11 +510,21 @@ def run_llm_or_chain(
         try:
             if isinstance(llm_or_chain_factory, BaseLanguageModel):
                 output: Any = run_llm(
-                    llm_or_chain_factory, example.inputs, callbacks, tags=tags
+                    llm_or_chain_factory,
+                    example.inputs,
+                    callbacks,
+                    tags=tags,
+                    input_mapper=input_mapper,
                 )
             else:
                 chain = llm_or_chain_factory()
-                output = chain(example.inputs, callbacks=callbacks, tags=tags)
+                if input_mapper is not None:
+                    inputs_ = input_mapper(example.inputs)
+                else:
+                    inputs_ = example.inputs
+                    if len(inputs_) == 1:
+                        inputs_ = next(iter(inputs_.values()))
+                output = chain(inputs_, callbacks=callbacks, tags=tags)
             outputs.append(output)
         except Exception as e:
             logger.warning(f"Chain failed for example {example.id}. Error: {e}")
@@ -503,27 +536,9 @@ def run_llm_or_chain(
     return outputs
 
 
-def _wrap_chain(
-    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY_EXTENDED,
-) -> MODEL_OR_CHAIN_FACTORY:
-    if isinstance(llm_or_chain_factory, Chain):
-        if llm_or_chain_factory.memory is not None:
-            raise ValueError(
-                f"Attempting to run a chain that uses memory: {llm_or_chain_factory}. "
-                "This will lead to issues reproducing results. To fix, pass in"
-                " a chain _factory_ to construct it instead:\n"
-                "def create_chain():\n"
-                "    return MyChain(..., memory=MyMemory())\n"
-                "run_on_dataset(..., llm_or_chain_factory=create_chain)\n"
-            )
-        chain = llm_or_chain_factory
-        return lambda: chain
-    return llm_or_chain_factory
-
-
 def run_on_examples(
     examples: Iterator[Example],
-    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY_EXTENDED,
+    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     *,
     num_repetitions: int = 1,
     project_name: Optional[str] = None,
@@ -531,6 +546,7 @@ def run_on_examples(
     client: Optional[LangChainPlusClient] = None,
     tags: Optional[List[str]] = None,
     run_evaluators: Optional[Sequence[RunEvaluator]] = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Dict[str, Any]:
     """
     Run the Chain or language model on examples and store
@@ -538,12 +554,9 @@ def run_on_examples(
 
     Args:
         examples: Examples to run the model or chain over.
-        llm_or_chain_factory: Language model, Chain, or Chain constructor
-            You can pass chains without memory directly. For chains and
-            agents with memory, it is recommended to pass in a factory
-            function to construct a new instance of the chain for each example.
-            This permits independent evaluations on each example without
-            carrying over state.
+        llm_or_chain_factory: Language model or Chain constructor to run
+            over the dataset. The Chain constructor is used to permit
+            independent calls on each example without carrying over state.
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
             intervals.
@@ -554,13 +567,17 @@ def run_on_examples(
             will be created using the credentials in the environment.
         tags: Tags to add to each run in the project.
         run_evaluators: Evaluators to run on the results of the chain.
+        input_mapper: A function to map to the inputs dictionary from an Example
+            to the format expected by the model to be evaluated. This is useful if
+            your model needs to deserialize more complex schema or if your dataset
+            has inputs with keys that differ from what is expected by your chain
+            or agent.
 
     Returns:
         A dictionary mapping example ids to the model outputs.
     """
     results: Dict[str, Any] = {}
-    llm_or_chain_factory_ = _wrap_chain(llm_or_chain_factory)
-    project_name = _get_project_name(project_name, llm_or_chain_factory_, None)
+    project_name = _get_project_name(project_name, llm_or_chain_factory, None)
     client_ = client or LangChainPlusClient()
     client_.create_project(project_name, mode="eval")
     tracer = LangChainTracer(project_name=project_name)
@@ -571,10 +588,11 @@ def run_on_examples(
     for i, example in enumerate(examples):
         result = run_llm_or_chain(
             example,
-            llm_or_chain_factory_,
+            llm_or_chain_factory,
             num_repetitions,
             tags=tags,
             callbacks=callbacks,
+            input_mapper=input_mapper,
         )
         if verbose:
             print(f"{i+1} processed", flush=True, end="\r")
@@ -613,7 +631,7 @@ def _get_project_name(
 
 async def arun_on_dataset(
     dataset_name: str,
-    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY_EXTENDED,
+    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     *,
     concurrency_level: int = 5,
     num_repetitions: int = 1,
@@ -622,6 +640,7 @@ async def arun_on_dataset(
     client: Optional[LangChainPlusClient] = None,
     tags: Optional[List[str]] = None,
     run_evaluators: Optional[Sequence[RunEvaluator]] = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Dict[str, Any]:
     """
     Asynchronously run the Chain or language model on a dataset
@@ -629,12 +648,9 @@ async def arun_on_dataset(
 
     Args:
         dataset_name: Name of the dataset to run the chain on.
-        llm_or_chain_factory: Language model, Chain, or Chain constructor
-            You can pass chains without memory directly. For chains and
-            agents with memory, it is recommended to pass in a factory
-            function to construct a new instance of the chain for each example.
-            This permits independent evaluations on each example without
-            carrying over state.
+        llm_or_chain_factory: Language model or Chain constructor to run
+            over the dataset. The Chain constructor is used to permit
+            independent calls on each example without carrying over state.
         concurrency_level: The number of async tasks to run concurrently.
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
@@ -646,18 +662,21 @@ async def arun_on_dataset(
             client will be created using the credentials in the environment.
         tags: Tags to add to each run in the project.
         run_evaluators: Evaluators to run on the results of the chain.
-
+        input_mapper: A function to map to the inputs dictionary from an Example
+            to the format expected by the model to be evaluated. This is useful if
+            your model needs to deserialize more complex schema or if your dataset
+            has inputs with keys that differ from what is expected by your chain
+            or agent.
     Returns:
         A dictionary containing the run's project name and the resulting model outputs.
     """
     client_ = client or LangChainPlusClient()
-    llm_or_chain_factory_ = _wrap_chain(llm_or_chain_factory)
-    project_name = _get_project_name(project_name, llm_or_chain_factory_, dataset_name)
+    project_name = _get_project_name(project_name, llm_or_chain_factory, dataset_name)
     dataset = client_.read_dataset(dataset_name=dataset_name)
     examples = client_.list_examples(dataset_id=str(dataset.id))
     results = await arun_on_examples(
         examples,
-        llm_or_chain_factory_,
+        llm_or_chain_factory,
         concurrency_level=concurrency_level,
         num_repetitions=num_repetitions,
         project_name=project_name,
@@ -665,6 +684,7 @@ async def arun_on_dataset(
         client=client_,
         tags=tags,
         run_evaluators=run_evaluators,
+        input_mapper=input_mapper,
     )
     return {
         "project_name": project_name,
@@ -674,7 +694,7 @@ async def arun_on_dataset(
 
 def run_on_dataset(
     dataset_name: str,
-    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY_EXTENDED,
+    llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     *,
     num_repetitions: int = 1,
     project_name: Optional[str] = None,
@@ -682,6 +702,7 @@ def run_on_dataset(
     client: Optional[LangChainPlusClient] = None,
     tags: Optional[List[str]] = None,
     run_evaluators: Optional[Sequence[RunEvaluator]] = None,
+    input_mapper: Optional[Callable[[Dict], Any]] = None,
 ) -> Dict[str, Any]:
     """
     Run the Chain or language model on a dataset and store traces
@@ -689,12 +710,9 @@ def run_on_dataset(
 
     Args:
         dataset_name: Name of the dataset to run the chain on.
-        llm_or_chain_factory: Language model, Chain, or Chain constructor
-            You can pass chains without memory directly. For chains and
-            agents with memory, it is recommended to pass in a factory
-            function to construct a new instance of the chain for each example.
-            This permits independent evaluations on each example without
-            carrying over state.
+        llm_or_chain_factory: Language model or Chain constructor to run
+            over the dataset. The Chain constructor is used to permit
+            independent calls on each example without carrying over state.
         concurrency_level: Number of async workers to run in parallel.
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
@@ -706,24 +724,29 @@ def run_on_dataset(
             will be created using the credentials in the environment.
         tags: Tags to add to each run in the project.
         run_evaluators: Evaluators to run on the results of the chain.
+        input_mapper: A function to map to the inputs dictionary from an Example
+            to the format expected by the model to be evaluated. This is useful if
+            your model needs to deserialize more complex schema or if your dataset
+            has inputs with keys that differ from what is expected by your chain
+            or agent.
 
     Returns:
         A dictionary containing the run's project name and the resulting model outputs.
     """
     client_ = client or LangChainPlusClient()
-    llm_or_chain_factory_ = _wrap_chain(llm_or_chain_factory)
-    project_name = _get_project_name(project_name, llm_or_chain_factory_, dataset_name)
+    project_name = _get_project_name(project_name, llm_or_chain_factory, dataset_name)
     dataset = client_.read_dataset(dataset_name=dataset_name)
     examples = client_.list_examples(dataset_id=str(dataset.id))
     results = run_on_examples(
         examples,
-        llm_or_chain_factory_,
+        llm_or_chain_factory,
         num_repetitions=num_repetitions,
         project_name=project_name,
         verbose=verbose,
         tags=tags,
         run_evaluators=run_evaluators,
         client=client_,
+        input_mapper=input_mapper,
     )
     return {
         "project_name": project_name,

langchain/document_loaders/__init__.py

@@ -63,6 +63,7 @@ from langchain.document_loaders.imsdb import IMSDbLoader
 from langchain.document_loaders.iugu import IuguLoader
 from langchain.document_loaders.joplin import JoplinLoader
 from langchain.document_loaders.json_loader import JSONLoader
+from langchain.document_loaders.larksuite import LarkSuiteDocLoader
 from langchain.document_loaders.markdown import UnstructuredMarkdownLoader
 from langchain.document_loaders.mastodon import MastodonTootsLoader
 from langchain.document_loaders.max_compute import MaxComputeLoader
@@ -78,6 +79,7 @@ from langchain.document_loaders.odt import UnstructuredODTLoader
 from langchain.document_loaders.onedrive import OneDriveLoader
 from langchain.document_loaders.onedrive_file import OneDriveFileLoader
 from langchain.document_loaders.open_city_data import OpenCityDataLoader
+from langchain.document_loaders.org_mode import UnstructuredOrgModeLoader
 from langchain.document_loaders.pdf import (
     MathpixPDFLoader,
     OnlinePDFLoader,
@@ -112,6 +114,8 @@ from langchain.document_loaders.telegram import (
     TelegramChatApiLoader,
     TelegramChatFileLoader,
 )
+from langchain.document_loaders.tencent_cos_directory import TencentCOSDirectoryLoader
+from langchain.document_loaders.tencent_cos_file import TencentCOSFileLoader
 from langchain.document_loaders.text import TextLoader
 from langchain.document_loaders.tomarkdown import ToMarkdownLoader
 from langchain.document_loaders.toml import TomlLoader
@@ -201,6 +205,7 @@ __all__ = [
     "IuguLoader",
     "JSONLoader",
     "JoplinLoader",
+    "LarkSuiteDocLoader",
     "MWDumpLoader",
     "MastodonTootsLoader",
     "MathpixPDFLoader",
@@ -242,6 +247,8 @@ __all__ = [
     "SnowflakeLoader",
     "SpreedlyLoader",
     "StripeLoader",
+    "TencentCOSDirectoryLoader",
+    "TencentCOSFileLoader",
     "TelegramChatApiLoader",
     "TelegramChatFileLoader",
     "TelegramChatLoader",
@@ -262,6 +269,7 @@ __all__ = [
     "UnstructuredImageLoader",
     "UnstructuredMarkdownLoader",
     "UnstructuredODTLoader",
+    "UnstructuredOrgModeLoader",
     "UnstructuredPDFLoader",
     "UnstructuredPowerPointLoader",
     "UnstructuredRSTLoader",

langchain/document_loaders/apify_dataset.py

@@ -50,5 +50,7 @@ class ApifyDatasetLoader(BaseLoader, BaseModel):
 
     def load(self) -> List[Document]:
         """Load documents."""
-        dataset_items = self.apify_client.dataset(self.dataset_id).list_items().items
+        dataset_items = (
+            self.apify_client.dataset(self.dataset_id).list_items(clean=True).items
+        )
         return list(map(self.dataset_mapping_function, dataset_items))

langchain/document_loaders/larksuite.py

@@ -0,0 +1,46 @@
+"""Loader that loads LarkSuite (FeiShu) document json dump."""
+import json
+import urllib.request
+from typing import Any, Iterator, List
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseLoader
+
+
+class LarkSuiteDocLoader(BaseLoader):
+    """Loader that loads LarkSuite (FeiShu) document."""
+
+    def __init__(self, domain: str, access_token: str, document_id: str):
+        """Initialize with domain, access_token (tenant / user), and document_id."""
+        self.domain = domain
+        self.access_token = access_token
+        self.document_id = document_id
+
+    def _get_larksuite_api_json_data(self, api_url: str) -> Any:
+        """Get LarkSuite (FeiShu) API response json data."""
+        headers = {"Authorization": f"Bearer {self.access_token}"}
+        request = urllib.request.Request(api_url, headers=headers)
+        with urllib.request.urlopen(request) as response:
+            json_data = json.loads(response.read().decode())
+            return json_data
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load LarkSuite (FeiShu) document."""
+        api_url_prefix = f"{self.domain}/open-apis/docx/v1/documents"
+        metadata_json = self._get_larksuite_api_json_data(
+            f"{api_url_prefix}/{self.document_id}"
+        )
+        raw_content_json = self._get_larksuite_api_json_data(
+            f"{api_url_prefix}/{self.document_id}/raw_content"
+        )
+        text = raw_content_json["data"]["content"]
+        metadata = {
+            "document_id": self.document_id,
+            "revision_id": metadata_json["data"]["document"]["revision_id"],
+            "title": metadata_json["data"]["document"]["title"],
+        }
+        yield Document(page_content=text, metadata=metadata)
+
+    def load(self) -> List[Document]:
+        """Load LarkSuite (FeiShu) document."""
+        return list(self.lazy_load())

langchain/document_loaders/org_mode.py

@@ -0,0 +1,22 @@
+"""Loader that loads Org-Mode files."""
+from typing import Any, List
+
+from langchain.document_loaders.unstructured import (
+    UnstructuredFileLoader,
+    validate_unstructured_version,
+)
+
+
+class UnstructuredOrgModeLoader(UnstructuredFileLoader):
+    """Loader that uses unstructured to load Org-Mode files."""
+
+    def __init__(
+        self, file_path: str, mode: str = "single", **unstructured_kwargs: Any
+    ):
+        validate_unstructured_version(min_unstructured_version="0.7.9")
+        super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List:
+        from unstructured.partition.org import partition_org
+
+        return partition_org(filename=self.file_path, **self.unstructured_kwargs)

langchain/document_loaders/parsers/__init__.py

@@ -1,5 +1,7 @@
 from langchain.document_loaders.parsers.audio import OpenAIWhisperParser
+from langchain.document_loaders.parsers.grobid import GrobidParser
 from langchain.document_loaders.parsers.html import BS4HTMLParser
+from langchain.document_loaders.parsers.language import LanguageParser
 from langchain.document_loaders.parsers.pdf import (
     PDFMinerParser,
     PDFPlumberParser,
@@ -10,6 +12,8 @@ from langchain.document_loaders.parsers.pdf import (
 
 __all__ = [
     "BS4HTMLParser",
+    "GrobidParser",
+    "LanguageParser",
     "OpenAIWhisperParser",
     "PDFMinerParser",
     "PDFPlumberParser",

langchain/document_loaders/parsers/grobid.py

@@ -0,0 +1,142 @@
+from typing import Dict, Iterator, List, Union
+
+import requests
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseBlobParser
+from langchain.document_loaders.blob_loaders import Blob
+
+
+class ServerUnavailableException(Exception):
+    pass
+
+
+class GrobidParser(BaseBlobParser):
+    """Loader that uses Grobid to load article PDF files."""
+
+    def __init__(
+        self,
+        segment_sentences: bool,
+        grobid_server: str = "http://localhost:8070/api/processFulltextDocument",
+    ) -> None:
+        self.segment_sentences = segment_sentences
+        self.grobid_server = grobid_server
+        try:
+            requests.get(grobid_server)
+        except requests.exceptions.RequestException:
+            print(
+                "GROBID server does not appear up and running, \
+                please ensure Grobid is installed and the server is running"
+            )
+            raise ServerUnavailableException
+
+    def process_xml(
+        self, file_path: str, xml_data: str, segment_sentences: bool
+    ) -> Iterator[Document]:
+        """Process the XML file from Grobin."""
+
+        try:
+            from bs4 import BeautifulSoup
+        except ImportError:
+            raise ImportError(
+                "`bs4` package not found, please install it with " "`pip install bs4`"
+            )
+        soup = BeautifulSoup(xml_data, "xml")
+        sections = soup.find_all("div")
+        title = soup.find_all("title")[0].text
+        chunks = []
+        for section in sections:
+            sect = section.find("head")
+            if sect is not None:
+                for i, paragraph in enumerate(section.find_all("p")):
+                    chunk_bboxes = []
+                    paragraph_text = []
+                    for i, sentence in enumerate(paragraph.find_all("s")):
+                        paragraph_text.append(sentence.text)
+                        sbboxes = []
+                        for bbox in sentence.get("coords").split(";"):
+                            box = bbox.split(",")
+                            sbboxes.append(
+                                {
+                                    "page": box[0],
+                                    "x": box[1],
+                                    "y": box[2],
+                                    "h": box[3],
+                                    "w": box[4],
+                                }
+                            )
+                        chunk_bboxes.append(sbboxes)
+                        if segment_sentences is True:
+                            fpage, lpage = sbboxes[0]["page"], sbboxes[-1]["page"]
+                            sentence_dict = {
+                                "text": sentence.text,
+                                "para": str(i),
+                                "bboxes": [sbboxes],
+                                "section_title": sect.text,
+                                "section_number": sect.get("n"),
+                                "pages": (fpage, lpage),
+                            }
+                            chunks.append(sentence_dict)
+                    if segment_sentences is not True:
+                        fpage, lpage = (
+                            chunk_bboxes[0][0]["page"],
+                            chunk_bboxes[-1][-1]["page"],
+                        )
+                        paragraph_dict = {
+                            "text": "".join(paragraph_text),
+                            "para": str(i),
+                            "bboxes": chunk_bboxes,
+                            "section_title": sect.text,
+                            "section_number": sect.get("n"),
+                            "pages": (fpage, lpage),
+                        }
+                        chunks.append(paragraph_dict)
+
+        yield from [
+            Document(
+                page_content=chunk["text"],
+                metadata=dict(
+                    {
+                        "text": str(chunk["text"]),
+                        "para": str(chunk["para"]),
+                        "bboxes": str(chunk["bboxes"]),
+                        "pages": str(chunk["pages"]),
+                        "section_title": str(chunk["section_title"]),
+                        "section_number": str(chunk["section_number"]),
+                        "paper_title": str(title),
+                        "file_path": str(file_path),
+                    }
+                ),
+            )
+            for chunk in chunks
+        ]
+
+    def lazy_parse(self, blob: Blob) -> Iterator[Document]:
+        file_path = blob.source
+        if file_path is None:
+            raise ValueError("blob.source cannot be None.")
+        pdf = open(file_path, "rb")
+        files = {"input": (file_path, pdf, "application/pdf", {"Expires": "0"})}
+        try:
+            data: Dict[str, Union[str, List[str]]] = {}
+            for param in ["generateIDs", "consolidateHeader", "segmentSentences"]:
+                data[param] = "1"
+            data["teiCoordinates"] = ["head", "s"]
+            files = files or {}
+            r = requests.request(
+                "POST",
+                self.grobid_server,
+                headers=None,
+                params=None,
+                files=files,
+                data=data,
+                timeout=60,
+            )
+            xml_data = r.text
+        except requests.exceptions.ReadTimeout:
+            xml_data = None
+
+        if xml_data is None:
+            return iter([])
+        else:
+            return self.process_xml(file_path, xml_data, self.segment_sentences)

langchain/document_loaders/parsers/language/__init__.py

@@ -0,0 +1,3 @@
+from langchain.document_loaders.parsers.language.language_parser import LanguageParser
+
+__all__ = ["LanguageParser"]

langchain/document_loaders/parsers/language/code_segmenter.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class CodeSegmenter(ABC):
+    def __init__(self, code: str):
+        self.code = code
+
+    def is_valid(self) -> bool:
+        return True
+
+    @abstractmethod
+    def simplify_code(self) -> str:
+        raise NotImplementedError  # pragma: no cover
+
+    @abstractmethod
+    def extract_functions_classes(self) -> List[str]:
+        raise NotImplementedError  # pragma: no cover

langchain/document_loaders/parsers/language/javascript.py

@@ -0,0 +1,65 @@
+from typing import Any, List
+
+from langchain.document_loaders.parsers.language.code_segmenter import CodeSegmenter
+
+
+class JavaScriptSegmenter(CodeSegmenter):
+    def __init__(self, code: str):
+        super().__init__(code)
+        self.source_lines = self.code.splitlines()
+
+        try:
+            import esprima  # noqa: F401
+        except ImportError:
+            raise ImportError(
+                "Could not import esprima Python package. "
+                "Please install it with `pip install esprima`."
+            )
+
+    def is_valid(self) -> bool:
+        import esprima
+
+        try:
+            esprima.parseScript(self.code)
+            return True
+        except esprima.Error:
+            return False
+
+    def _extract_code(self, node: Any) -> str:
+        start = node.loc.start.line - 1
+        end = node.loc.end.line
+        return "\n".join(self.source_lines[start:end])
+
+    def extract_functions_classes(self) -> List[str]:
+        import esprima
+
+        tree = esprima.parseScript(self.code, loc=True)
+        functions_classes = []
+
+        for node in tree.body:
+            if isinstance(
+                node,
+                (esprima.nodes.FunctionDeclaration, esprima.nodes.ClassDeclaration),
+            ):
+                functions_classes.append(self._extract_code(node))
+
+        return functions_classes
+
+    def simplify_code(self) -> str:
+        import esprima
+
+        tree = esprima.parseScript(self.code, loc=True)
+        simplified_lines = self.source_lines[:]
+
+        for node in tree.body:
+            if isinstance(
+                node,
+                (esprima.nodes.FunctionDeclaration, esprima.nodes.ClassDeclaration),
+            ):
+                start = node.loc.start.line - 1
+                simplified_lines[start] = f"// Code for: {simplified_lines[start]}"
+
+                for line_num in range(start + 1, node.loc.end.line):
+                    simplified_lines[line_num] = None  # type: ignore
+
+        return "\n".join(line for line in simplified_lines if line is not None)

langchain/document_loaders/parsers/language/language_parser.py

@@ -0,0 +1,143 @@
+from typing import Any, Dict, Iterator, Optional
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseBlobParser
+from langchain.document_loaders.blob_loaders import Blob
+from langchain.document_loaders.parsers.language.javascript import JavaScriptSegmenter
+from langchain.document_loaders.parsers.language.python import PythonSegmenter
+from langchain.text_splitter import Language
+
+LANGUAGE_EXTENSIONS: Dict[str, str] = {
+    "py": Language.PYTHON,
+    "js": Language.JS,
+}
+
+LANGUAGE_SEGMENTERS: Dict[str, Any] = {
+    Language.PYTHON: PythonSegmenter,
+    Language.JS: JavaScriptSegmenter,
+}
+
+
+class LanguageParser(BaseBlobParser):
+    """
+    Language parser that split code using the respective language syntax.
+
+    Each top-level function and class in the code is loaded into separate documents.
+    Furthermore, an extra document is generated, containing the remaining top-level code
+    that excludes the already segmented functions and classes.
+
+    This approach can potentially improve the accuracy of QA models over source code.
+
+    Currently, the supported languages for code parsing are Python and JavaScript.
+
+    The language used for parsing can be configured, along with the minimum number of
+    lines required to activate the splitting based on syntax.
+
+    Examples:
+
+        .. code-block:: python
+
+            from langchain.text_splitter.Language
+            from langchain.document_loaders.generic import GenericLoader
+            from langchain.document_loaders.parsers import LanguageParser
+
+            loader = GenericLoader.from_filesystem(
+                "./code",
+                glob="**/*",
+                suffixes=[".py", ".js"],
+                parser=LanguageParser()
+            )
+            docs = loader.load()
+
+        Example instantiations to manually select the language:
+
+        ... code-block:: python
+
+            from langchain.text_splitter import Language
+
+            loader = GenericLoader.from_filesystem(
+                "./code",
+                glob="**/*",
+                suffixes=[".py"],
+                parser=LanguageParser(language=Language.PYTHON)
+            )
+
+        Example instantiations to set number of lines threshold:
+
+        ... code-block:: python
+
+            loader = GenericLoader.from_filesystem(
+                "./code",
+                glob="**/*",
+                suffixes=[".py"],
+                parser=LanguageParser(parser_threshold=200)
+            )
+    """
+
+    def __init__(self, language: Optional[Language] = None, parser_threshold: int = 0):
+        """
+        Language parser that split code using the respective language syntax.
+
+        Args:
+            language: If None (default), it will try to infer language from source.
+            parser_threshold: Minimum lines needed to activate parsing (0 by default).
+        """
+        self.language = language
+        self.parser_threshold = parser_threshold
+
+    def lazy_parse(self, blob: Blob) -> Iterator[Document]:
+        code = blob.as_string()
+
+        language = self.language or (
+            LANGUAGE_EXTENSIONS.get(blob.source.rsplit(".", 1)[-1])
+            if isinstance(blob.source, str)
+            else None
+        )
+
+        if language is None:
+            yield Document(
+                page_content=code,
+                metadata={
+                    "source": blob.source,
+                },
+            )
+            return
+
+        if self.parser_threshold >= len(code.splitlines()):
+            yield Document(
+                page_content=code,
+                metadata={
+                    "source": blob.source,
+                    "language": language,
+                },
+            )
+            return
+
+        self.Segmenter = LANGUAGE_SEGMENTERS[language]
+        segmenter = self.Segmenter(blob.as_string())
+        if not segmenter.is_valid():
+            yield Document(
+                page_content=code,
+                metadata={
+                    "source": blob.source,
+                },
+            )
+            return
+
+        for functions_classes in segmenter.extract_functions_classes():
+            yield Document(
+                page_content=functions_classes,
+                metadata={
+                    "source": blob.source,
+                    "content_type": "functions_classes",
+                    "language": language,
+                },
+            )
+        yield Document(
+            page_content=segmenter.simplify_code(),
+            metadata={
+                "source": blob.source,
+                "content_type": "simplified_code",
+                "language": language,
+            },
+        )

langchain/document_loaders/parsers/language/python.py

@@ -0,0 +1,47 @@
+import ast
+from typing import Any, List
+
+from langchain.document_loaders.parsers.language.code_segmenter import CodeSegmenter
+
+
+class PythonSegmenter(CodeSegmenter):
+    def __init__(self, code: str):
+        super().__init__(code)
+        self.source_lines = self.code.splitlines()
+
+    def is_valid(self) -> bool:
+        try:
+            ast.parse(self.code)
+            return True
+        except SyntaxError:
+            return False
+
+    def _extract_code(self, node: Any) -> str:
+        start = node.lineno - 1
+        end = node.end_lineno
+        return "\n".join(self.source_lines[start:end])
+
+    def extract_functions_classes(self) -> List[str]:
+        tree = ast.parse(self.code)
+        functions_classes = []
+
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                functions_classes.append(self._extract_code(node))
+
+        return functions_classes
+
+    def simplify_code(self) -> str:
+        tree = ast.parse(self.code)
+        simplified_lines = self.source_lines[:]
+
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                start = node.lineno - 1
+                simplified_lines[start] = f"# Code for: {simplified_lines[start]}"
+
+                assert isinstance(node.end_lineno, int)
+                for line_num in range(start + 1, node.end_lineno):
+                    simplified_lines[line_num] = None  # type: ignore
+
+        return "\n".join(line for line in simplified_lines if line is not None)

langchain/document_loaders/parsers/pdf.py

@@ -1,5 +1,5 @@
 """Module contains common parsers for PDFs."""
-from typing import Any, Iterator, Mapping, Optional
+from typing import Any, Iterator, Mapping, Optional, Union
 
 from langchain.document_loaders.base import BaseBlobParser
 from langchain.document_loaders.blob_loaders import Blob
@@ -9,12 +9,15 @@ from langchain.schema import Document
 class PyPDFParser(BaseBlobParser):
     """Loads a PDF with pypdf and chunks at character level."""
 
+    def __init__(self, password: Optional[Union[str, bytes]] = None):
+        self.password = password
+
     def lazy_parse(self, blob: Blob) -> Iterator[Document]:
         """Lazily parse the blob."""
         import pypdf
 
         with blob.as_bytes_io() as pdf_file_obj:
-            pdf_reader = pypdf.PdfReader(pdf_file_obj)
+            pdf_reader = pypdf.PdfReader(pdf_file_obj, password=self.password)
             yield from [
                 Document(
                     page_content=page.extract_text(),