bump 300 (#10940)

Added async support to the MultiQueryRetriever class.

---------

Co-authored-by: Nuno Campos <nuno@boringbits.io>

.github/workflows/doc_lint.yml

@@ -19,4 +19,4 @@ jobs:
       run: |
         # We should not encourage imports directly from main init file
         # Expect for hub
-        git grep 'from langchain import' docs | grep -vE 'from langchain import (hub)' && exit 1 || exit 0
+        git grep 'from langchain import' docs/{extras,docs_skeleton,snippets} | grep -vE 'from langchain import (hub)' && exit 1 || exit 0

docs/_scripts/model_feat_table.py

@@ -0,0 +1,149 @@
+import os
+from pathlib import Path
+
+from langchain import chat_models, llms
+from langchain.chat_models.base import BaseChatModel, SimpleChatModel
+from langchain.llms.base import BaseLLM, LLM
+
+INTEGRATIONS_DIR = (
+    Path(os.path.abspath(__file__)).parents[1] / "extras" / "integrations"
+)
+LLM_IGNORE = ("FakeListLLM", "OpenAIChat", "PromptLayerOpenAIChat")
+LLM_FEAT_TABLE_CORRECTION = {
+    "TextGen": {"_astream": False, "_agenerate": False},
+    "Ollama": {
+        "_stream": False,
+    },
+    "PromptLayerOpenAI": {"batch_generate": False, "batch_agenerate": False},
+}
+CHAT_MODEL_IGNORE = ("FakeListChatModel", "HumanInputChatModel")
+CHAT_MODEL_FEAT_TABLE_CORRECTION = {
+    "ChatMLflowAIGateway": {"_agenerate": False},
+    "PromptLayerChatOpenAI": {"_stream": False, "_astream": False},
+    "ChatKonko": {"_astream": False, "_agenerate": False},
+}
+
+LLM_TEMPLATE = """\
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+
+# LLMs
+
+import DocCardList from "@theme/DocCardList";
+
+## Features (natively supported)
+All LLMs implement the Runnable interface, which comes with default implementations of all methods, ie. `ainvoke`, `batch`, `abtach`, `stream`, `astream`. This gives all LLMs basic support for async, streaming and batch, which by default is implemented as below:
+- *Async* support defaults to calling the respective sync method in asyncio's default thread pool executor. This lets other async functions in your application make progress while the LLM is being executed, by moving this call to a background thread.
+- *Streaming* support defaults to returning an `Iterator` (or `AsyncIterator` in the case of async streaming) of a single value, the final result returned by the underlying LLM provider. This obviously doesn't give you token-by-token streaming, which requires native support from the LLM provider, but ensures your code that expects an iterator of tokens can work for any of our LLM integrations.
+- *Batch* support defaults to calling the underlying LLM in parallel for each input by making use of a thread pool executor (in the sync batch case) or `asyncio.gather` (in the async batch case). The concurrency can be controlled with the `max_concurrency` key in `RunnableConfig`.
+
+Each LLM integration optionally can implement native support for async, streaming or batch, which, for providers that support it, can be more efficient.
+
+{table}
+
+<DocCardList />
+"""
+
+CHAT_MODEL_TEMPLATE = """\
+---
+sidebar_position: 1
+sidebar_class_name: hidden
+---
+
+# Chat models
+
+import DocCardList from "@theme/DocCardList";
+
+## Features (natively supported)
+All ChatModels implement the Runnable interface, which comes with default implementations of all methods, ie. `ainvoke`, `batch`, `abtach`, `stream`, `astream`. This gives all ChatModels basic support for async, streaming and batch, which by default is implemented as below:
+- *Async* support defaults to calling the respective sync method in asyncio's default thread pool executor. This lets other async functions in your application make progress while the ChatModel is being executed, by moving this call to a background thread.
+- *Streaming* support defaults to returning an `Iterator` (or `AsyncIterator` in the case of async streaming) of a single value, the final result returned by the underlying ChatModel provider. This obviously doesn't give you token-by-token streaming, which requires native support from the ChatModel provider, but ensures your code that expects an iterator of tokens can work for any of our ChatModel integrations.
+- *Batch* support defaults to calling the underlying ChatModel in parallel for each input by making use of a thread pool executor (in the sync batch case) or `asyncio.gather` (in the async batch case). The concurrency can be controlled with the `max_concurrency` key in `RunnableConfig`.
+
+Each ChatModel integration optionally can implement native support for async, streaming or batch, which, for providers that support it, can be more efficient.
+
+{table}
+
+<DocCardList />
+"""
+
+
+def get_llm_table():
+    llm_feat_table = {}
+    for cm in llms.__all__:
+        llm_feat_table[cm] = {}
+        cls = getattr(llms, cm)
+        if issubclass(cls, LLM):
+            for feat in ("_stream", "_astream", ("_acall", "_agenerate")):
+                if isinstance(feat, tuple):
+                    feat, name = feat
+                else:
+                    feat, name = feat, feat
+                llm_feat_table[cm][name] = getattr(cls, feat) != getattr(LLM, feat)
+        else:
+            for feat in [
+                "_stream",
+                "_astream",
+                ("_generate", "batch_generate"),
+                "_agenerate",
+                ("_agenerate", "batch_agenerate"),
+            ]:
+                if isinstance(feat, tuple):
+                    feat, name = feat
+                else:
+                    feat, name = feat, feat
+                llm_feat_table[cm][name] = getattr(cls, feat) != getattr(BaseLLM, feat)
+    final_feats = {
+        k: v
+        for k, v in {**llm_feat_table, **LLM_FEAT_TABLE_CORRECTION}.items()
+        if k not in LLM_IGNORE
+    }
+
+    header = [
+        "model",
+        "_agenerate",
+        "_stream",
+        "_astream",
+        "batch_generate",
+        "batch_agenerate",
+    ]
+    title = ["Model", "Invoke", "Async invoke", "Stream", "Async stream", "Batch", "Async batch"]
+    rows = [title, [":-"] + [":-:"] * (len(title) - 1)]
+    for llm, feats in sorted(final_feats.items()):
+        rows += [[llm, "✅"] + ["✅" if feats.get(h) else "❌" for h in header[1:]]]
+    return "\n".join(["|".join(row) for row in rows])
+
+
+def get_chat_model_table():
+    feat_table = {}
+    for cm in chat_models.__all__:
+        feat_table[cm] = {}
+        cls = getattr(chat_models, cm)
+        if issubclass(cls, SimpleChatModel):
+            comparison_cls = SimpleChatModel
+        else:
+            comparison_cls = BaseChatModel
+        for feat in ("_stream", "_astream", "_agenerate"):
+            feat_table[cm][feat] = getattr(cls, feat) != getattr(comparison_cls, feat)
+    final_feats = {
+        k: v
+        for k, v in {**feat_table, **CHAT_MODEL_FEAT_TABLE_CORRECTION}.items()
+        if k not in CHAT_MODEL_IGNORE
+    }
+    header = ["model", "_agenerate", "_stream", "_astream"]
+    title = ["Model", "Invoke", "Async invoke", "Stream", "Async stream"]
+    rows = [title, [":-"] + [":-:"] * (len(title) - 1)]
+    for llm, feats in sorted(final_feats.items()):
+        rows += [[llm, "✅"] + ["✅" if feats.get(h) else "❌" for h in header[1:]]]
+    return "\n".join(["|".join(row) for row in rows])
+
+
+if __name__ == "__main__":
+    llm_page = LLM_TEMPLATE.format(table=get_llm_table())
+    with open(INTEGRATIONS_DIR / "llms" / "index.mdx", "w") as f:
+        f.write(llm_page)
+    chat_model_page = CHAT_MODEL_TEMPLATE.format(table=get_chat_model_table())
+    with open(INTEGRATIONS_DIR / "chat" / "index.mdx", "w") as f:
+        f.write(chat_model_page)

docs/api_reference/create_api_rst.py

@@ -3,7 +3,7 @@ import importlib
 import inspect
 import typing
 from pathlib import Path
-from typing import TypedDict, Sequence, List, Dict, Literal, Union
+from typing import TypedDict, Sequence, List, Dict, Literal, Union, Optional
 from enum import Enum
 
 from pydantic import BaseModel
@@ -122,7 +122,8 @@ def _merge_module_members(
 
 
 def _load_package_modules(
-    package_directory: Union[str, Path]
+    package_directory: Union[str, Path],
+    submodule: Optional[str] = None
 ) -> Dict[str, ModuleMembers]:
     """Recursively load modules of a package based on the file system.
 
@@ -131,6 +132,7 @@ def _load_package_modules(
 
     Parameters:
         package_directory: Path to the package directory.
+        submodule: Optional name of submodule to load.
 
     Returns:
         list: A list of loaded module objects.
@@ -142,8 +144,13 @@ def _load_package_modules(
     )
     modules_by_namespace = {}
 
+    # Get the high level package name
     package_name = package_path.name
 
+    # If we are loading a submodule, add it in
+    if submodule is not None:
+        package_path = package_path / submodule
+
     for file_path in package_path.rglob("*.py"):
         if file_path.name.startswith("_"):
             continue
@@ -160,9 +167,16 @@ def _load_package_modules(
         top_namespace = namespace.split(".")[0]
 
         try:
-            module_members = _load_module_members(
-                f"{package_name}.{namespace}", namespace
-            )
+            # If submodule is present, we need to construct the paths in a slightly
+            # different way
+            if submodule is not None:
+                module_members = _load_module_members(
+                    f"{package_name}.{submodule}.{namespace}", f"{submodule}.{namespace}"
+                )
+            else:
+                module_members = _load_module_members(
+                    f"{package_name}.{namespace}", namespace
+                )
             # Merge module members if the namespace already exists
             if top_namespace in modules_by_namespace:
                 existing_module_members = modules_by_namespace[top_namespace]
@@ -269,6 +283,12 @@ Functions
 def main() -> None:
     """Generate the reference.rst file for each package."""
     lc_members = _load_package_modules(PKG_DIR)
+    # Put some packages at top level
+    tools = _load_package_modules(PKG_DIR, "tools")
+    lc_members['tools.render'] = tools['render']
+    agents = _load_package_modules(PKG_DIR, "agents")
+    lc_members['agents.output_parsers'] = agents['output_parsers']
+    lc_members['agents.format_scratchpad'] = agents['format_scratchpad']
     lc_doc = ".. _api_reference:\n\n" + _construct_doc("langchain", lc_members)
     with open(WRITE_FILE, "w") as f:
         f.write(lc_doc)

docs/docs_skeleton/docs/expression_language/index.mdx

@@ -5,7 +5,23 @@ sidebar_class_name: hidden
 # LangChain Expression Language (LCEL)
 
 LangChain Expression Language or LCEL is a declarative way to easily compose chains together.
-Any chain constructed this way will automatically have full sync, async, and streaming support.
+There are several benefits to writing chains in this manner (as opposed to writing normal code):
+
+**Async, Batch, and Streaming Support**
+Any chain constructed this way will automatically have full sync, async, batch, and streaming support.
+This makes it easy to prototype a chain in a Jupyter notebook using the sync interface, and then expose it as an async streaming interface.
+
+**Fallbacks**
+The non-determinism of LLMs makes it important to be able to handle errors gracefully.
+With LCEL you can easily attach fallbacks to any chain.
+
+**Parallelism**
+Since LLM applications involve (sometimes long) API calls, it often becomes important to run things in parallel.
+With LCEL syntax, any components that can be run in parallel automatically are.
+
+**Seamless LangSmith Tracing Integration**
+As your chains get more and more complex, it becomes increasingly important to understand what exactly is happening at every step.
+With LCEL, **all** steps are automatically logged to [LangSmith](smith.langchain.com) for maximal observability and debuggability.
 
 #### [Interface](/docs/expression_language/interface)
 The base interface shared by all LCEL objects

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -7,20 +7,27 @@ The core idea of agents is to use an LLM to choose a sequence of actions to take
 In chains, a sequence of actions is hardcoded (in code).
 In agents, a language model is used as a reasoning engine to determine which actions to take and in which order.
 
+Some important terminology (and schema) to know:
+
+1. `AgentAction`: This is a dataclass that represents the action an agent should take. It has a `tool` property (which is the name of the tool that should be invoked) and a `tool_input` property (the input to that tool)
+2. `AgentFinish`: This is a dataclass that signifies that the agent has finished and should return to the user. It has a `return_values` parameter, which is a dictionary to return. It often only has one key - `output` - that is a string, and so often it is just this key that is returned.
+3. `intermediate_steps`: These represent previous agent actions and corresponding outputs that are passed around. These are important to pass to future iteration so the agent knows what work it has already done. This is typed as a `List[Tuple[AgentAction, Any]]`. Note that observation is currently left as type `Any` to be maximally flexible. In practice, this is often a string.
+
 There are several key components here:
 
 ## Agent
 
-This is the class responsible for deciding what step to take next.
+This is the chain responsible for deciding what step to take next.
 This is powered by a language model and a prompt.
-This prompt can include things like:
+The inputs to this chain are:
 
-1. The personality of the agent (useful for having it respond in a certain way)
-2. Background context for the agent (useful for giving it more context on the types of tasks it's being asked to do)
-3. Prompting strategies to invoke better reasoning (the most famous/widely used being [ReAct](https://arxiv.org/abs/2210.03629))
+1. List of available tools
+2. User input
+3. Any previously executed steps (`intermediate_steps`)
 
-LangChain provides a few different types of agents to get started.
-Even then, you will likely want to customize those agents with parts (1) and (2).
+This chain then returns either the next action to take or the final response to send to the user (`AgentAction` or `AgentFinish`).
+
+Different agents have different prompting styles for reasoning, different ways of encoding input, and different ways of parsing the output.
 For a full list of agent types see [agent types](/docs/modules/agents/agent_types/)
 
 ## Tools
@@ -74,12 +81,22 @@ The `AgentExecutor` class is the main agent runtime supported by LangChain.
 However, there are other, more experimental runtimes we also support.
 These include:
 
-- [Plan-and-execute Agent](/docs/modules/agents/agent_types/plan_and_execute.html)
-- [Baby AGI](/docs/use_cases/autonomous_agents/baby_agi.html)
-- [Auto GPT](/docs/use_cases/autonomous_agents/autogpt.html)
+- [Plan-and-execute Agent](/docs/use_cases/more/agents/autonomous_agents/plan_and_execute)
+- [Baby AGI](/docs/use_cases/more/agents/autonomous_agents/baby_agi)
+- [Auto GPT](/docs/use_cases/more/agents/autonomous_agents/autogpt)
 
 ## Get started
 
 import GetStarted from "@snippets/modules/agents/get_started.mdx"
 
 <GetStarted/>
+
+## Next Steps
+
+Awesome! You've now run your first end-to-end agent.
+To dive deeper, you can:
+
+- Check out all the different [agent types](/docs/modules/agents/agent_types/) supported
+- Learn all the controls for [AgentExecutor](/docs/modules/agents/how_to/)
+- See a full list of all the off-the-shelf [toolkits](/docs/modules/agents/toolkits/) we provide
+- Explore all the individual [tools](/docs/modules/agents/tools/) supported

docs/docs_skeleton/sidebars.js

@@ -99,8 +99,8 @@ module.exports = {
       label: "Components",
       collapsible: false,
       items: [
-        { type: "category", label: "LLMs", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/llms" }], link: {type: "generated-index", slug: "integrations/llms" }},
-        { type: "category", label: "Chat models", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/chat" }], link: {type: "generated-index", slug: "integrations/chat" }},
+        { type: "category", label: "LLMs", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/llms" }], link: { type: 'doc', id: "integrations/llms/index"}},
+        { type: "category", label: "Chat models", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/chat" }], link: { type: 'doc', id: "integrations/chat/index"}},
         { type: "category", label: "Document loaders", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/document_loaders" }], link: {type: "generated-index", slug: "integrations/document_loaders" }},
         { type: "category", label: "Document transformers", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/document_transformers" }], link: {type: "generated-index", slug: "integrations/document_transformers" }},
         { type: "category", label: "Text embedding models", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/text_embedding" }], link: {type: "generated-index", slug: "integrations/text_embedding" }},

docs/docs_skeleton/vercel.json

@@ -1,72 +1,88 @@
 {
   "redirects": [
+    {
+      "source": "/docs/use_cases(/?)",
+      "destination": "/docs/use_cases/question_answering/"
+    },
+    {
+      "source": "/docs/integrations(/?)",
+      "destination": "/docs/integrations/providers/"
+    },
+    {
+      "source": "/docs/integrations/platforms(/?)",
+      "destination": "/docs/integrations/providers/"
+    },
+    {
+      "source": "/docs/integrations/platforms(/?)",
+      "destination": "/docs/integrations/providers/"
+    },
     {
       "source": "/docs/expression_language/cookbook/routing",
       "destination": "/docs/expression_language/how_to/routing"
     },
     {
       "source":  "/docs/integrations/providers/amazon_api_gateway",
-      "destination": "/docs/integrations/platform/aws"
+      "destination": "/docs/integrations/platforms/aws"
     },
     {
       "source":  "/docs/integrations/providers/azure_blob_storage",
-      "destination": "/docs/integrations/platform/microsoft"
+      "destination": "/docs/integrations/platforms/microsoft"
     },
     {
       "source":  "/docs/integrations/providers/google_vertexai_matchingengine",
-      "destination": "/docs/integrations/platform/google"
+      "destination": "/docs/integrations/platforms/google"
     },
     {
       "source":  "/docs/integrations/providers/aws_s3",
-      "destination": "/docs/integrations/platform/aws"
+      "destination": "/docs/integrations/platforms/aws"
     },
     {
       "source":  "/docs/integrations/providers/azure_openai",
-      "destination": "/docs/integrations/platform/microsoft"
+      "destination": "/docs/integrations/platforms/microsoft"
     },
     {
       "source":  "/docs/integrations/providers/azure_blob_storage",
-      "destination": "/docs/integrations/platform/microsoft"
+      "destination": "/docs/integrations/platforms/microsoft"
     },
     {
       "source":  "/docs/integrations/providers/azure_cognitive_search_",
-      "destination": "/docs/integrations/platform/microsoft"
+      "destination": "/docs/integrations/platforms/microsoft"
     },
     {
       "source":  "/docs/integrations/providers/bedrock",
-      "destination": "/docs/integrations/platform/aws"
+      "destination": "/docs/integrations/platforms/aws"
     },
     {
       "source":  "/docs/integrations/providers/google_bigquery",
-      "destination": "/docs/integrations/platform/google"
+      "destination": "/docs/integrations/platforms/google"
     },
     {
       "source":  "/docs/integrations/providers/google_cloud_storage",
-      "destination": "/docs/integrations/platform/google"
+      "destination": "/docs/integrations/platforms/google"
     },
     {
       "source":  "/docs/integrations/providers/google_drive",
-      "destination": "/docs/integrations/platform/google"
+      "destination": "/docs/integrations/platforms/google"
     },
     {
       "source":  "/docs/integrations/providers/google_search",
-      "destination": "/docs/integrations/platform/google"
+      "destination": "/docs/integrations/platforms/google"
     },
     {
       "source":  "/docs/integrations/providers/microsoft_onedrive",
-      "destination": "/docs/integrations/platform/microsoft"
+      "destination": "/docs/integrations/platforms/microsoft"
     },
     {
       "source":  "/docs/integrations/providers/microsoft_powerpoint",
-      "destination": "/docs/integrations/platform/microsoft"
+      "destination": "/docs/integrations/platforms/microsoft"
     },
     {
       "source":  "/docs/integrations/providers/microsoft_word",
-      "destination": "/docs/integrations/platform/microsoft"
+      "destination": "/docs/integrations/platforms/microsoft"
     },
     {
       "source":  "/docs/integrations/providers/sagemaker_endpoint",
-      "destination": "/docs/integrations/platform/aws"
+      "destination": "/docs/integrations/platforms/aws"
     },
     {
       "source":  "/docs/integrations/providers/sagemaker_tracking",
@@ -74,7 +90,7 @@
     },
     {
       "source":  "/docs/integrations/providers/openai",
-      "destination": "/docs/integrations/callbacks/openai"
+      "destination": "/docs/integrations/platforms/openai"
     },
     {
       "source": "/docs/modules/data_connection/caching_embeddings(/?)",
@@ -438,7 +454,7 @@
     },
     {
       "source": "/docs/integrations/openai",
-      "destination": "/docs/integrations/providers/openai"
+      "destination": "/docs/integrations/platforms/openai"
     },
     {
       "source": "/docs/integrations/opensearch",

docs/extras/expression_language/how_to/_category_.yml

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

docs/extras/expression_language/how_to/index.mdx

@@ -0,0 +1,9 @@
+---
+sidebar_position: 1
+---
+
+# How to
+
+import DocCardList from "@theme/DocCardList";
+
+<DocCardList />

docs/extras/integrations/chat/baidu_qianfan_endpoint.ipynb

@@ -46,21 +46,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:00:29] logging.py:55 [t:139698882193216]: requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    }
+   ],
    "source": [
     "\"\"\"For basic init and call\"\"\"\n",
-    "from langchain.chat_models.baidu_qianfan_endpoint import QianfanChatEndpoint \n",
+    "from langchain.chat_models import QianfanChatEndpoint \n",
     "from langchain.chat_models.base import HumanMessage\n",
     "import os\n",
-    "os.environ[\"QIAFAN_AK\"] = \"xxx\"\n",
-    "os.environ[\"QIAFAN_AK\"] = \"xxx\"\n",
-    "\n",
+    "os.environ[\"QIANFAN_AK\"] = \"your_ak\"\n",
+    "os.environ[\"QIANFAN_SK\"] = \"your_sk\"\n",
     "\n",
     "chat = QianfanChatEndpoint(\n",
-    "                            qianfan_ak=\"xxx\",\n",
-    "                            qianfan_sk=\"xxx\",\n",
     "                            streaming=True, \n",
     "                            )\n",
     "res = chat([HumanMessage(content=\"write a funny joke\")])\n"
@@ -68,21 +73,55 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:00:36] logging.py:55 [t:139698882193216]: requesting llm api endpoint: /chat/eb-instant\n",
+      "[INFO] [09-15 20:00:37] logging.py:55 [t:139698882193216]: async requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "chat resp: content='您好，您似乎输入' additional_kwargs={} example=False\n",
+      "chat resp: content='了一个话题标签，请问需要我帮您找到什么资料或者帮助您解答什么问题吗？' additional_kwargs={} example=False\n",
+      "chat resp: content='' additional_kwargs={} example=False\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:00:39] logging.py:55 [t:139698882193216]: async requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "generations=[[ChatGeneration(text=\"The sea is a vast expanse of water that covers much of the Earth's surface. It is a source of travel, trade, and entertainment, and is also a place of scientific exploration and marine conservation. The sea is an important part of our world, and we should cherish and protect it.\", generation_info={'finish_reason': 'finished'}, message=AIMessage(content=\"The sea is a vast expanse of water that covers much of the Earth's surface. It is a source of travel, trade, and entertainment, and is also a place of scientific exploration and marine conservation. The sea is an important part of our world, and we should cherish and protect it.\", additional_kwargs={}, example=False))]] llm_output={} run=[RunInfo(run_id=UUID('d48160a6-5960-4c1d-8a0e-90e6b51a209b'))]\n",
+      "astream content='The sea is a vast' additional_kwargs={} example=False\n",
+      "astream content=' expanse of water, a place of mystery and adventure. It is the source of many cultures and civilizations, and a center of trade and exploration. The sea is also a source of life and beauty, with its unique marine life and diverse' additional_kwargs={} example=False\n",
+      "astream content=' coral reefs. Whether you are swimming, diving, or just watching the sea, it is a place that captivates the imagination and transforms the spirit.' additional_kwargs={} example=False\n"
+     ]
+    }
+   ],
    "source": [
     "    \n",
-    "from langchain.chat_models.baidu_qianfan_endpoint import QianfanChatEndpoint\n",
+    "from langchain.chat_models import QianfanChatEndpoint\n",
     "from langchain.schema import HumanMessage\n",
-    "import asyncio\n",
     "\n",
     "chatLLM = QianfanChatEndpoint(\n",
     "    streaming=True,\n",
     ")\n",
     "res = chatLLM.stream([HumanMessage(content=\"hi\")], streaming=True)\n",
     "for r in res:\n",
-    "    print(\"chat resp1:\", r)\n",
+    "    print(\"chat resp:\", r)\n",
     "\n",
     "\n",
     "async def run_aio_generate():\n",
@@ -113,9 +152,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:00:50] logging.py:55 [t:139698882193216]: requesting llm api endpoint: /chat/bloomz_7b1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content='你好！很高兴见到你。' additional_kwargs={} example=False\n"
+     ]
+    }
+   ],
    "source": [
     "chatBloom = QianfanChatEndpoint(\n",
     "                            streaming=True, \n",
@@ -141,9 +195,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:00:57] logging.py:55 [t:139698882193216]: requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content='您好，您似乎输入' additional_kwargs={} example=False\n",
+      "content='了一个文本字符串，但并没有给出具体的问题或场景。' additional_kwargs={} example=False\n",
+      "content='如果您能提供更多信息，我可以更好地回答您的问题。' additional_kwargs={} example=False\n",
+      "content='' additional_kwargs={} example=False\n"
+     ]
+    }
+   ],
    "source": [
     "res = chat.stream([HumanMessage(content=\"hi\")], **{'top_p': 0.4, 'temperature': 0.1, 'penalty_score': 1})\n",
     "\n",
@@ -154,7 +226,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "base",
    "language": "python",
    "name": "python3"
   },
@@ -168,11 +240,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.2"
+   "version": "3.11.4"
   },
   "vscode": {
    "interpreter": {
-    "hash": "2d8226dd90b7dc6e8932aea372a8bf9fc71abac4be3cdd5a63a36c2a19e3700f"
+    "hash": "6fa70026b407ae751a5c9e6bd7f7d482379da8ad616f98512780b705c84ee157"
    }
   }
  },

docs/extras/integrations/chat/bedrock.ipynb

@@ -22,7 +22,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 1,
+            "execution_count": null,
             "id": "d4a7c55d-b235-4ca4-a579-c90cc9570da9",
             "metadata": {
                 "tags": []
@@ -73,13 +73,46 @@
                 "chat(messages)"
             ]
         },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "id": "a4a4f4d4",
+            "metadata": {},
+            "source": [
+                "### For BedrockChat with Streaming"
+            ]
+        },
         {
             "cell_type": "code",
             "execution_count": null,
             "id": "c253883f",
             "metadata": {},
             "outputs": [],
-            "source": []
+            "source": [
+                "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+                "\n",
+                "chat = BedrockChat(\n",
+                "    model_id=\"anthropic.claude-v2\",\n",
+                "    streaming=True,\n",
+                "    callbacks=[StreamingStdOutCallbackHandler()],\n",
+                "    model_kwargs={\"temperature\": 0.1},\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "d9e52838",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "messages = [\n",
+                "    HumanMessage(\n",
+                "        content=\"Translate this sentence from English to French. I love programming.\"\n",
+                "    )\n",
+                "]\n",
+                "chat(messages)"
+            ]
         }
     ],
     "metadata": {
@@ -98,7 +131,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.11.4"
+            "version": "3.10.9"
         }
     },
     "nbformat": 4,

docs/extras/integrations/chat/google_vertex_ai_palm.ipynb

@@ -5,7 +5,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Google Cloud Platform Vertex AI PaLM \n",
+    "# GCP Vertex AI \n",
     "\n",
     "Note: This is seperate from the Google PaLM integration. Google has chosen to offer an enterprise version of PaLM through GCP, and this supports the models made available through there. \n",
     "\n",
@@ -31,7 +31,7 @@
    },
    "outputs": [],
    "source": [
-    "#!pip install google-cloud-aiplatform"
+    "#!pip install langchain google-cloud-aiplatform"
    ]
   },
   {
@@ -41,12 +41,7 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatVertexAI\n",
-    "from langchain.prompts.chat import (\n",
-    "    ChatPromptTemplate,\n",
-    "    SystemMessagePromptTemplate,\n",
-    "    HumanMessagePromptTemplate,\n",
-    ")\n",
-    "from langchain.schema import HumanMessage, SystemMessage"
+    "from langchain.prompts import ChatPromptTemplate"
    ]
   },
   {
@@ -60,82 +55,78 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system = \"You are a helpful assistant who translate English to French\"\n",
+    "human = \"Translate this sentence from English to French. I love programming.\"\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", system), (\"human\",  human)]\n",
+    ")\n",
+    "messages = prompt.format_messages()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='Sure, here is the translation of the sentence \"I love programming\" from English to French:\\n\\nJ\\'aime programmer.', additional_kwargs={}, example=False)"
+       "AIMessage(content=\" J'aime la programmation.\", additional_kwargs={}, example=False)"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "messages = [\n",
-    "    SystemMessage(\n",
-    "        content=\"You are a helpful assistant that translates English to French.\"\n",
-    "    ),\n",
-    "    HumanMessage(\n",
-    "        content=\"Translate this sentence from English to French. I love programming.\"\n",
-    "    ),\n",
-    "]\n",
     "chat(messages)"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can make use of templating by using a `MessagePromptTemplate`. You can build a `ChatPromptTemplate` from one or more `MessagePromptTemplates`. You can use `ChatPromptTemplate`'s `format_prompt` -- this returns a `PromptValue`, which you can convert to a string or Message object, depending on whether you want to use the formatted value as input to an llm or chat model.\n",
-    "\n",
-    "For convenience, there is a `from_template` method exposed on the template. If you were to use this template, this is what it would look like:"
+    "If we want to construct a simple chain that takes user specified parameters:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
-    "template = (\n",
-    "    \"You are a helpful assistant that translates {input_language} to {output_language}.\"\n",
-    ")\n",
-    "system_message_prompt = SystemMessagePromptTemplate.from_template(template)\n",
-    "human_template = \"{text}\"\n",
-    "human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)"
+    "system = \"You are a helpful assistant that translates {input_language} to {output_language}.\"\n",
+    "human = \"{text}\"\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", system), (\"human\",  human)]\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='Sure, here is the translation of \"I love programming\" in French:\\n\\nJ\\'aime programmer.', additional_kwargs={}, example=False)"
+       "AIMessage(content=' 私はプログラミングが大好きです。', additional_kwargs={}, example=False)"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "chat_prompt = ChatPromptTemplate.from_messages(\n",
-    "    [system_message_prompt, human_message_prompt]\n",
-    ")\n",
-    "\n",
-    "# get a chat completion from the formatted messages\n",
-    "chat(\n",
-    "    chat_prompt.format_prompt(\n",
-    "        input_language=\"English\", output_language=\"French\", text=\"I love programming.\"\n",
-    "    ).to_messages()\n",
+    "chain = prompt | chat\n",
+    "chain.invoke(\n",
+    "    {\"input_language\": \"English\", \"output_language\": \"Japanese\", \"text\": \"I love programming\"}\n",
     ")"
    ]
   },
@@ -153,60 +144,129 @@
     "tags": []
    },
    "source": [
+    "## Code generation chat models\n",
     "You can now leverage the Codey API for code chat within Vertex AI. The model name is:\n",
     "- codechat-bison: for code assistance"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 18,
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-06-17T21:30:43.974841Z",
-     "iopub.status.busy": "2023-06-17T21:30:43.974431Z",
-     "iopub.status.idle": "2023-06-17T21:30:44.248119Z",
-     "shell.execute_reply": "2023-06-17T21:30:44.247362Z",
-     "shell.execute_reply.started": "2023-06-17T21:30:43.974820Z"
-    },
     "tags": []
    },
    "outputs": [],
    "source": [
-    "chat = ChatVertexAI(model_name=\"codechat-bison\")"
+    "chat = ChatVertexAI(\n",
+    "    model_name=\"codechat-bison\",\n",
+    "    max_output_tokens=1000,\n",
+    "    temperature=0.5\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 20,
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-06-17T21:30:45.146093Z",
-     "iopub.status.busy": "2023-06-17T21:30:45.145752Z",
-     "iopub.status.idle": "2023-06-17T21:30:47.449126Z",
-     "shell.execute_reply": "2023-06-17T21:30:47.448609Z",
-     "shell.execute_reply.started": "2023-06-17T21:30:45.146069Z"
-    },
     "tags": []
    },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " ```python\n",
+      "def is_prime(x): \n",
+      "    if (x <= 1): \n",
+      "        return False\n",
+      "    for i in range(2, x): \n",
+      "        if (x % i == 0): \n",
+      "            return False\n",
+      "    return True\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "# For simple string in string out usage, we can use the `predict` method:\n",
+    "print(chat.predict(\"Write a Python function to identify all prime numbers\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Asynchronous calls\n",
+    "\n",
+    "We can make asynchronous calls via the `agenerate` and `ainvoke` methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "# import nest_asyncio\n",
+    "# nest_asyncio.apply()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='The following Python function can be used to identify all prime numbers up to a given integer:\\n\\n```\\ndef is_prime(n):\\n  \"\"\"\\n  Determines whether the given integer is prime.\\n\\n  Args:\\n    n: The integer to be tested for primality.\\n\\n  Returns:\\n    True if n is prime, False otherwise.\\n  \"\"\"\\n\\n  # Check if n is divisible by 2.\\n  if n % 2 == 0:\\n    return False\\n\\n  # Check if n is divisible by any integer from 3 to the square root', additional_kwargs={}, example=False)"
+       "LLMResult(generations=[[ChatGeneration(text=\" J'aime la programmation.\", generation_info=None, message=AIMessage(content=\" J'aime la programmation.\", additional_kwargs={}, example=False))]], llm_output={}, run=[RunInfo(run_id=UUID('223599ef-38f8-4c79-ac6d-a5013060eb9d'))])"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 35,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "messages = [\n",
-    "    HumanMessage(\n",
-    "        content=\"How do I create a python function to identify all prime numbers?\"\n",
-    "    )\n",
-    "]\n",
-    "chat(messages)"
+    "chat = ChatVertexAI(\n",
+    "    model_name=\"chat-bison\",\n",
+    "    max_output_tokens=1000,\n",
+    "    temperature=0.7,\n",
+    "    top_p=0.95,\n",
+    "    top_k=40,\n",
+    ")\n",
+    "\n",
+    "asyncio.run(chat.agenerate([messages]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' अहं प्रोग्रामिंग प्रेमामि', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "asyncio.run(chain.ainvoke({\"input_language\": \"English\", \"output_language\": \"Sanskrit\", \"text\": \"I love programming\"}))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Streaming calls\n",
+    "\n",
+    "We can also stream outputs via the `stream` method:"
    ]
   },
   {
@@ -214,14 +274,51 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "import sys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 1. China (1,444,216,107)\n",
+      "2. India (1,393,409,038)\n",
+      "3. United States (332,403,650)\n",
+      "4. Indonesia (273,523,615)\n",
+      "5. Pakistan (220,892,340)\n",
+      "6. Brazil (212,559,409)\n",
+      "7. Nigeria (206,139,589)\n",
+      "8. Bangladesh (164,689,383)\n",
+      "9. Russia (145,934,462)\n",
+      "10. Mexico (128,932,488)\n",
+      "11. Japan (126,476,461)\n",
+      "12. Ethiopia (115,063,982)\n",
+      "13. Philippines (109,581,078)\n",
+      "14. Egypt (102,334,404)\n",
+      "15. Vietnam (97,338,589)"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages([(\"human\", \"List out the 15 most populous countries in the world\")])\n",
+    "messages = prompt.format_messages()\n",
+    "for chunk in chat.stream(messages):\n",
+    "    sys.stdout.write(chunk.content)\n",
+    "    sys.stdout.flush()"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "poetry-venv",
    "language": "python",
-   "name": "python3"
+   "name": "poetry-venv"
   },
   "language_info": {
    "codemirror_mode": {

docs/extras/integrations/chat/index.mdx

@@ -0,0 +1,38 @@
+---
+sidebar_position: 1
+sidebar_class_name: hidden
+---
+
+# Chat models
+
+import DocCardList from "@theme/DocCardList";
+
+## Features (natively supported)
+All ChatModels implement the Runnable interface, which comes with default implementations of all methods, ie. `ainvoke`, `batch`, `abtach`, `stream`, `astream`. This gives all ChatModels basic support for async, streaming and batch, which by default is implemented as below:
+- *Async* support defaults to calling the respective sync method in asyncio's default thread pool executor. This lets other async functions in your application make progress while the ChatModel is being executed, by moving this call to a background thread.
+- *Streaming* support defaults to returning an `Iterator` (or `AsyncIterator` in the case of async streaming) of a single value, the final result returned by the underlying ChatModel provider. This obviously doesn't give you token-by-token streaming, which requires native support from the ChatModel provider, but ensures your code that expects an iterator of tokens can work for any of our ChatModel integrations.
+- *Batch* support defaults to calling the underlying ChatModel in parallel for each input by making use of a thread pool executor (in the sync batch case) or `asyncio.gather` (in the async batch case). The concurrency can be controlled with the `max_concurrency` key in `RunnableConfig`.
+
+Each ChatModel integration optionally can implement native support for async, streaming or batch, which, for providers that support it, can be more efficient.
+
+Model|Invoke|Async invoke|Stream|Async stream
+:-|:-:|:-:|:-:|:-:
+AzureChatOpenAI|✅|✅|✅|✅
+BedrockChat|✅|❌|✅|❌
+ChatAnthropic|✅|✅|✅|✅
+ChatAnyscale|✅|✅|✅|✅
+ChatGooglePalm|✅|✅|❌|❌
+ChatJavelinAIGateway|✅|✅|❌|❌
+ChatKonko|✅|❌|❌|❌
+ChatLiteLLM|✅|✅|✅|✅
+ChatMLflowAIGateway|✅|❌|❌|❌
+ChatOllama|✅|❌|✅|❌
+ChatOpenAI|✅|✅|✅|✅
+ChatVertexAI|✅|✅|✅|❌
+ErnieBotChat|✅|❌|❌|❌
+JinaChat|✅|✅|✅|✅
+MiniMaxChat|✅|✅|❌|❌
+PromptLayerChatOpenAI|✅|❌|❌|❌
+QianfanChatEndpoint|✅|✅|✅|✅
+
+<DocCardList />

docs/extras/integrations/chat/minimax.ipynb

@@ -0,0 +1,70 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MiniMax\n",
+    "\n",
+    "[Minimax](https://api.minimax.chat) is a Chinese startup that provides LLM service for companies and individuals.\n",
+    "\n",
+    "This example goes over how to use LangChain to interact with MiniMax Inference for Chat."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"MINIMAX_GROUP_ID\"] = \"MINIMAX_GROUP_ID\"\n",
+    "os.environ[\"MINIMAX_API_KEY\"] = \"MINIMAX_API_KEY\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import MiniMaxChat\n",
+    "from langchain.schema import HumanMessage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat = MiniMaxChat()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat(\n",
+    "    [\n",
+    "        HumanMessage(\n",
+    "            content=\"Translate this sentence from English to French. I love programming.\"\n",
+    "        )\n",
+    "    ]\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/extras/integrations/llms/baidu_qianfan_endpoint.ipynb

@@ -47,32 +47,88 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:23:22] logging.py:55 [t:140708023539520]: trying to refresh access_token\n",
+      "[INFO] [09-15 20:23:22] logging.py:55 [t:140708023539520]: sucessfully refresh access_token\n",
+      "[INFO] [09-15 20:23:22] logging.py:55 [t:140708023539520]: requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0.280\n",
+      "作为一个人工智能语言模型，我无法提供此类信息。\n",
+      "这种类型的信息可能会违反法律法规，并对用户造成严重的心理和社交伤害。\n",
+      "建议遵守相关的法律法规和社会道德规范，并寻找其他有益和健康的娱乐方式。\n"
+     ]
+    }
+   ],
    "source": [
-    "\"\"\"For basic init and call\"\"\"\n",
-    "from langchain.llms.baidu_qianfan_endpoint import QianfanLLMEndpoint\n",
     "\n",
+    "\"\"\"For basic init and call\"\"\"\n",
+    "from langchain.llms import QianfanLLMEndpoint\n",
     "import os\n",
     "\n",
-    "os.environ[\"QIANFAN_AK\"] = \"xx\"\n",
-    "os.environ[\"QIANFAN_SK\"] = \"xx\"\n",
+    "os.environ[\"QIANFAN_AK\"] = \"your_ak\"\n",
+    "os.environ[\"QIANFAN_SK\"] = \"your_sk\"\n",
     "\n",
-    "llm = QianfanLLMEndpoint(streaming=True, ak=\"xx\", sk=\"xx\")\n",
-    "res = llm(\"hi\")\n"
+    "llm = QianfanLLMEndpoint(streaming=True)\n",
+    "res = llm(\"hi\")\n",
+    "print(res)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:23:26] logging.py:55 [t:140708023539520]: requesting llm api endpoint: /chat/eb-instant\n",
+      "[INFO] [09-15 20:23:27] logging.py:55 [t:140708023539520]: async requesting llm api endpoint: /chat/eb-instant\n",
+      "[INFO] [09-15 20:23:29] logging.py:55 [t:140708023539520]: requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "generations=[[Generation(text='Rivers are an important part of the natural environment, providing drinking water, transportation, and other services for human beings. However, due to human activities such as pollution and dams, rivers are facing a series of problems such as water quality degradation and fishery resources decline. Therefore, we should strengthen environmental protection and management, and protect rivers and other natural resources.', generation_info=None)]] llm_output=None run=[RunInfo(run_id=UUID('ffa72a97-caba-48bb-bf30-f5eaa21c996a'))]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:23:30] logging.py:55 [t:140708023539520]: async requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "As an AI language model\n",
+      ", I cannot provide any inappropriate content. My goal is to provide useful and positive information to help people solve problems.\n",
+      "Mountains are the symbols\n",
+      " of majesty and power in nature, and also the lungs of the world. They not only provide oxygen for human beings, but also provide us with beautiful scenery and refreshing air. We can climb mountains to experience the charm of nature,\n",
+      " but also exercise our body and spirit. When we are not satisfied with the rote, we can go climbing, refresh our energy, and reset our focus. However, climbing mountains should be carried out in an organized and safe manner. If you don\n",
+      "'t know how to climb, you should learn first, or seek help from professionals. Enjoy the beautiful scenery of mountains, but also pay attention to safety.\n"
+     ]
+    }
+   ],
    "source": [
     "\n",
     "\"\"\"Test for llm generate \"\"\"\n",
     "res = llm.generate(prompts=[\"hillo?\"])\n",
-    "import asyncio\n",
     "\"\"\"Test for llm aio generate\"\"\"\n",
     "async def run_aio_generate():\n",
     "    resp = await llm.agenerate(prompts=[\"Write a 20-word article about rivers.\"])\n",
@@ -107,16 +163,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:23:36] logging.py:55 [t:140708023539520]: requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    }
+   ],
    "source": [
-    "llm = QianfanLLMEndpoint(qianfan_ak='xxx', \n",
-    "                            qianfan_sk='xxx', \n",
-    "                            streaming=True, \n",
-    "                            model=\"ERNIE-Bot-turbo\",\n",
-    "                            endpoint=\"eb-instant\",\n",
-    "                            )\n",
+    "llm = QianfanLLMEndpoint(\n",
+    "        streaming=True, \n",
+    "        model=\"ERNIE-Bot-turbo\",\n",
+    "        endpoint=\"eb-instant\",\n",
+    "        )\n",
     "res = llm(\"hi\")"
    ]
   },
@@ -136,9 +199,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:23:40] logging.py:55 [t:140708023539520]: requesting llm api endpoint: /chat/eb-instant\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "('generations', [[Generation(text='您好，您似乎输入了一个文本字符串，但并没有给出具体的问题或场景。如果您能提供更多信息，我可以更好地回答您的问题。', generation_info=None)]])\n",
+      "('llm_output', None)\n",
+      "('run', [RunInfo(run_id=UUID('9d0bfb14-cf15-44a9-bca1-b3e96b75befe'))])\n"
+     ]
+    }
+   ],
    "source": [
     "res = llm.generate(prompts=[\"hi\"], streaming=True, **{'top_p': 0.4, 'temperature': 0.1, 'penalty_score': 1})\n",
     "\n",

docs/extras/integrations/llms/bedrock.ipynb

@@ -61,6 +61,46 @@
     "\n",
     "conversation.predict(input=\"Hi there!\")"
    ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Conversation Chain With Streaming"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import Bedrock\n",
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "\n",
+    "\n",
+    "llm = Bedrock(\n",
+    "    credentials_profile_name=\"bedrock-admin\",\n",
+    "    model_id=\"amazon.titan-tg1-large\",\n",
+    "    streaming=True,\n",
+    "    callbacks=[StreamingStdOutCallbackHandler()],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "conversation = ConversationChain(\n",
+    "    llm=llm, verbose=True, memory=ConversationBufferMemory()\n",
+    ")\n",
+    "\n",
+    "conversation.predict(input=\"Hi there!\")"
+   ]
   }
  ],
  "metadata": {

docs/extras/integrations/llms/google_vertex_ai_palm.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Google Vertex AI PaLM \n",
+    "# GCP Vertex AI\n",
     "\n",
     "**Note:** This is separate from the `Google PaLM` integration, it exposes [Vertex AI PaLM API](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/overview) on `Google Cloud`. \n"
    ]
@@ -41,32 +41,56 @@
    },
    "outputs": [],
    "source": [
-    "#!pip install google-cloud-aiplatform"
+    "#!pip install langchain google-cloud-aiplatform"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain.llms import VertexAI"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Python is a widely used, interpreted, object-oriented, and high-level programming language with dynamic semantics, used for general-purpose programming. It is known for its readability, simplicity, and versatility. Here are some of the pros and cons of Python:\n",
+      "\n",
+      "**Pros:**\n",
+      "\n",
+      "- **Easy to learn:** Python is known for its simple and intuitive syntax, making it easy for beginners to learn. It has a relatively shallow learning curve compared to other programming languages.\n",
+      "\n",
+      "- **Versatile:** Python is a general-purpose programming language, meaning it can be used for a wide variety of tasks, including web development, data science, machine\n"
+     ]
+    }
+   ],
+   "source": [
+    "llm = VertexAI()\n",
+    "print(llm(\"What are some of the pros and cons of Python as a programming language?\"))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Question-answering example"
+    "## Using in a chain"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\nfrom langchain.chains import LLMChain"
+    "from langchain.prompts import PromptTemplate"
    ]
   },
   {
@@ -78,17 +102,7 @@
     "template = \"\"\"Question: {question}\n",
     "\n",
     "Answer: Let's think step by step.\"\"\"\n",
-    "\n",
-    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = VertexAI()"
+    "prompt = PromptTemplate.from_template(template)"
    ]
   },
   {
@@ -97,29 +111,26 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm_chain = LLMChain(prompt=prompt, llm=llm)"
+    "chain = prompt | llm"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'Justin Bieber was born on March 1, 1994. The Super Bowl in 1994 was won by the San Francisco 49ers.\\nThe final answer: San Francisco 49ers.'"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Justin Bieber was born on March 1, 1994. Bill Clinton was the president of the United States from January 20, 1993, to January 20, 2001.\n",
+      "The final answer is Bill Clinton\n"
+     ]
     }
    ],
    "source": [
-    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
-    "\n",
-    "llm_chain.run(question)"
+    "question = \"Who was the president in the year Justin Beiber was born?\"\n",
+    "print(chain.invoke({\"question\": question}))"
    ]
   },
   {
@@ -140,78 +151,200 @@
     "- `code-gecko`: for code completion"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-06-17T21:16:53.149438Z",
-     "iopub.status.busy": "2023-06-17T21:16:53.149065Z",
-     "iopub.status.idle": "2023-06-17T21:16:53.421824Z",
-     "shell.execute_reply": "2023-06-17T21:16:53.421136Z",
-     "shell.execute_reply.started": "2023-06-17T21:16:53.149415Z"
-    },
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "llm = VertexAI(model_name=\"code-bison\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-06-17T21:17:11.179077Z",
-     "iopub.status.busy": "2023-06-17T21:17:11.178686Z",
-     "iopub.status.idle": "2023-06-17T21:17:11.182499Z",
-     "shell.execute_reply": "2023-06-17T21:17:11.181895Z",
-     "shell.execute_reply.started": "2023-06-17T21:17:11.179052Z"
-    },
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "llm_chain = LLMChain(prompt=prompt, llm=llm)"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2023-06-17T21:18:47.024785Z",
-     "iopub.status.busy": "2023-06-17T21:18:47.024230Z",
-     "iopub.status.idle": "2023-06-17T21:18:49.352249Z",
-     "shell.execute_reply": "2023-06-17T21:18:49.351695Z",
-     "shell.execute_reply.started": "2023-06-17T21:18:47.024762Z"
-    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "llm = VertexAI(model_name=\"code-bison\", max_output_tokens=1000, temperature=0.3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"Write a python function that checks if a string is a valid email address\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
     "tags": []
    },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'```python\\ndef is_prime(n):\\n  \"\"\"\\n  Determines if a number is prime.\\n\\n  Args:\\n    n: The number to be tested.\\n\\n  Returns:\\n    True if the number is prime, False otherwise.\\n  \"\"\"\\n\\n  # Check if the number is 1.\\n  if n == 1:\\n    return False\\n\\n  # Check if the number is 2.\\n  if n == 2:\\n    return True\\n\\n'"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "```python\n",
+      "import re\n",
+      "\n",
+      "def is_valid_email(email):\n",
+      "    pattern = re.compile(r\"[^@]+@[^@]+\\.[^@]+\")\n",
+      "    return pattern.match(email)\n",
+      "```\n"
+     ]
     }
    ],
    "source": [
-    "question = \"Write a python function that identifies if the number is a prime number?\"\n",
-    "\n",
-    "llm_chain.run(question)"
+    "print(llm(question))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Using models deployed on Vertex Model Garden"
+    "## Full generation info\n",
+    "\n",
+    "We can use the `generate` method to get back extra metadata like [safety attributes](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/responsible-ai#safety_attribute_confidence_scoring) and not just text completions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[GenerationChunk(text='```python\\nimport re\\n\\ndef is_valid_email(email):\\n    pattern = re.compile(r\"[^@]+@[^@]+\\\\.[^@]+\")\\n    return pattern.match(email)\\n```', generation_info={'is_blocked': False, 'safety_attributes': {'Health': 0.1}})]]"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = llm.generate([question])\n",
+    "result.generations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Asynchronous calls\n",
+    "\n",
+    "With `agenerate` we can make asynchronous calls"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# If running in a Jupyter notebook you'll need to install nest_asyncio\n",
+    "\n",
+    "# !pip install nest_asyncio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "# import nest_asyncio\n",
+    "# nest_asyncio.apply()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LLMResult(generations=[[GenerationChunk(text='```python\\nimport re\\n\\ndef is_valid_email(email):\\n    pattern = re.compile(r\"[^@]+@[^@]+\\\\.[^@]+\")\\n    return pattern.match(email)\\n```', generation_info={'is_blocked': False, 'safety_attributes': {'Health': 0.1}})]], llm_output=None, run=[RunInfo(run_id=UUID('caf74e91-aefb-48ac-8031-0c505fcbbcc6'))])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "asyncio.run(llm.agenerate([question]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Streaming calls\n",
+    "\n",
+    "With `stream` we can stream results from the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "```python\n",
+      "import re\n",
+      "\n",
+      "def is_valid_email(email):\n",
+      "  \"\"\"\n",
+      "  Checks if a string is a valid email address.\n",
+      "\n",
+      "  Args:\n",
+      "    email: The string to check.\n",
+      "\n",
+      "  Returns:\n",
+      "    True if the string is a valid email address, False otherwise.\n",
+      "  \"\"\"\n",
+      "\n",
+      "  # Check for a valid email address format.\n",
+      "  if not re.match(r\"^[A-Za-z0-9\\.\\+_-]+@[A-Za-z0-9\\._-]+\\.[a-zA-Z]*$\", email):\n",
+      "    return False\n",
+      "\n",
+      "  # Check if the domain name exists.\n",
+      "  try:\n",
+      "    domain = email.split(\"@\")[1]\n",
+      "    socket.gethostbyname(domain)\n",
+      "  except socket.gaierror:\n",
+      "    return False\n",
+      "\n",
+      "  return True\n",
+      "```"
+     ]
+    }
+   ],
+   "source": [
+    "for chunk in llm.stream(question):\n",
+    "    sys.stdout.write(chunk)\n",
+    "    sys.stdout.flush()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Vertex Model Garden"
    ]
   },
   {
@@ -248,7 +381,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm(\"What is the meaning of life?\")"
+    "print(llm(\"What is the meaning of life?\"))"
    ]
   },
   {
@@ -264,8 +397,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
-    "\n",
     "prompt = PromptTemplate.from_template(\"What is the meaning of {thing}?\")"
    ]
   },
@@ -275,9 +406,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm_oss_chain = prompt | llm\n",
-    "\n",
-    "llm_oss_chain.invoke({\"thing\": \"life\"})"
+    "chian = prompt | llm\n",
+    "print(chain.invoke({\"thing\": \"life\"}))"
    ]
   }
  ],

docs/extras/integrations/llms/gradient.ipynb

@@ -0,0 +1,216 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Gradient\n",
+    "\n",
+    "`Gradient` allows to fine tune and get completions on LLMs with a simple web API.\n",
+    "\n",
+    "This notebook goes over how to use Langchain with [Gradient](https://gradient.ai/).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import requests\n",
+    "from langchain.llms import GradientLLM\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.chains import LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set the Environment API Key\n",
+    "Make sure to get your API key from Gradient AI. You are given $10 in free credits to test and fine-tune different models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from getpass import getpass\n",
+    "\n",
+    "\n",
+    "if not os.environ.get(\"GRADIENT_ACCESS_TOKEN\",None):\n",
+    "    # Access token under https://auth.gradient.ai/select-workspace\n",
+    "    os.environ[\"GRADIENT_ACCESS_TOKEN\"] = getpass(\"gradient.ai access token:\")\n",
+    "if not os.environ.get(\"GRADIENT_WORKSPACE_ID\",None):\n",
+    "    # `ID` listed in `$ gradient workspace list`\n",
+    "    # also displayed after login at at https://auth.gradient.ai/select-workspace\n",
+    "    os.environ[\"GRADIENT_WORKSPACE_ID\"] = getpass(\"gradient.ai workspace id:\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Optional: Validate your Enviroment variables ```GRADIENT_ACCESS_TOKEN``` and ```GRADIENT_WORKSPACE_ID``` to get currently deployed models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Credentials valid.\n",
+      "Possible values for `model_id` are:\n",
+      " {'models': [{'id': '99148c6d-c2a0-4fbe-a4a7-e7c05bdb8a09_base_ml_model', 'name': 'bloom-560m', 'slug': 'bloom-560m', 'type': 'baseModel'}, {'id': 'f0b97d96-51a8-4040-8b22-7940ee1fa24e_base_ml_model', 'name': 'llama2-7b-chat', 'slug': 'llama2-7b-chat', 'type': 'baseModel'}, {'id': 'cc2dafce-9e6e-4a23-a918-cad6ba89e42e_base_ml_model', 'name': 'nous-hermes2', 'slug': 'nous-hermes2', 'type': 'baseModel'}, {'baseModelId': 'f0b97d96-51a8-4040-8b22-7940ee1fa24e_base_ml_model', 'id': 'bb7b9865-0ce3-41a8-8e2b-5cbcbe1262eb_model_adapter', 'name': 'optical-transmitting-sensor', 'type': 'modelAdapter'}]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "\n",
+    "resp = requests.get(f'https://api.gradient.ai/api/models', headers={\n",
+    "                    \"authorization\": f\"Bearer {os.environ['GRADIENT_ACCESS_TOKEN']}\",\n",
+    "                    \"x-gradient-workspace-id\": f\"{os.environ['GRADIENT_WORKSPACE_ID']}\",\n",
+    "                },\n",
+    "              )\n",
+    "if resp.status_code == 200:\n",
+    "    models = resp.json()\n",
+    "    print(\"Credentials valid.\\nPossible values for `model_id` are:\\n\", models)\n",
+    "else:\n",
+    "    print(\"Error when listing models. Are your credentials valid?\", resp.text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the Gradient instance\n",
+    "You can specify different parameters such as the model name, max tokens generated, temperature, etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = GradientLLM(\n",
+    "    # `ID` listed in `$ gradient model list`\n",
+    "    model_id=\"99148c6d-c2a0-4fbe-a4a7-e7c05bdb8a09_base_ml_model\",\n",
+    "    # # optional: set new credentials, they default to environment variables\n",
+    "    # gradient_workspace_id=os.environ[\"GRADIENT_WORKSPACE_ID\"],\n",
+    "    # gradient_access_token=os.environ[\"GRADIENT_ACCESS_TOKEN\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a Prompt Template\n",
+    "We will create a prompt template for Question and Answer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initiate the LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the LLMChain\n",
+    "Provide a question and run the LLMChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' The first team to win the Super Bowl was the New England Patriots. The Patriots won the'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "question = \"What NFL team won the Super Bowl in 1994?\"\n",
+    "\n",
+    "llm_chain.run(\n",
+    "    question=question\n",
+    ")"
+   ]
+  }
+ ],
+ "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.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "a0a0263b650d907a3bfe41c0f8d6a63a071b884df3cfdc1579f00cdc1aed6b03"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/extras/integrations/llms/index.mdx

@@ -0,0 +1,93 @@
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+
+# LLMs
+
+import DocCardList from "@theme/DocCardList";
+
+## Features (natively supported)
+All LLMs implement the Runnable interface, which comes with default implementations of all methods, ie. `ainvoke`, `batch`, `abtach`, `stream`, `astream`. This gives all LLMs basic support for async, streaming and batch, which by default is implemented as below:
+- *Async* support defaults to calling the respective sync method in asyncio's default thread pool executor. This lets other async functions in your application make progress while the LLM is being executed, by moving this call to a background thread.
+- *Streaming* support defaults to returning an `Iterator` (or `AsyncIterator` in the case of async streaming) of a single value, the final result returned by the underlying LLM provider. This obviously doesn't give you token-by-token streaming, which requires native support from the LLM provider, but ensures your code that expects an iterator of tokens can work for any of our LLM integrations.
+- *Batch* support defaults to calling the underlying LLM in parallel for each input by making use of a thread pool executor (in the sync batch case) or `asyncio.gather` (in the async batch case). The concurrency can be controlled with the `max_concurrency` key in `RunnableConfig`.
+
+Each LLM integration optionally can implement native support for async, streaming or batch, which, for providers that support it, can be more efficient.
+
+Model|Invoke|Async invoke|Stream|Async stream|Batch|Async batch
+:-|:-:|:-:|:-:|:-:|:-:|:-:
+AI21|✅|❌|❌|❌|❌|❌
+AlephAlpha|✅|❌|❌|❌|❌|❌
+AmazonAPIGateway|✅|❌|❌|❌|❌|❌
+Anthropic|✅|✅|✅|✅|❌|❌
+Anyscale|✅|❌|❌|❌|❌|❌
+Aviary|✅|❌|❌|❌|❌|❌
+AzureMLOnlineEndpoint|✅|❌|❌|❌|❌|❌
+AzureOpenAI|✅|✅|✅|✅|✅|✅
+Banana|✅|❌|❌|❌|❌|❌
+Baseten|✅|❌|❌|❌|❌|❌
+Beam|✅|❌|❌|❌|❌|❌
+Bedrock|✅|❌|✅|❌|❌|❌
+CTransformers|✅|✅|❌|❌|❌|❌
+CTranslate2|✅|❌|❌|❌|✅|❌
+CerebriumAI|✅|❌|❌|❌|❌|❌
+ChatGLM|✅|❌|❌|❌|❌|❌
+Clarifai|✅|❌|❌|❌|❌|❌
+Cohere|✅|✅|❌|❌|❌|❌
+Databricks|✅|❌|❌|❌|❌|❌
+DeepInfra|✅|❌|❌|❌|❌|❌
+DeepSparse|✅|❌|❌|❌|❌|❌
+EdenAI|✅|✅|❌|❌|❌|❌
+Fireworks|✅|✅|❌|❌|✅|✅
+FireworksChat|✅|✅|❌|❌|✅|✅
+ForefrontAI|✅|❌|❌|❌|❌|❌
+GPT4All|✅|❌|❌|❌|❌|❌
+GooglePalm|✅|❌|❌|❌|✅|❌
+GooseAI|✅|❌|❌|❌|❌|❌
+GradientLLM|✅|✅|❌|❌|❌|❌
+HuggingFaceEndpoint|✅|❌|❌|❌|❌|❌
+HuggingFaceHub|✅|❌|❌|❌|❌|❌
+HuggingFacePipeline|✅|❌|❌|❌|❌|❌
+HuggingFaceTextGenInference|✅|✅|✅|✅|❌|❌
+HumanInputLLM|✅|❌|❌|❌|❌|❌
+JavelinAIGateway|✅|✅|❌|❌|❌|❌
+KoboldApiLLM|✅|❌|❌|❌|❌|❌
+LlamaCpp|✅|❌|✅|❌|❌|❌
+ManifestWrapper|✅|❌|❌|❌|❌|❌
+Minimax|✅|❌|❌|❌|❌|❌
+MlflowAIGateway|✅|❌|❌|❌|❌|❌
+Modal|✅|❌|❌|❌|❌|❌
+MosaicML|✅|❌|❌|❌|❌|❌
+NIBittensorLLM|✅|❌|❌|❌|❌|❌
+NLPCloud|✅|❌|❌|❌|❌|❌
+Nebula|✅|❌|❌|❌|❌|❌
+OctoAIEndpoint|✅|❌|❌|❌|❌|❌
+Ollama|✅|❌|❌|❌|❌|❌
+OpaquePrompts|✅|❌|❌|❌|❌|❌
+OpenAI|✅|✅|✅|✅|✅|✅
+OpenLLM|✅|✅|❌|❌|❌|❌
+OpenLM|✅|✅|✅|✅|✅|✅
+Petals|✅|❌|❌|❌|❌|❌
+PipelineAI|✅|❌|❌|❌|❌|❌
+Predibase|✅|❌|❌|❌|❌|❌
+PredictionGuard|✅|❌|❌|❌|❌|❌
+PromptLayerOpenAI|✅|❌|❌|❌|❌|❌
+QianfanLLMEndpoint|✅|✅|✅|✅|❌|❌
+RWKV|✅|❌|❌|❌|❌|❌
+Replicate|✅|❌|✅|❌|❌|❌
+SagemakerEndpoint|✅|❌|❌|❌|❌|❌
+SelfHostedHuggingFaceLLM|✅|❌|❌|❌|❌|❌
+SelfHostedPipeline|✅|❌|❌|❌|❌|❌
+StochasticAI|✅|❌|❌|❌|❌|❌
+TextGen|✅|❌|❌|❌|❌|❌
+TitanTakeoff|✅|❌|✅|❌|❌|❌
+Tongyi|✅|❌|❌|❌|❌|❌
+VLLM|✅|❌|❌|❌|✅|❌
+VLLMOpenAI|✅|✅|✅|✅|✅|✅
+VertexAI|✅|✅|✅|❌|✅|✅
+VertexAIModelGarden|✅|✅|❌|❌|✅|✅
+Writer|✅|❌|❌|❌|❌|❌
+Xinference|✅|❌|❌|❌|❌|❌
+
+<DocCardList />

docs/extras/integrations/llms/javelin.ipynb

@@ -0,0 +1,242 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "62bacc68-1976-44eb-9316-d5baf54bf595",
+   "metadata": {},
+   "source": [
+    "# Javelin AI Gateway Tutorial\n",
+    "\n",
+    "This Jupyter Notebook will explore how to interact with the Javelin AI Gateway using the Python SDK. \n",
+    "The Javelin AI Gateway facilitates the utilization of large language models (LLMs) like OpenAI, Cohere, Anthropic, and others by \n",
+    "providing a secure and unified endpoint. The gateway itself provides a centralized mechanism to roll out models systematically, \n",
+    "provide access security, policy & cost guardrails for enterprises, etc., \n",
+    "\n",
+    "For a complete listing of all the features & benefits of Javelin, please visit www.getjavelin.io\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e52185f8-132b-4585-b73d-6fee928ac199",
+   "metadata": {},
+   "source": [
+    "## Step 1: Introduction\n",
+    "[The Javelin AI Gateway](https://www.getjavelin.io) is an enterprise-grade API Gateway for AI applications. It integrates robust access security, ensuring secure interactions with large language models. Learn more in the [official documentation](https://docs.getjavelin.io).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e2acdb3-e3b8-422b-b077-7a0d63d18349",
+   "metadata": {},
+   "source": [
+    "## Step 2: Installation\n",
+    "Before we begin, we must install the `javelin_sdk` and set up the Javelin API key as an environment variable. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e91518a4-43ce-443e-b4c0-dbc652eb749f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: javelin_sdk in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (0.1.8)\n",
+      "Requirement already satisfied: httpx<0.25.0,>=0.24.0 in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from javelin_sdk) (0.24.1)\n",
+      "Requirement already satisfied: pydantic<2.0.0,>=1.10.7 in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from javelin_sdk) (1.10.12)\n",
+      "Requirement already satisfied: certifi in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from httpx<0.25.0,>=0.24.0->javelin_sdk) (2023.5.7)\n",
+      "Requirement already satisfied: httpcore<0.18.0,>=0.15.0 in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from httpx<0.25.0,>=0.24.0->javelin_sdk) (0.17.3)\n",
+      "Requirement already satisfied: idna in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from httpx<0.25.0,>=0.24.0->javelin_sdk) (3.4)\n",
+      "Requirement already satisfied: sniffio in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from httpx<0.25.0,>=0.24.0->javelin_sdk) (1.3.0)\n",
+      "Requirement already satisfied: typing-extensions>=4.2.0 in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from pydantic<2.0.0,>=1.10.7->javelin_sdk) (4.7.1)\n",
+      "Requirement already satisfied: h11<0.15,>=0.13 in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from httpcore<0.18.0,>=0.15.0->httpx<0.25.0,>=0.24.0->javelin_sdk) (0.14.0)\n",
+      "Requirement already satisfied: anyio<5.0,>=3.0 in /usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages (from httpcore<0.18.0,>=0.15.0->httpx<0.25.0,>=0.24.0->javelin_sdk) (3.7.1)\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "pip install 'javelin_sdk'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53b546dc-9ca3-4602-9a7b-d733d99e8e2f",
+   "metadata": {},
+   "source": [
+    "## Step 3: Completions Example\n",
+    "This section will demonstrate how to interact with the Javelin AI Gateway to get completions from a large language model. Here is a Python script that demonstrates this:\n",
+    "(note) assumes that you have setup a route in the gateway called 'eng_dept03'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d36949f0-5354-44ca-9a31-70c769344319",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'JavelinAIGateway' from 'langchain.llms' (/usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages/langchain/llms/__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[6], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mlangchain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mchains\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m LLMChain\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mlangchain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mllms\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m JavelinAIGateway\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mlangchain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mprompts\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m PromptTemplate\n\u001b[1;32m      5\u001b[0m route_completions \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124meng_dept03\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
+      "\u001b[0;31mImportError\u001b[0m: cannot import name 'JavelinAIGateway' from 'langchain.llms' (/usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages/langchain/llms/__init__.py)"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chains import LLMChain\n",
+    "from langchain.llms import JavelinAIGateway\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "\n",
+    "route_completions = \"eng_dept03\"\n",
+    "\n",
+    "gateway = JavelinAIGateway(\n",
+    "    gateway_uri=\"http://localhost:8000\", # replace with service URL or host/port of Javelin\n",
+    "    route=route_completions,\n",
+    "    model_name=\"text-davinci-003\",\n",
+    ")\n",
+    "\n",
+    "prompt = PromptTemplate(\"Translate the following English text to French: {text}\")\n",
+    "\n",
+    "llmchain = LLMChain(llm=gateway, prompt=prompt)\n",
+    "result = llmchain.run(\"podcast player\")\n",
+    "\n",
+    "print(result)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b63fe93-2e77-4ea9-b8e7-dec2b96b8e95",
+   "metadata": {},
+   "source": [
+    "# Step 4: Embeddings Example\n",
+    "This section demonstrates how to use the Javelin AI Gateway to obtain embeddings for text queries and documents. Here is a Python script that illustrates this:\n",
+    "(note) assumes that you have setup a route in the gateway called 'embeddings'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "878e6c1d-be7f-49de-825c-43c266c8714e",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'JavelinAIGatewayEmbeddings' from 'langchain.embeddings' (/usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages/langchain/embeddings/__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[9], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mlangchain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01membeddings\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m JavelinAIGatewayEmbeddings\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mlangchain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01membeddings\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mopenai\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m OpenAIEmbeddings\n\u001b[1;32m      4\u001b[0m embeddings \u001b[38;5;241m=\u001b[39m JavelinAIGatewayEmbeddings(\n\u001b[1;32m      5\u001b[0m     gateway_uri\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhttp://localhost:8000\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;66;03m# replace with service URL or host/port of Javelin\u001b[39;00m\n\u001b[1;32m      6\u001b[0m     route\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124membeddings\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m      7\u001b[0m )\n",
+      "\u001b[0;31mImportError\u001b[0m: cannot import name 'JavelinAIGatewayEmbeddings' from 'langchain.embeddings' (/usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages/langchain/embeddings/__init__.py)"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.embeddings import JavelinAIGatewayEmbeddings\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "\n",
+    "embeddings = JavelinAIGatewayEmbeddings(\n",
+    "    gateway_uri=\"http://localhost:8000\", # replace with service URL or host/port of Javelin\n",
+    "    route=\"embeddings\",\n",
+    ")\n",
+    "\n",
+    "print(embeddings.embed_query(\"hello\"))\n",
+    "print(embeddings.embed_documents([\"hello\"]))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "07c6691b-d333-4598-b2b7-c0933ed75937",
+   "metadata": {},
+   "source": [
+    "# Step 5: Chat Example\n",
+    "This section illustrates how to interact with the Javelin AI Gateway to facilitate a chat with a large language model. Here is a Python script that demonstrates this:\n",
+    "(note) assumes that you have setup a route in the gateway called 'mychatbot_route'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "653ef88c-36cd-4730-9c12-43c246b551f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'ChatJavelinAIGateway' from 'langchain.chat_models' (/usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages/langchain/chat_models/__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mlangchain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mchat_models\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m ChatJavelinAIGateway\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mlangchain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mschema\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m HumanMessage, SystemMessage\n\u001b[1;32m      4\u001b[0m messages \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m      5\u001b[0m     SystemMessage(\n\u001b[1;32m      6\u001b[0m         content\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mYou are a helpful assistant that translates English to French.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     10\u001b[0m     ),\n\u001b[1;32m     11\u001b[0m ]\n",
+      "\u001b[0;31mImportError\u001b[0m: cannot import name 'ChatJavelinAIGateway' from 'langchain.chat_models' (/usr/local/Caskroom/miniconda/base/lib/python3.11/site-packages/langchain/chat_models/__init__.py)"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatJavelinAIGateway\n",
+    "from langchain.schema import HumanMessage, SystemMessage\n",
+    "\n",
+    "messages = [\n",
+    "    SystemMessage(\n",
+    "        content=\"You are a helpful assistant that translates English to French.\"\n",
+    "    ),\n",
+    "    HumanMessage(\n",
+    "        content=\"Artificial Intelligence has the power to transform humanity and make the world a better place\"\n",
+    "    ),\n",
+    "]\n",
+    "\n",
+    "chat = ChatJavelinAIGateway(\n",
+    "    gateway_uri=\"http://localhost:8000\", # replace with service URL or host/port of Javelin\n",
+    "    route=\"mychatbot_route\",\n",
+    "    model_name=\"gpt-3.5-turbo\",\n",
+    "    params={\n",
+    "        \"temperature\": 0.1\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "print(chat(messages))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6eb9cf33-6505-4e05-808b-645856463a8e",
+   "metadata": {},
+   "source": [
+    "Step 6: Conclusion\n",
+    "This tutorial introduced the Javelin AI Gateway and demonstrated how to interact with it using the Python SDK. \n",
+    "Remember to check the Javelin [Python SDK](https://www.github.com/getjavelin.io/javelin-python) for more examples and to explore the official documentation for additional details.\n",
+    "\n",
+    "Happy coding!"
+   ]
+  }
+ ],
+ "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/integrations/llms/llm_caching.ipynb

@@ -95,7 +95,7 @@
     {
      "data": {
       "text/plain": [
-       "'\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side.'"
+       "\"\\n\\nWhy couldn't the bicycle stand up by itself? It was...two tired!\""
       ]
      },
      "execution_count": 7,
@@ -811,6 +811,228 @@
     "langchain.llm_cache = SQLAlchemyCache(engine, FulltextLLMCache)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "eeba7d60",
+   "metadata": {},
+   "source": [
+    "## `Cassandra` caches\n",
+    "\n",
+    "You can use Cassandra / Astra DB for caching LLM responses, choosing from the exact-match `CassandraCache` or the (vector-similarity-based) `CassandraSemanticCache`.\n",
+    "\n",
+    "Let's see both in action in the following cells."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4a6725d",
+   "metadata": {},
+   "source": [
+    "#### Connect to the DB\n",
+    "\n",
+    "First you need to establish a `Session` to the DB and to specify a _keyspace_ for the cache table(s). The following gets you started with an Astra DB instance (see e.g. [here](https://cassio.org/start_here/#vector-database) for more backends and connection options)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "cc53ce1b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Keyspace name? my_keyspace\n",
+      "\n",
+      "Astra DB Token (\"AstraCS:...\") ········\n",
+      "Full path to your Secure Connect Bundle? /path/to/secure-connect-databasename.zip\n"
+     ]
+    }
+   ],
+   "source": [
+    "import getpass\n",
+    "\n",
+    "keyspace = input(\"\\nKeyspace name? \")\n",
+    "ASTRA_DB_APPLICATION_TOKEN = getpass.getpass('\\nAstra DB Token (\"AstraCS:...\") ')\n",
+    "ASTRA_DB_SECURE_BUNDLE_PATH = input(\"Full path to your Secure Connect Bundle? \")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4617f485",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cassandra.cluster import Cluster\n",
+    "from cassandra.auth import PlainTextAuthProvider\n",
+    "\n",
+    "cluster = Cluster(\n",
+    "    cloud={\n",
+    "        \"secure_connect_bundle\": ASTRA_DB_SECURE_BUNDLE_PATH,\n",
+    "    },\n",
+    "    auth_provider=PlainTextAuthProvider(\"token\", ASTRA_DB_APPLICATION_TOKEN),\n",
+    ")\n",
+    "session = cluster.connect()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8665664a",
+   "metadata": {},
+   "source": [
+    "### Exact cache\n",
+    "\n",
+    "This will avoid invoking the LLM when the supplied prompt is _exactly_ the same as one encountered already:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "00a5e66f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import langchain\n",
+    "from langchain.cache import CassandraCache\n",
+    "\n",
+    "langchain.llm_cache = CassandraCache(session=session, keyspace=keyspace)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "956a5145",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "The Moon always shows the same side because it is tidally locked to Earth.\n",
+      "CPU times: user 41.7 ms, sys: 153 µs, total: 41.8 ms\n",
+      "Wall time: 1.96 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\n",
+    "print(llm(\"Why is the Moon always showing the same side?\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "158f0151",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "The Moon always shows the same side because it is tidally locked to Earth.\n",
+      "CPU times: user 4.09 ms, sys: 0 ns, total: 4.09 ms\n",
+      "Wall time: 119 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\n",
+    "print(llm(\"Why is the Moon always showing the same side?\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fc4d017",
+   "metadata": {},
+   "source": [
+    "### Semantic cache\n",
+    "\n",
+    "This cache will do a semantic similarity search and return a hit if it finds a cached entry that is similar enough, For this, you need to provide an `Embeddings` instance of your choice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b9ad3f54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "\n",
+    "embedding=OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "4623f95e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.cache import CassandraSemanticCache\n",
+    "\n",
+    "langchain.llm_cache = CassandraSemanticCache(\n",
+    "    session=session, keyspace=keyspace, embedding=embedding, table_name=\"cass_sem_cache\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "1a8e577b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "The Moon always shows the same side because it is tidally locked with Earth. This means that the same side of the Moon always faces Earth.\n",
+      "CPU times: user 21.3 ms, sys: 177 µs, total: 21.4 ms\n",
+      "Wall time: 3.09 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\n",
+    "print(llm(\"Why is the Moon always showing the same side?\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "f7abddfd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "The Moon always shows the same side because it is tidally locked with Earth. This means that the same side of the Moon always faces Earth.\n",
+      "CPU times: user 10.9 ms, sys: 17 µs, total: 10.9 ms\n",
+      "Wall time: 461 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\n",
+    "print(llm(\"How come we always see one face of the moon?\"))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "0c69d84d",

docs/extras/integrations/llms/minimax.ipynb

@@ -94,7 +94,8 @@
    "outputs": [],
    "source": [
     "from langchain.llms import Minimax\n",
-    "from langchain.prompts import PromptTemplate\nfrom langchain.chains import LLMChain"
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.chains import LLMChain"
    ],
    "metadata": {
     "collapsed": false

docs/extras/integrations/llms/modal.ipynb

@@ -108,7 +108,8 @@
    "outputs": [],
    "source": [
     "from langchain.llms import Modal\n",
-    "from langchain.prompts import PromptTemplate\nfrom langchain.chains import LLMChain"
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.chains import LLMChain"
    ]
   },
   {

docs/extras/integrations/platforms/google.mdx

@@ -2,6 +2,35 @@
 
 All functionality related to Google Platform
 
+## LLMs
+
+### Vertex AI
+
+Access PaLM LLMs like `text-bison` and `code-bison` via Google Cloud.
+
+```python
+from langchain.llms import VertexAI
+```
+
+### Model Garden
+
+Access PaLM and hundreds of OSS models via Vertex AI Model Garden.
+
+```python
+from langchain.llms import VertexAIModelGarden
+```
+
+## Chat models
+
+### Vertex AI
+
+Access PaLM chat models like `chat-bison` and `codechat-bison` via Google Cloud.
+
+```python
+from langchain.chat_models import ChatVertexAI
+```
+
+
 ## Document Loader
 ### Google BigQuery
 

docs/extras/integrations/providers/databricks.md

@@ -13,12 +13,13 @@ Databricks embraces the LangChain ecosystem in various ways:
 
 Databricks connector for the SQLDatabase Chain
 ----------------------------------------------
-You can connect to [Databricks runtimes](https://docs.databricks.com/runtime/index.html) and [Databricks SQL](https://www.databricks.com/product/databricks-sql) using the SQLDatabase wrapper of LangChain. See the notebook [Connect to Databricks](/docs/ecosystem/integrations/databricks/databricks.html) for details.
+You can connect to [Databricks runtimes](https://docs.databricks.com/runtime/index.html) and [Databricks SQL](https://www.databricks.com/product/databricks-sql) using the SQLDatabase wrapper of LangChain. 
+See the notebook [Connect to Databricks](/docs/use_cases/qa_structured/integrations/databricks) for details.
 
 Databricks MLflow integrates with LangChain
 -------------------------------------------
 
-MLflow is an open source platform to manage the ML lifecycle, including experimentation, reproducibility, deployment, and a central model registry. See the notebook [MLflow Callback Handler](/docs/ecosystem/integrations/mlflow_tracking.ipynb) for details about MLflow's integration with LangChain.
+MLflow is an open source platform to manage the ML lifecycle, including experimentation, reproducibility, deployment, and a central model registry. See the notebook [MLflow Callback Handler](/docs/integrations/providers/mlflow_tracking) for details about MLflow's integration with LangChain.
 
 Databricks provides a fully managed and hosted version of MLflow integrated with enterprise security features, high availability, and other Databricks workspace features such as experiment and run management and notebook revision capture. MLflow on Databricks offers an integrated experience for tracking and securing machine learning model training runs and running machine learning projects. See [MLflow guide](https://docs.databricks.com/mlflow/index.html) for more details.
 
@@ -27,7 +28,7 @@ Databricks MLflow makes it more convenient to develop LangChain applications on
 Databricks MLflow AI Gateway
 ----------------------------
 
-See [MLflow AI Gateway](/docs/ecosystem/integrations/mlflow_ai_gateway).
+See [MLflow AI Gateway](/docs/integrations/providers/mlflow_ai_gateway).
 
 Databricks as an LLM provider
 -----------------------------

docs/extras/integrations/providers/javelin_ai_gateway.mdx

@@ -0,0 +1,92 @@
+# Javelin AI Gateway
+
+[The Javelin AI Gateway](https://www.getjavelin.io) service is a high-performance, enterprise grade API Gateway for AI applications.  
+It is designed to streamline the usage and access of various large language model (LLM) providers, 
+such as OpenAI, Cohere, Anthropic and custom large language models within an organization by incorporating
+robust access security for all interactions with LLMs. 
+
+Javelin offers a high-level interface that simplifies the interaction with LLMs by providing a unified endpoint 
+to handle specific LLM related requests. 
+
+See the Javelin AI Gateway [documentation](https://docs.getjavelin.io) for more details.  
+[Javelin Python SDK](https://www.github.com/getjavelin/javelin-python) is an easy to use client library meant to be embedded into AI Applications
+
+## Installation and Setup
+
+Install `javelin_sdk` to interact with Javelin AI Gateway:
+
+```sh
+pip install 'javelin_sdk'
+```
+
+Set the Javelin's API key as an environment variable:
+
+```sh
+export JAVELIN_API_KEY=...
+```
+
+## Completions Example
+
+```python
+
+from langchain.chains import LLMChain
+from langchain.llms import JavelinAIGateway
+from langchain.prompts import PromptTemplate
+
+route_completions = "eng_dept03"
+
+gateway = JavelinAIGateway(
+    gateway_uri="http://localhost:8000",
+    route=route_completions,
+    model_name="text-davinci-003",
+)
+
+llmchain = LLMChain(llm=gateway, prompt=prompt)
+result = llmchain.run("podcast player")
+
+print(result)
+
+```
+
+## Embeddings Example
+
+```python
+from langchain.embeddings import JavelinAIGatewayEmbeddings
+from langchain.embeddings.openai import OpenAIEmbeddings
+
+embeddings = JavelinAIGatewayEmbeddings(
+    gateway_uri="http://localhost:8000",
+    route="embeddings",
+)
+
+print(embeddings.embed_query("hello"))
+print(embeddings.embed_documents(["hello"]))
+```
+
+## Chat Example
+```python
+from langchain.chat_models import ChatJavelinAIGateway
+from langchain.schema import HumanMessage, SystemMessage
+
+messages = [
+    SystemMessage(
+        content="You are a helpful assistant that translates English to French."
+    ),
+    HumanMessage(
+        content="Artificial Intelligence has the power to transform humanity and make the world a better place"
+    ),
+]
+
+chat = ChatJavelinAIGateway(
+    gateway_uri="http://localhost:8000",
+    route="mychatbot_route",
+    model_name="gpt-3.5-turbo"
+    params={
+        "temperature": 0.1
+    }
+)
+
+print(chat(messages))
+
+```
+

docs/extras/integrations/providers/minimax.mdx

@@ -17,6 +17,14 @@ See a [usage example](/docs/modules/model_io/models/llms/integrations/minimax.ht
 from langchain.llms import Minimax
 ```
 
+## Chat Models
+
+See a [usage example](/docs/modules/model_io/models/chat/integrations/minimax.html)
+
+```python
+from langchain.chat_models import MiniMaxChat
+```
+
 ## Text Embedding Model
 
 There exists a Minimax Embedding model, which you can access with

docs/extras/integrations/providers/promptlayer.mdx

@@ -19,13 +19,13 @@ There exists an PromptLayer OpenAI LLM wrapper, which you can access with
 from langchain.llms import PromptLayerOpenAI
 ```
 
-To tag your requests, use the argument `pl_tags` when instanializing the LLM
+To tag your requests, use the argument `pl_tags` when initializing the LLM
 ```python
 from langchain.llms import PromptLayerOpenAI
 llm = PromptLayerOpenAI(pl_tags=["langchain-requests", "chatbot"])
 ```
 
-To get the PromptLayer request id, use the argument `return_pl_id` when instanializing the LLM
+To get the PromptLayer request id, use the argument `return_pl_id` when initializing the LLM
 ```python
 from langchain.llms import PromptLayerOpenAI
 llm = PromptLayerOpenAI(return_pl_id=True)
@@ -42,7 +42,7 @@ You can use the PromptLayer request ID to add a prompt, score, or other metadata
 
 This LLM is identical to the [OpenAI](/docs/ecosystem/integrations/openai.html) LLM, except that
 - all your requests will be logged to your PromptLayer account
-- you can add `pl_tags` when instantializing to tag your requests on PromptLayer
+- you can add `pl_tags` when instantiating to tag your requests on PromptLayer
 - you can add `return_pl_id` when instantializing to return a PromptLayer request id to use [while tracking requests](https://magniv.notion.site/Track-4deee1b1f7a34c1680d085f82567dab9).
 
 

docs/extras/integrations/text_embedding/baidu_qianfan_endpoint.ipynb

@@ -34,26 +34,47 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:01:35] logging.py:55 [t:140292313159488]: trying to refresh access_token\n",
+      "[INFO] [09-15 20:01:35] logging.py:55 [t:140292313159488]: sucessfully refresh access_token\n",
+      "[INFO] [09-15 20:01:35] logging.py:55 [t:140292313159488]: requesting llm api endpoint: /embeddings/embedding-v1\n",
+      "[INFO] [09-15 20:01:35] logging.py:55 [t:140292313159488]: async requesting llm api endpoint: /embeddings/embedding-v1\n",
+      "[INFO] [09-15 20:01:35] logging.py:55 [t:140292313159488]: async requesting llm api endpoint: /embeddings/embedding-v1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-0.03313107788562775, 0.052325375378131866, 0.04951248690485954, 0.0077608139254152775, -0.05907672271132469, -0.010798933915793896, 0.03741293027997017, 0.013969100080430508]\n",
+      " [0.0427522286772728, -0.030367236584424973, -0.14847028255462646, 0.055074431002140045, -0.04177454113960266, -0.059512972831726074, -0.043774791061878204, 0.0028191760648041964]\n",
+      " [0.03803155943751335, -0.013231384567916393, 0.0032379645854234695, 0.015074018388986588, -0.006529552862048149, -0.13813287019729614, 0.03297128155827522, 0.044519297778606415]\n"
+     ]
+    }
+   ],
    "source": [
     "\"\"\"For basic init and call\"\"\"\n",
-    "from langchain.embeddings.baidu_qianfan_endpoint import QianfanEmbeddingsEndpoint \n",
+    "from langchain.embeddings import QianfanEmbeddingsEndpoint \n",
     "\n",
     "import os\n",
-    "os.environ[\"QIANFAN_AK\"] = \"xx\"\n",
-    "os.environ[\"QIANFAN_SK\"] = \"xx\"\n",
+    "os.environ[\"QIANFAN_AK\"] = \"your_ak\"\n",
+    "os.environ[\"QIANFAN_SK\"] = \"your_sk\"\n",
     "\n",
-    "embed = QianfanEmbeddingsEndpoint(qianfan_ak='xxx', \n",
-    "                            qianfan_sk='xxx')\n",
+    "embed = QianfanEmbeddingsEndpoint(\n",
+    "    # qianfan_ak='xxx', \n",
+    "    # qianfan_sk='xxx'\n",
+    ")\n",
     "res = embed.embed_documents([\"hi\", \"world\"])\n",
     "\n",
-    "import asyncio\n",
-    "\n",
     "async def aioEmbed():\n",
     "    res = await embed.aembed_query(\"qianfan\")\n",
-    "    print(res)\n",
+    "    print(res[:8])\n",
     "await aioEmbed()\n",
     "\n",
     "import asyncio\n",
@@ -81,16 +102,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[INFO] [09-15 20:01:40] logging.py:55 [t:140292313159488]: requesting llm api endpoint: /embeddings/bge_large_zh\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-0.0001582596160005778, -0.025089964270591736, -0.03997539356350899, 0.013156415894627571, 0.000135212714667432, 0.012428865768015385, 0.016216561198234558, -0.04126659780740738]\n",
+      "[0.0019113451708108187, -0.008625439368188381, -0.0531032420694828, -0.0018436014652252197, -0.01818147301673889, 0.010310115292668343, -0.008867680095136166, -0.021067561581730843]\n"
+     ]
+    }
+   ],
    "source": [
-    "embed = QianfanEmbeddingsEndpoint(qianfan_ak='xxx', \n",
-    "                            qianfan_sk='xxx',\n",
+    "embed = QianfanEmbeddingsEndpoint(\n",
     "                            model=\"bge_large_zh\",\n",
-    "                            endpoint=\"bge_large_zh\")\n",
+    "                            endpoint=\"bge_large_zh\"\n",
+    "                            )\n",
     "\n",
-    "res = embed.embed_documents([\"hi\", \"world\"])"
+    "res = embed.embed_documents([\"hi\", \"world\"])\n",
+    "for r in res :\n",
+    "    print(r[:8])"
    ]
   }
  ],

docs/extras/integrations/vectorstores/llm_rails.ipynb

@@ -0,0 +1,328 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "683953b3",
+   "metadata": {},
+   "source": [
+    "# LLMRails\n",
+    "\n",
+    ">[LLMRails](https://www.llmrails.com/) is a API platform for building GenAI applications. It provides an easy-to-use API for document indexing and querying that is managed by LLMRails and is optimized for performance and accuracy. \n",
+    "See the [LLMRails API documentation ](https://docs.llmrails.com/) for more information on how to use the API.\n",
+    "\n",
+    "This notebook shows how to use functionality related to the `LLMRails`'s integration with langchain.\n",
+    "Note that unlike many other integrations in this category, LLMRails provides an end-to-end managed service for retrieval agumented generation, which includes:\n",
+    "1. A way to extract text from document files and chunk them into sentences.\n",
+    "2. Its own embeddings model and vector store - each text segment is encoded into a vector embedding and stored in the LLMRails internal vector store\n",
+    "3. A query service that automatically encodes the query into embedding, and retrieves the most relevant text segments (including support for [Hybrid Search](https://docs.llmrails.com/datastores/search))\n",
+    "\n",
+    "All of these are supported in this LangChain integration."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc0f4344",
+   "metadata": {},
+   "source": [
+    "# Setup\n",
+    "\n",
+    "You will need a LLMRails account to use LLMRails with LangChain. To get started, use the following steps:\n",
+    "1. [Sign up](https://console.llmrails.com/signup) for a LLMRails account if you don't already have one.\n",
+    "2. Next you'll need to create API keys to access the API. Click on the **\"API Keys\"** tab in the corpus view and then the **\"Create API Key\"** button. Give your key a name. Click \"Create key\" and you now have an active API key. Keep this key confidential. \n",
+    "\n",
+    "To use LangChain with LLMRails, you'll need to have this value: api_key.\n",
+    "You can provide those to LangChain in two ways:\n",
+    "\n",
+    "1. Include in your environment these two variables: `LLM_RAILS_API_KEY`, `LLM_RAILS_DATASTORE_ID`.\n",
+    "\n",
+    "> For example, you can set these variables using os.environ and getpass as follows:\n",
+    "\n",
+    "```python\n",
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "os.environ[\"LLM_RAILS_API_KEY\"] = getpass.getpass(\"LLMRails API Key:\")\n",
+    "os.environ[\"LLM_RAILS_DATASTORE_ID\"] = getpass.getpass(\"LLMRails Datastore Id:\")\n",
+    "```\n",
+    "\n",
+    "1. Provide them as arguments when creating the LLMRails vectorstore object:\n",
+    "\n",
+    "```python\n",
+    "vectorstore = LLMRails(\n",
+    "    api_key=llm_rails_api_key,\n",
+    "    datastore_id=datastore_id\n",
+    ")\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d93c4fcd",
+   "metadata": {},
+   "source": [
+    "## Adding text\n",
+    "\n",
+    "For adding text to your datastore first you have to go to [Datastores](https://console.llmrails.com/datastores) page and create one. Click Create Datastore button and choose a name and embedding model for your datastore. Then get your datastore id from newly created  datatore settings.\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "920f4644",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.vectorstores import LLMRails\n",
+    "import os\n",
+    "\n",
+    "os.environ['LLM_RAILS_DATASTORE_ID'] = 'Your datastore id '\n",
+    "os.environ['LLM_RAILS_API_KEY'] = 'Your API Key'\n",
+    "\n",
+    "llm_rails = LLMRails.from_texts(['Your text here'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f9215c8",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-04T09:27:29.920258Z",
+     "start_time": "2023-04-04T09:27:29.913714Z"
+    }
+   },
+   "source": [
+    "## Similarity search\n",
+    "\n",
+    "The simplest scenario for using LLMRails is to perform a similarity search. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a8c513ab",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-04T10:51:25.204469Z",
+     "start_time": "2023-04-04T10:51:24.855618Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "query = \"What do you plan to do about national security?\"\n",
+    "found_docs = llm_rails.similarity_search(\n",
+    "    query, k=5\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fc516993",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-04T10:51:25.220984Z",
+     "start_time": "2023-04-04T10:51:25.213943Z"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Others may not be democratic but nevertheless depend upon a rules-based international system.\n",
+      "\n",
+      "Yet what we share in common, and the prospect of a freer and more open world, makes such a broad coalition necessary and worthwhile.\n",
+      "\n",
+      "We will listen to and consider ideas that our partners suggest about how to do this.\n",
+      "\n",
+      "Building this inclusive coalition requires reinforcing the multilateral system to uphold the founding principles of the United Nations, including respect for international law.\n",
+      "\n",
+      "141 countries expressed support at the United Nations General Assembly for a resolution condemning Russia’s unprovoked aggression against Ukraine.\n",
+      "\n",
+      "We continue to demonstrate this approach by engaging all regions across all issues, not in terms of what we are against but what we are for.\n",
+      "\n",
+      "This year, we partnered with ASEAN to advance clean energy infrastructure and maritime security in the region.\n",
+      "\n",
+      "We kickstarted the Prosper Africa Build Together Campaign to fuel economic growth across the continent and bolster trade and investment in the clean energy, health, and digital technology sectors.\n",
+      "\n",
+      "We are working to develop a partnership with countries on the Atlantic Ocean to establish and carry out a shared approach to advancing our joint development, economic, environmental, scientific, and maritime governance goals.\n",
+      "\n",
+      "We galvanized regional action to address the core challenges facing the Western Hemisphere by spearheading the Americas Partnership for Economic Prosperity to drive economic recovery and by mobilizing the region behind a bold and unprecedented approach to migration through the Los Angeles Declaration on Migration and Protection.\n",
+      "\n",
+      "In the Middle East, we have worked to enhance deterrence toward Iran, de-escalate regional conflicts, deepen integration among a diverse set of partners in the region, and bolster energy stability.\n",
+      "\n",
+      "A prime example of an inclusive coalition is IPEF, which we launched alongside a dozen regional partners that represent 40 percent of the world’s GDP.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(found_docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1bda9bf5",
+   "metadata": {},
+   "source": [
+    "## Similarity search with score\n",
+    "\n",
+    "Sometimes we might want to perform the search, but also obtain a relevancy score to know how good is a particular result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8804a21d",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-04T10:51:25.631585Z",
+     "start_time": "2023-04-04T10:51:25.227384Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "query = \"What is your approach to national defense\"\n",
+    "found_docs = llm_rails.similarity_search_with_score(\n",
+    "    query, k=5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "756a6887",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-04T10:51:25.642282Z",
+     "start_time": "2023-04-04T10:51:25.635947Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "But we will do so as the last resort and only when the objectives and mission are clear and achievable, consistent with our values and laws, alongside non-military tools, and the mission is undertaken with the informed consent of the American people.\n",
+      "\n",
+      "Our approach to national defense is described in detail in the 2022 National Defense Strategy.\n",
+      "\n",
+      "Our starting premise is that a powerful U.S. military helps advance and safeguard vital U.S. national interests by backstopping diplomacy, confronting aggression, deterring conflict, projecting strength, and protecting the American people and their economic interests.\n",
+      "\n",
+      "Amid intensifying competition, the military’s role is to maintain and gain warfighting advantages while limiting those of our competitors.\n",
+      "\n",
+      "The military will act urgently to sustain and strengthen deterrence, with the PRC as its pacing challenge.\n",
+      "\n",
+      "We will make disciplined choices regarding our national defense and focus our attention on the military’s primary responsibilities: to defend the homeland, and deter attacks and aggression against the United States, our allies and partners, while being prepared to fight and win the Nation’s wars should diplomacy and deterrence fail.\n",
+      "\n",
+      "To do so, we will combine our strengths to achieve maximum effect in deterring acts of aggression—an approach we refer to as integrated deterrence (see text box on page 22).\n",
+      "\n",
+      "We will operate our military using a campaigning mindset—sequencing logically linked military activities to advance strategy-aligned priorities.\n",
+      "\n",
+      "And, we will build a resilient force and defense ecosystem to ensure we can perform these functions for decades to come.\n",
+      "\n",
+      "We ended America’s longest war in Afghanistan, and with it an era of major military operations to remake other societies, even as we have maintained the capacity to address terrorist threats to the American people as they emerge.\n",
+      "\n",
+      "20  NATIONAL SECURITY STRATEGY Page 21 \n",
+      "\n",
+      "A combat-credible military is the foundation of deterrence and America’s ability to prevail in conflict.\n",
+      "\n",
+      "Score: 0.5040982687179959\n"
+     ]
+    }
+   ],
+   "source": [
+    "document, score = found_docs[0]\n",
+    "print(document.page_content)\n",
+    "print(f\"\\nScore: {score}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "691a82d6",
+   "metadata": {},
+   "source": [
+    "## LLMRails as a Retriever\n",
+    "\n",
+    "LLMRails, as all the other LangChain vectorstores, is most often used as a LangChain Retriever:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9427195f",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-04T10:51:26.031451Z",
+     "start_time": "2023-04-04T10:51:26.018763Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LLMRailsRetriever(tags=None, metadata=None, vectorstore=<langchain.vectorstores.llm_rails.LLMRails object at 0x107b9c040>, search_type='similarity', search_kwargs={'k': 5})"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "retriever = llm_rails.as_retriever()\n",
+    "retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "f3c70c31",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-04T10:51:26.495652Z",
+     "start_time": "2023-04-04T10:51:26.046407Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Document(page_content='But we will do so as the last resort and only when the objectives and mission are clear and achievable, consistent with our values and laws, alongside non-military tools, and the mission is undertaken with the informed consent of the American people.\\n\\nOur approach to national defense is described in detail in the 2022 National Defense Strategy.\\n\\nOur starting premise is that a powerful U.S. military helps advance and safeguard vital U.S. national interests by backstopping diplomacy, confronting aggression, deterring conflict, projecting strength, and protecting the American people and their economic interests.\\n\\nAmid intensifying competition, the military’s role is to maintain and gain warfighting advantages while limiting those of our competitors.\\n\\nThe military will act urgently to sustain and strengthen deterrence, with the PRC as its pacing challenge.\\n\\nWe will make disciplined choices regarding our national defense and focus our attention on the military’s primary responsibilities: to defend the homeland, and deter attacks and aggression against the United States, our allies and partners, while being prepared to fight and win the Nation’s wars should diplomacy and deterrence fail.\\n\\nTo do so, we will combine our strengths to achieve maximum effect in deterring acts of aggression—an approach we refer to as integrated deterrence (see text box on page 22).\\n\\nWe will operate our military using a campaigning mindset—sequencing logically linked military activities to advance strategy-aligned priorities.\\n\\nAnd, we will build a resilient force and defense ecosystem to ensure we can perform these functions for decades to come.\\n\\nWe ended America’s longest war in Afghanistan, and with it an era of major military operations to remake other societies, even as we have maintained the capacity to address terrorist threats to the American people as they emerge.\\n\\n20  NATIONAL SECURITY STRATEGY Page 21 \\x90\\x90\\x90\\x90\\x90\\x90\\n\\nA combat-credible military is the foundation of deterrence and America’s ability to prevail in conflict.', metadata={'type': 'file', 'url': 'https://cdn.llmrails.com/dst_d94b490c-4638-4247-ad5e-9aa0e7ef53c1/c2d63a2ea3cd406cb522f8312bc1535d', 'name': 'Biden-Harris-Administrations-National-Security-Strategy-10.2022.pdf'})"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What is your approach to national defense\"\n",
+    "retriever.get_relevant_documents(query)[0]"
+   ]
+  }
+ ],
+ "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/integrations/vectorstores/supabase.ipynb

@@ -92,7 +92,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "19846a7b-99bc-47a7-8e1c-f13c2497f1ae",
    "metadata": {},
    "outputs": [],
@@ -105,7 +105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "id": "c71c3901-d44b-4d09-92c5-3018628c28fa",
    "metadata": {},
    "outputs": [],
@@ -115,7 +115,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "id": "8b91ecfa-f61b-489a-a337-dff1f12f6ab2",
    "metadata": {},
    "outputs": [],
@@ -138,51 +138,66 @@
     "load_dotenv()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "924d4df5",
+   "metadata": {},
+   "source": [
+    "First we'll create a Supabase client and instantiate a OpenAI embeddings class."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 19,
    "id": "5ce44f7c",
    "metadata": {},
    "outputs": [],
    "source": [
     "import os\n",
     "from supabase.client import Client, create_client\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import SupabaseVectorStore\n",
     "\n",
     "supabase_url = os.environ.get(\"SUPABASE_URL\")\n",
     "supabase_key = os.environ.get(\"SUPABASE_SERVICE_KEY\")\n",
-    "supabase: Client = create_client(supabase_url, supabase_key)"
+    "supabase: Client = create_client(supabase_url, supabase_key)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c707d4c",
+   "metadata": {},
+   "source": [
+    "Next we'll load and parse some data for our vector store (skip if you already have documents with embeddings stored in your DB)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 20,
    "id": "aac9563e",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "\n",
     "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.vectorstores import SupabaseVectorStore\n",
-    "from langchain.document_loaders import TextLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "a3c3999a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
     "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()"
+    "docs = text_splitter.split_documents(documents)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5abb9b93",
+   "metadata": {},
+   "source": [
+    "Insert the above documents into the database. Embeddings will automatically be generated for each document."
    ]
   },
   {
@@ -192,13 +207,39 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# We're using the default `documents` table here. You can modify this by passing in a `table_name` argument to the `from_documents` method.\n",
-    "vector_store = SupabaseVectorStore.from_documents(docs, embeddings, client=supabase)"
+    "\n",
+    "vector_store = SupabaseVectorStore.from_documents(docs, embeddings, client=supabase, table_name=\"documents\", query_name=\"match_documents\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e169345d",
+   "metadata": {},
+   "source": [
+    "Alternatively if you already have documents with embeddings in your database, simply instantiate a new `SupabaseVectorStore` directly:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
+   "id": "397e3e7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vector_store = SupabaseVectorStore(embedding=embeddings, client=supabase, table_name=\"documents\", query_name=\"match_documents\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e28ce092",
+   "metadata": {},
+   "source": [
+    "Finally, test it out by performing a similarity search:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "id": "5eabdb75",
    "metadata": {},
    "outputs": [],
@@ -209,7 +250,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "4b172de8",
    "metadata": {},
    "outputs": [
@@ -431,7 +472,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/extras/integrations/vectorstores/vald.ipynb

@@ -0,0 +1,175 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "25bce5eb-8599-40fe-947e-4932cfae8184",
+   "metadata": {},
+   "source": [
+    "# Vald\n",
+    "\n",
+    "> [Vald](https://github.com/vdaas/vald) is a highly scalable distributed fast approximate nearest neighbor (ANN) dense vector search engine.\n",
+    "\n",
+    "This notebook shows how to use functionality related to the `Vald` database.\n",
+    "\n",
+    "To run this notebook you need a running Vald cluster.\n",
+    "Check [Get Started](https://github.com/vdaas/vald#get-started) for more information.\n",
+    "\n",
+    "See the [installation instructions](https://github.com/vdaas/vald-client-python#install)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f45f46f2-7229-4859-9797-30bbead1b8e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install vald-client-python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f65caa9-8383-409a-bccb-6e91fc8d5e8f",
+   "metadata": {},
+   "source": [
+    "## Basic Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eab0b1e4-9793-4be7-a2ba-e4455c21ea22",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TextLoader\n",
+    "from langchain.embeddings import HuggingFaceEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import Vald\n",
+    "\n",
+    "raw_documents = TextLoader('state_of_the_union.txt').load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "documents = text_splitter.split_documents(raw_documents)\n",
+    "embeddings = HuggingFaceEmbeddings()\n",
+    "db = Vald.from_documents(documents, embeddings, host=\"localhost\", port=8080)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0a6797c-2bb0-45db-a636-5d2437f7a4c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = db.similarity_search(query)\n",
+    "docs[0].page_content"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4c4e06d-6def-44ce-ac9a-4c01673c29a2",
+   "metadata": {},
+   "source": [
+    "### Similarity search by vector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1eb72610-d451-4158-880c-9f0d45fa5909",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embedding_vector = embeddings.embed_query(query)\n",
+    "docs = db.similarity_search_by_vector(embedding_vector)\n",
+    "docs[0].page_content"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d33588d4-67c2-4bd3-b251-76ae783cbafb",
+   "metadata": {},
+   "source": [
+    "### Similarity search with score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a41e382-0336-4e6d-b2ef-44cc77db2696",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs_and_scores = db.similarity_search_with_score(query)\n",
+    "docs_and_scores[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57f930f2-41a0-4795-ad9e-44a33c8f88ec",
+   "metadata": {},
+   "source": [
+    "## Maximal Marginal Relevance Search (MMR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4790e437-3207-45cb-b121-d857ab5aabd8",
+   "metadata": {},
+   "source": [
+    "In addition to using similarity search in the retriever object, you can also use `mmr` as retriever."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "495754b1-5cdb-4af6-9733-f68700bb7232",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "retriever = db.as_retriever(search_type=\"mmr\")\n",
+    "retriever.get_relevant_documents(query)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e213d957-e439-4bd6-90f2-8909323f5f09",
+   "metadata": {},
+   "source": [
+    "Or use `max_marginal_relevance_search` directly:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99d928d0-3b79-4588-925e-32230e12af47",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db.max_marginal_relevance_search(query, k=2, fetch_k=10)"
+   ]
+  }
+ ],
+ "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/integrations/vectorstores/vearch.ipynb

@@ -2,52 +2,27 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/export/anaconda3/envs/langchainGLM6B/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "/export/anaconda3/envs/vearch_cluster_langchain/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
       "  from .autonotebook import tqdm as notebook_tqdm\n",
-      "INFO  2023-08-28 18:26:07,485-1d: \n",
-      "loading model config\n",
-      "llm device: cuda\n",
-      "embedding device: cuda\n",
-      "dir: /data/zhx/zhx/langchain-ChatGLM_new\n",
-      "flagging username: e2fc35b8e87c4de18d692e951a5f7c46\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Loading checkpoint shards: 100%|██████████| 7/7 [00:06<00:00,  1.01it/s]\n"
+      "Loading checkpoint shards: 100%|██████████| 7/7 [00:07<00:00,  1.01s/it]\n"
      ]
     }
    ],
    "source": [
-    "\n",
-    "import os, sys, torch\n",
-    "from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModel\n",
-    "from langchain.llms import HuggingFacePipeline\nfrom langchain.chains import ConversationChain\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
-    "from langchain.vectorstores.vearch import VearchDb\n",
     "from langchain.document_loaders import TextLoader\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain.chains import RetrievalQA\n",
     "from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n",
+    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "from transformers import AutoModel, AutoTokenizer\n",
+    "from langchain.vectorstores.vearch import Vearch\n",
     "\n",
-    "# your local model path\n",
+    "# repalce to your local model path\n",
     "model_path =\"/data/zhx/zhx/langchain-ChatGLM_new/chatglm2-6b\"  \n",
     "\n",
     "tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)\n",
@@ -56,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -67,7 +42,7 @@
       "ChatGLM:你好👋！我是人工智能助手 ChatGLM2-6B，很高兴见到你，欢迎问我任何问题。\n",
       "\n",
       "Human: 你知道凌波微步吗，你知道都有谁学会了吗?\n",
-      "ChatGLM:凌波微步是一种步伐，最早出自于《倚天屠龙记》。在小说中，灭绝师太曾因与练习凌波微步的杨过的恩怨纠葛，而留下了一部经书，内容是记载凌波微步的起源和作用。后来，凌波微步便成为杨过和小龙女的感情象征。在现实生活中，凌波微步是一句口号，是清华大学学生社团“模型社”的社训。\n",
+      "ChatGLM:凌波微步是一种步伐，最早出自《倚天屠龙记》。在电视剧《人民的名义》中，侯亮平也学会了凌波微步。\n",
       "\n"
      ]
     }
@@ -83,16 +58,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO  2023-08-28 18:27:36,037-1d: Load pretrained SentenceTransformer: /data/zhx/zhx/langchain-ChatGLM_new/text2vec/text2vec-large-chinese\n",
-      "WARNING 2023-08-28 18:27:36,038-1d: No sentence-transformers model found with name /data/zhx/zhx/langchain-ChatGLM_new/text2vec/text2vec-large-chinese. Creating a new one with MEAN pooling.\n",
-      "INFO  2023-08-28 18:27:38,936-1d: Use pytorch device: cuda\n"
+      "No sentence-transformers model found with name /data/zhx/zhx/langchain-ChatGLM_new/text2vec/text2vec-large-chinese. Creating a new one with MEAN pooling.\n"
      ]
     }
    ],
@@ -103,60 +76,45 @@
     "documents = loader.load()\n",
     "\n",
     "# split text into sentences and embedding the sentences\n",
-    "text_splitter = RecursiveCharacterTextSplitter(\n",
-    "    chunk_size=500, chunk_overlap=100)\n",
+    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)\n",
     "texts = text_splitter.split_documents(documents)\n",
     "\n",
-    "#your model path\n",
+    "#replace to your model path\n",
     "embedding_path = '/data/zhx/zhx/langchain-ChatGLM_new/text2vec/text2vec-large-chinese'\n",
-    "embeddings = HuggingFaceEmbeddings(model_name=embedding_path)\n",
-    "\n"
+    "embeddings = HuggingFaceEmbeddings(model_name=embedding_path)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Batches: 100%|██████████| 1/1 [00:00<00:00,  4.56it/s]"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "['7aae36236f784105a0004d8ff3c7c3ad', '7e495d4e5962497db2080e84d52e75ed', '9a640124fc324a8abb0eaa31acb638b7']\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
+      "docids ['18ce6747dca04a2c833e60e8dfd83c04', 'aafacb0e46574b378a9f433877ab06a8', '9776bccfdd8643a8b219ccee0596f370']\n",
+      "***************after is cluster res*****************\n",
+      "docids ['1841638988191686991', '-4519586577642625749', '5028230008472292907']\n"
      ]
     }
    ],
    "source": [
     "#first add your document into vearch vectorstore\n",
-    "vearch_db = VearchDb.from_documents(texts,embeddings,table_name=\"your_table_name\",metadata_path=\"/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/your_table_name\")"
+    "vearch_standalone = Vearch.from_documents(\n",
+    "    texts,embeddings,path_or_url=\"/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/localdb_new_test\",table_name=\"localdb_new_test\",flag=0)\n",
+    "\n",
+    "print(\"***************after is cluster res*****************\")\n",
+    "\n",
+    "vearch_cluster = Vearch.from_documents(\n",
+    "    texts,embeddings,path_or_url=\"http://test-vearch-langchain-router.vectorbase.svc.ht1.n.jd.local\",db_name=\"vearch_cluster_langchian\",table_name=\"tobenumone\",flag=1)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Batches: 100%|██████████| 1/1 [00:00<00:00, 22.49it/s]\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -194,28 +152,76 @@
       "段誉心道：“神仙姊姊所遗的步法，必定精妙之极，遇到强敌时脱身逃走，那就很好，‘再取敌命’也就不必了。”\n",
       "卷好帛卷，对之作了两个揖，珍而重之地揣入怀中，转身对那玉像道：“神仙姊姊，你吩咐我朝午晚三次练功，段誉不敢有违。今后我对人加倍客气，别人不会来打我，我自然也不会去吸他内力。你这套‘凌波微步’我更要用心练熟，眼见不对，立刻溜之大吉，就吸不到他内力了。”至于“杀尽我逍遥派弟子”一节，却想也不敢去想。\n",
       "\n",
-      "********ChatGLM:凌波微步是一种轻功身法，属于逍遥派独门轻功。它以《易经》中的六十四卦为基础，按照特定顺序踏着卦象方位行进，从第一步到最后一步正好行走一个大圈。凌波微步精妙异常，可以让人内力相助，自身内力颇为深厚之后再练。《天龙八部》第五回中有描述。\n",
+      "********ChatGLM:凌波微步是一门极上乘的轻功，源于《易经》八八六十四卦。使用者按照特定顺序踏着卦象方位行进，从第一步到最后一步正好行走一个大圈。这门轻功精妙异常，可以使人内力大为提升，但需在练成“北冥神功”后才能真正掌握。凌波微步在金庸先生的《天龙八部》中得到了充分的描写。\n",
+      "\n",
+      "***************************after is cluster res******************************\n",
+      "####################第1段相关文档####################\n",
+      "\n",
+      "午饭过后，段誉又练“凌波微步”，走一步，吸一口气，走第二步时将气呼出，六十四卦走完，四肢全无麻痹之感，料想呼吸顺畅，便无害处。第二次再走时连走两步吸一口气，再走两步始行呼出。这“凌波微步”是以动功修习内功，脚步踏遍六十四卦一个周天，内息自然而然地也转了一个周天。因此他每走一遍，内力便有一分进益。\n",
+      "\n",
+      "这般练了几天，“凌波微步”已走得颇为纯熟，不须再数呼吸，纵然疾行，气息也已无所窒滞。心意既畅，跨步时渐渐想到《洛神赋》中那些与“凌波微步”有关的句子：“仿佛兮若轻云之蔽月，飘飘兮若流风之回雪”，“竦轻躯以鹤立，若将飞而未翔”，“体迅飞凫，飘忽若神”，“动无常则，若危若安。进止难期，若往若还”。\n",
+      "\n",
+      "\n",
+      "\n",
+      "百度简介\n",
+      "\n",
+      "凌波微步是「逍遥派」独门轻功身法，精妙异常。\n",
+      "\n",
+      "凌波微步乃是一门极上乘的轻功，所以列于卷轴之末，以易经八八六十四卦为基础，使用者按特定顺序踏着卦象方位行进，从第一步到最后一步正好行走一个大圈。此步法精妙异常，原是要待人练成「北冥神功」，吸人内力，自身内力已【颇为深厚】之后再练。\n",
+      "\n",
+      "####################第2段相关文档####################\n",
+      "\n",
+      "《天龙八部》第五回 微步縠纹生\n",
+      "\n",
+      "卷轴中此外诸种经脉修习之法甚多，皆是取人内力的法门，段誉虽自语宽解，总觉习之有违本性，单是贪多务得，便非好事，当下暂不理会。\n",
+      "\n",
+      "卷到卷轴末端，又见到了“凌波微步”那四字，登时便想起《洛神赋》中那些句子来：“凌波微步，罗袜生尘……转眄流精，光润玉颜。含辞未吐，气若幽兰。华容婀娜，令我忘餐。”曹子建那些千古名句，在脑海中缓缓流过：“秾纤得衷，修短合度，肩若削成，腰如约素。延颈秀项，皓质呈露。芳泽无加，铅华弗御。云髻峨峨，修眉连娟。丹唇外朗，皓齿内鲜。明眸善睐，靥辅承权。瑰姿艳逸，仪静体闲。柔情绰态，媚于语言……”这些句子用在木婉清身上，“这话倒也有理”；但如用之于神仙姊姊，只怕更为适合。想到神仙姊姊的姿容体态，“皎若太阳升朝霞，灼若芙蓉出绿波”，但觉依她吩咐行事，实为人生至乐，心想：“我先来练这‘凌波微步’，此乃逃命之妙法，非害人之手段也，练之有百利而无一害。”\n",
+      "\n",
+      "####################第3段相关文档####################\n",
+      "\n",
+      "《天龙八部》第二回 玉壁月华明\n",
+      "\n",
+      "再展帛卷，长卷上源源皆是裸女画像，或立或卧，或现前胸，或见后背。人像的面容都是一般，但或喜或愁，或含情凝眸，或轻嗔薄怒，神情各异。一共有三十六幅图像，每幅像上均有颜色细线，注明穴道部位及练功法诀。\n",
+      "\n",
+      "帛卷尽处题着“凌波微步”四字，其后绘的是无数足印，注明“妇妹”、“无妄”等等字样，尽是《易经》中的方位。段誉前几日还正全心全意地钻研《易经》，一见到这些名称，登时精神大振，便似遇到故交良友一般。只见足印密密麻麻，不知有几千百个，自一个足印至另一个足印均有绿线贯串，线上绘有箭头，最后写着一行字道：“步法神妙，保身避敌，待积内力，再取敌命。”\n",
+      "\n",
+      "段誉心道：“神仙姊姊所遗的步法，必定精妙之极，遇到强敌时脱身逃走，那就很好，‘再取敌命’也就不必了。”\n",
+      "卷好帛卷，对之作了两个揖，珍而重之地揣入怀中，转身对那玉像道：“神仙姊姊，你吩咐我朝午晚三次练功，段誉不敢有违。今后我对人加倍客气，别人不会来打我，我自然也不会去吸他内力。你这套‘凌波微步’我更要用心练熟，眼见不对，立刻溜之大吉，就吸不到他内力了。”至于“杀尽我逍遥派弟子”一节，却想也不敢去想。\n",
+      "\n",
+      "********ChatGLM:凌波微步是一门极上乘的轻功，源于《易经》中的六十四卦。使用者按照特定顺序踏着卦象方位行进，从第一步到最后一步正好行走一个大圈。这门轻功精妙异常，可以使人内力增进，但需要谨慎练习，避免伤害他人。凌波微步在逍遥派中尤为流行，但并非所有逍遥派弟子都会凌波微步。\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "\n",
-    "res=vearch_db.similarity_search(query, 3)\n",
     "query = \"你知道凌波微步吗，你知道都有谁会凌波微步?\"\n",
-    "for idx,tmp in enumerate(res): \n",
+    "vearch_standalone_res=vearch_standalone.similarity_search(query, 3)\n",
+    "for idx,tmp in enumerate(vearch_standalone_res): \n",
     "    print(f\"{'#'*20}第{idx+1}段相关文档{'#'*20}\\n\\n{tmp.page_content}\\n\")\n",
     "\n",
     "# combine your local knowleadge and query \n",
-    "context = \"\".join([tmp.page_content for tmp in res])\n",
+    "context = \"\".join([tmp.page_content for tmp in vearch_standalone_res])\n",
     "new_query = f\"基于以下信息，尽可能准确的来回答用户的问题。背景信息:\\n {context} \\n 回答用户这个问题:{query}\\n\\n\"\n",
     "response, history = model.chat(tokenizer, new_query, history=[])\n",
-    "print(f\"********ChatGLM:{response}\\n\")\n"
+    "print(f\"********ChatGLM:{response}\\n\")\n",
+    "\n",
+    "print(\"***************************after is cluster res******************************\")\n",
+    "\n",
+    "query_c = \"你知道凌波微步吗，你知道都有谁会凌波微步?\"\n",
+    "cluster_res=vearch_cluster.similarity_search(query_c, 3)\n",
+    "for idx,tmp in enumerate(cluster_res): \n",
+    "    print(f\"{'#'*20}第{idx+1}段相关文档{'#'*20}\\n\\n{tmp.page_content}\\n\")\n",
+    "\n",
+    "# combine your local knowleadge and query \n",
+    "context_c = \"\".join([tmp.page_content for tmp in cluster_res])\n",
+    "new_query_c = f\"基于以下信息，尽可能准确的来回答用户的问题。背景信息:\\n {context_c} \\n 回答用户这个问题:{query_c}\\n\\n\"\n",
+    "response_c, history_c = model.chat(tokenizer, new_query_c, history=[])\n",
+    "print(f\"********ChatGLM:{response_c}\\n\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -223,42 +229,20 @@
      "output_type": "stream",
      "text": [
       "Human: 你知道vearch是什么吗?\n",
-      "ChatGLM:是的，我知道 Vearch。Vearch 是一种矩阵分解 technique，用于将矩阵分解为若干个不可约矩阵的乘积。它是由 Linus Torvalds 开发的，旨在提高 Linux 内核中矩阵操作的性能。\n",
+      "ChatGLM:是的，我知道 Vearch。Vearch 是一种用于计算机械系统极化子的工具，它可以用于模拟和优化电路的性能。它是一个基于Matlab的电路仿真软件，可以用于设计和分析各种类型的电路，包括交流电路和直流电路。\n",
       "\n",
-      "Vearch 可以通过使用特殊的操作来对矩阵进行操作，从而避免了使用昂贵的矩阵操作库。它也被广泛用于其他操作系统中，如 FreeBSD 和 Solaris。\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Batches: 100%|██████████| 1/1 [00:00<00:00, 31.59it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['04bc84fff5074b7b8990441e92e6df07', 'e221906153bb4e03bc7095dadea144de', '126034ba51934093920d8732860f340b']\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
+      "docids ['eee5e7468434427eb49829374c1e8220', '2776754da8fc4bb58d3e482006010716', '9223acd6d89d4c2c84ff42677ac0d47c']\n",
+      "*****************after is cluster res********************\n",
+      "docids ['-4311783201092343475', '-2899734009733762895', '1342026762029067927']\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "['04bc84fff5074b7b8990441e92e6df07',\n",
-       " 'e221906153bb4e03bc7095dadea144de',\n",
-       " '126034ba51934093920d8732860f340b']"
+       "['-4311783201092343475', '-2899734009733762895', '1342026762029067927']"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -268,27 +252,24 @@
     "response, history = model.chat(tokenizer, query, history=history)\n",
     "print(f\"Human: {query}\\nChatGLM:{response}\\n\")\n",
     "\n",
-    "\n",
     "vearch_info = [\"Vearch 是一款存储大语言模型数据的向量数据库，用于存储和快速搜索模型embedding后的向量，可用于基于个人知识库的大模型应用\",\n",
     "              \"Vearch 支持OpenAI, Llama, ChatGLM等模型，以及LangChain库\",\n",
     "              \"vearch 是基于C语言,go语言开发的，并提供python接口，可以直接通过pip安装\"]\n",
     "vearch_source=[{'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/tlbb/three_body.txt'},{'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/tlbb/three_body.txt'},{'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/tlbb/three_body.txt'}]\n",
-    "vearch_db.add_texts(vearch_info,vearch_source)\n",
+    "vearch_standalone.add_texts(vearch_info,vearch_source)\n",
+    "\n",
+    "print(\"*****************after is cluster res********************\")\n",
+    "\n",
+    "vearch_cluster.add_texts(vearch_info,vearch_source)\n",
+    "\n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Batches: 100%|██████████| 1/1 [00:00<00:00, 25.57it/s]\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -305,56 +286,107 @@
       "\n",
       "vearch 是基于C语言,go语言开发的，并提供python接口，可以直接通过pip安装\n",
       "\n",
-      "***************ChatGLM:是的，Varch是一个向量数据库，旨在存储和快速搜索模型embedding后的向量。它支持OpenAI、Llama和ChatGLM等模型，并可以直接通过pip安装。Varch是一个基于C语言和Go语言开发的项目，并提供了Python接口。\n",
+      "***************ChatGLM:是的，Varch是一个向量数据库，旨在存储和快速搜索模型embedding后的向量。它支持OpenAI、ChatGLM等模型，并可直接通过pip安装。\n",
+      "\n",
+      "***************after is cluster res******************\n",
+      "####################第1段相关文档####################\n",
+      "\n",
+      "Vearch 是一款存储大语言模型数据的向量数据库，用于存储和快速搜索模型embedding后的向量，可用于基于个人知识库的大模型应用\n",
+      "\n",
+      "####################第2段相关文档####################\n",
+      "\n",
+      "Vearch 支持OpenAI, Llama, ChatGLM等模型，以及LangChain库\n",
+      "\n",
+      "####################第3段相关文档####################\n",
+      "\n",
+      "vearch 是基于C语言,go语言开发的，并提供python接口，可以直接通过pip安装\n",
+      "\n",
+      "***************ChatGLM:是的，Varch是一个向量数据库，旨在存储和快速搜索模型embedding后的向量。它支持OpenAI，ChatGLM等模型，并可用于基于个人知识库的大模型应用。Varch基于C语言和Go语言开发，并提供Python接口，可以通过pip安装。\n",
       "\n"
      ]
     }
    ],
    "source": [
     "query3 = \"你知道vearch是什么吗?\"\n",
-    "res1 = vearch_db.similarity_search(query3, 3)\n",
+    "res1 = vearch_standalone.similarity_search(query3, 3)\n",
     "for idx,tmp in enumerate(res1): \n",
     "    print(f\"{'#'*20}第{idx+1}段相关文档{'#'*20}\\n\\n{tmp.page_content}\\n\")\n",
     "\n",
     "context1 = \"\".join([tmp.page_content for tmp in res1])\n",
     "new_query1 = f\"基于以下信息，尽可能准确的来回答用户的问题。背景信息:\\n {context1} \\n 回答用户这个问题:{query3}\\n\\n\"\n",
     "response, history = model.chat(tokenizer, new_query1, history=[])\n",
+    "print(f\"***************ChatGLM:{response}\\n\")\n",
     "\n",
-    "print(f\"***************ChatGLM:{response}\\n\")"
+    "print(\"***************after is cluster res******************\")\n",
+    "\n",
+    "query3_c = \"你知道vearch是什么吗?\"\n",
+    "res1_c = vearch_standalone.similarity_search(query3_c, 3)\n",
+    "for idx,tmp in enumerate(res1_c): \n",
+    "    print(f\"{'#'*20}第{idx+1}段相关文档{'#'*20}\\n\\n{tmp.page_content}\\n\")\n",
+    "\n",
+    "context1_C = \"\".join([tmp.page_content for tmp in res1_c])\n",
+    "new_query1_c = f\"基于以下信息，尽可能准确的来回答用户的问题。背景信息:\\n {context1_C} \\n 回答用户这个问题:{query3_c}\\n\\n\"\n",
+    "response_c, history_c = model.chat(tokenizer, new_query1_c, history=[])\n",
+    "\n",
+    "print(f\"***************ChatGLM:{response_c}\\n\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "delete docid True\n",
+      "delete vearch standalone docid True\n",
       "Human: 你知道vearch是什么吗?\n",
-      "ChatGLM:Vearch是一种高分子化合物,也称为聚合物、高分子材料或合成材料。它是由重复单元组成的大型聚合物,通常由一些重复单元组成,这些单元在聚合过程中结合在一起形成一个连续的高分子链。\n",
+      "ChatGLM:Vearch是一种用于处理向量的库,可以轻松地将向量转换为矩阵,并提供许多有用的函数和算法,以操作向量。 Vearch支持许多常见的向量操作,例如加法、减法、乘法、除法、矩阵乘法、求和、统计和归一化等。 Vearch还提供了一些高级功能,例如L2正则化、协方差矩阵、稀疏矩阵和奇异值分解等。\n",
       "\n",
-      "Vearch具有许多独特的性质,例如高强度、高刚性、耐磨、耐腐蚀、耐高温等。它们通常用于制造各种应用,例如塑料制品、橡胶、纤维、建筑材料等。\n",
+      "delete vearch cluster docid True\n",
+      "Human: 你知道vearch是什么吗?\n",
+      "ChatGLM:Vearch是一种用于处理向量数据的函数,可以应用于多种不同的编程语言和数据结构中。\n",
+      "\n",
+      "Vearch最初是作为Java中一个名为“vearch”的包而出现的,它的目的是提供一种高效的向量数据结构。它支持向量的多态性,可以轻松地实现不同类型的向量之间的转换,同时还支持向量的压缩和反向操作等操作。\n",
+      "\n",
+      "后来,Vearch被广泛应用于其他编程语言中,如Python、Ruby、JavaScript等。在Python中,它被称为“vectorize”,在Ruby中,它被称为“Vector”。\n",
+      "\n",
+      "Vearch的主要优点是它的向量操作具有多态性,可以应用于不同类型的向量数据,同时还支持高效的向量操作和反向操作,因此可以提高程序的性能。\n",
       "\n",
       "after delete docid to query again: {}\n",
-      "get existed docid {'7aae36236f784105a0004d8ff3c7c3ad': Document(page_content='《天龙八部》第二回 玉壁月华明\\n\\n再展帛卷，长卷上源源皆是裸女画像，或立或卧，或现前胸，或见后背。人像的面容都是一般，但或喜或愁，或含情凝眸，或轻嗔薄怒，神情各异。一共有三十六幅图像，每幅像上均有颜色细线，注明穴道部位及练功法诀。\\n\\n帛卷尽处题着“凌波微步”四字，其后绘的是无数足印，注明“妇妹”、“无妄”等等字样，尽是《易经》中的方位。段誉前几日还正全心全意地钻研《易经》，一见到这些名称，登时精神大振，便似遇到故交良友一般。只见足印密密麻麻，不知有几千百个，自一个足印至另一个足印均有绿线贯串，线上绘有箭头，最后写着一行字道：“步法神妙，保身避敌，待积内力，再取敌命。”\\n\\n段誉心道：“神仙姊姊所遗的步法，必定精妙之极，遇到强敌时脱身逃走，那就很好，‘再取敌命’也就不必了。”\\n卷好帛卷，对之作了两个揖，珍而重之地揣入怀中，转身对那玉像道：“神仙姊姊，你吩咐我朝午晚三次练功，段誉不敢有违。今后我对人加倍客气，别人不会来打我，我自然也不会去吸他内力。你这套‘凌波微步’我更要用心练熟，眼见不对，立刻溜之大吉，就吸不到他内力了。”至于“杀尽我逍遥派弟子”一节，却想也不敢去想。', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'}), '7e495d4e5962497db2080e84d52e75ed': Document(page_content='《天龙八部》第五回 微步縠纹生\\n\\n卷轴中此外诸种经脉修习之法甚多，皆是取人内力的法门，段誉虽自语宽解，总觉习之有违本性，单是贪多务得，便非好事，当下暂不理会。\\n\\n卷到卷轴末端，又见到了“凌波微步”那四字，登时便想起《洛神赋》中那些句子来：“凌波微步，罗袜生尘……转眄流精，光润玉颜。含辞未吐，气若幽兰。华容婀娜，令我忘餐。”曹子建那些千古名句，在脑海中缓缓流过：“秾纤得衷，修短合度，肩若削成，腰如约素。延颈秀项，皓质呈露。芳泽无加，铅华弗御。云髻峨峨，修眉连娟。丹唇外朗，皓齿内鲜。明眸善睐，靥辅承权。瑰姿艳逸，仪静体闲。柔情绰态，媚于语言……”这些句子用在木婉清身上，“这话倒也有理”；但如用之于神仙姊姊，只怕更为适合。想到神仙姊姊的姿容体态，“皎若太阳升朝霞，灼若芙蓉出绿波”，但觉依她吩咐行事，实为人生至乐，心想：“我先来练这‘凌波微步’，此乃逃命之妙法，非害人之手段也，练之有百利而无一害。”', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'})}\n"
+      "get existed docid {'18ce6747dca04a2c833e60e8dfd83c04': Document(page_content='《天龙八部》第二回 玉壁月华明\\n\\n再展帛卷，长卷上源源皆是裸女画像，或立或卧，或现前胸，或见后背。人像的面容都是一般，但或喜或愁，或含情凝眸，或轻嗔薄怒，神情各异。一共有三十六幅图像，每幅像上均有颜色细线，注明穴道部位及练功法诀。\\n\\n帛卷尽处题着“凌波微步”四字，其后绘的是无数足印，注明“妇妹”、“无妄”等等字样，尽是《易经》中的方位。段誉前几日还正全心全意地钻研《易经》，一见到这些名称，登时精神大振，便似遇到故交良友一般。只见足印密密麻麻，不知有几千百个，自一个足印至另一个足印均有绿线贯串，线上绘有箭头，最后写着一行字道：“步法神妙，保身避敌，待积内力，再取敌命。”\\n\\n段誉心道：“神仙姊姊所遗的步法，必定精妙之极，遇到强敌时脱身逃走，那就很好，‘再取敌命’也就不必了。”\\n卷好帛卷，对之作了两个揖，珍而重之地揣入怀中，转身对那玉像道：“神仙姊姊，你吩咐我朝午晚三次练功，段誉不敢有违。今后我对人加倍客气，别人不会来打我，我自然也不会去吸他内力。你这套‘凌波微步’我更要用心练熟，眼见不对，立刻溜之大吉，就吸不到他内力了。”至于“杀尽我逍遥派弟子”一节，却想也不敢去想。', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'}), 'aafacb0e46574b378a9f433877ab06a8': Document(page_content='《天龙八部》第五回 微步縠纹生\\n\\n卷轴中此外诸种经脉修习之法甚多，皆是取人内力的法门，段誉虽自语宽解，总觉习之有违本性，单是贪多务得，便非好事，当下暂不理会。\\n\\n卷到卷轴末端，又见到了“凌波微步”那四字，登时便想起《洛神赋》中那些句子来：“凌波微步，罗袜生尘……转眄流精，光润玉颜。含辞未吐，气若幽兰。华容婀娜，令我忘餐。”曹子建那些千古名句，在脑海中缓缓流过：“秾纤得衷，修短合度，肩若削成，腰如约素。延颈秀项，皓质呈露。芳泽无加，铅华弗御。云髻峨峨，修眉连娟。丹唇外朗，皓齿内鲜。明眸善睐，靥辅承权。瑰姿艳逸，仪静体闲。柔情绰态，媚于语言……”这些句子用在木婉清身上，“这话倒也有理”；但如用之于神仙姊姊，只怕更为适合。想到神仙姊姊的姿容体态，“皎若太阳升朝霞，灼若芙蓉出绿波”，但觉依她吩咐行事，实为人生至乐，心想：“我先来练这‘凌波微步’，此乃逃命之妙法，非害人之手段也，练之有百利而无一害。”', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'}), '9776bccfdd8643a8b219ccee0596f370': Document(page_content='午饭过后，段誉又练“凌波微步”，走一步，吸一口气，走第二步时将气呼出，六十四卦走完，四肢全无麻痹之感，料想呼吸顺畅，便无害处。第二次再走时连走两步吸一口气，再走两步始行呼出。这“凌波微步”是以动功修习内功，脚步踏遍六十四卦一个周天，内息自然而然地也转了一个周天。因此他每走一遍，内力便有一分进益。\\n\\n这般练了几天，“凌波微步”已走得颇为纯熟，不须再数呼吸，纵然疾行，气息也已无所窒滞。心意既畅，跨步时渐渐想到《洛神赋》中那些与“凌波微步”有关的句子：“仿佛兮若轻云之蔽月，飘飘兮若流风之回雪”，“竦轻躯以鹤立，若将飞而未翔”，“体迅飞凫，飘忽若神”，“动无常则，若危若安。进止难期，若往若还”。\\n\\n\\n\\n百度简介\\n\\n凌波微步是「逍遥派」独门轻功身法，精妙异常。\\n\\n凌波微步乃是一门极上乘的轻功，所以列于卷轴之末，以易经八八六十四卦为基础，使用者按特定顺序踏着卦象方位行进，从第一步到最后一步正好行走一个大圈。此步法精妙异常，原是要待人练成「北冥神功」，吸人内力，自身内力已【颇为深厚】之后再练。', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'})}\n",
+      "after delete docid to query again: {}\n",
+      "get existed docid {'1841638988191686991': Document(page_content='《天龙八部》第二回 玉壁月华明\\n\\n再展帛卷，长卷上源源皆是裸女画像，或立或卧，或现前胸，或见后背。人像的面容都是一般，但或喜或愁，或含情凝眸，或轻嗔薄怒，神情各异。一共有三十六幅图像，每幅像上均有颜色细线，注明穴道部位及练功法诀。\\n\\n帛卷尽处题着“凌波微步”四字，其后绘的是无数足印，注明“妇妹”、“无妄”等等字样，尽是《易经》中的方位。段誉前几日还正全心全意地钻研《易经》，一见到这些名称，登时精神大振，便似遇到故交良友一般。只见足印密密麻麻，不知有几千百个，自一个足印至另一个足印均有绿线贯串，线上绘有箭头，最后写着一行字道：“步法神妙，保身避敌，待积内力，再取敌命。”\\n\\n段誉心道：“神仙姊姊所遗的步法，必定精妙之极，遇到强敌时脱身逃走，那就很好，‘再取敌命’也就不必了。”\\n卷好帛卷，对之作了两个揖，珍而重之地揣入怀中，转身对那玉像道：“神仙姊姊，你吩咐我朝午晚三次练功，段誉不敢有违。今后我对人加倍客气，别人不会来打我，我自然也不会去吸他内力。你这套‘凌波微步’我更要用心练熟，眼见不对，立刻溜之大吉，就吸不到他内力了。”至于“杀尽我逍遥派弟子”一节，却想也不敢去想。', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'}), '-4519586577642625749': Document(page_content='《天龙八部》第五回 微步縠纹生\\n\\n卷轴中此外诸种经脉修习之法甚多，皆是取人内力的法门，段誉虽自语宽解，总觉习之有违本性，单是贪多务得，便非好事，当下暂不理会。\\n\\n卷到卷轴末端，又见到了“凌波微步”那四字，登时便想起《洛神赋》中那些句子来：“凌波微步，罗袜生尘……转眄流精，光润玉颜。含辞未吐，气若幽兰。华容婀娜，令我忘餐。”曹子建那些千古名句，在脑海中缓缓流过：“秾纤得衷，修短合度，肩若削成，腰如约素。延颈秀项，皓质呈露。芳泽无加，铅华弗御。云髻峨峨，修眉连娟。丹唇外朗，皓齿内鲜。明眸善睐，靥辅承权。瑰姿艳逸，仪静体闲。柔情绰态，媚于语言……”这些句子用在木婉清身上，“这话倒也有理”；但如用之于神仙姊姊，只怕更为适合。想到神仙姊姊的姿容体态，“皎若太阳升朝霞，灼若芙蓉出绿波”，但觉依她吩咐行事，实为人生至乐，心想：“我先来练这‘凌波微步’，此乃逃命之妙法，非害人之手段也，练之有百利而无一害。”', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'}), '5028230008472292907': Document(page_content='午饭过后，段誉又练“凌波微步”，走一步，吸一口气，走第二步时将气呼出，六十四卦走完，四肢全无麻痹之感，料想呼吸顺畅，便无害处。第二次再走时连走两步吸一口气，再走两步始行呼出。这“凌波微步”是以动功修习内功，脚步踏遍六十四卦一个周天，内息自然而然地也转了一个周天。因此他每走一遍，内力便有一分进益。\\n\\n这般练了几天，“凌波微步”已走得颇为纯熟，不须再数呼吸，纵然疾行，气息也已无所窒滞。心意既畅，跨步时渐渐想到《洛神赋》中那些与“凌波微步”有关的句子：“仿佛兮若轻云之蔽月，飘飘兮若流风之回雪”，“竦轻躯以鹤立，若将飞而未翔”，“体迅飞凫，飘忽若神”，“动无常则，若危若安。进止难期，若往若还”。\\n\\n\\n\\n百度简介\\n\\n凌波微步是「逍遥派」独门轻功身法，精妙异常。\\n\\n凌波微步乃是一门极上乘的轻功，所以列于卷轴之末，以易经八八六十四卦为基础，使用者按特定顺序踏着卦象方位行进，从第一步到最后一步正好行走一个大圈。此步法精妙异常，原是要待人练成「北冥神功」，吸人内力，自身内力已【颇为深厚】之后再练。', metadata={'source': '/data/zhx/zhx/langchain-ChatGLM_new/knowledge_base/天龙八部/lingboweibu.txt'})}\n"
      ]
     }
    ],
    "source": [
     "##delete and get function need to maintian  docids \n",
     "##your docid\n",
-    "res_d=vearch_db.delete(['04bc84fff5074b7b8990441e92e6df07', 'e221906153bb4e03bc7095dadea144de', '126034ba51934093920d8732860f340b'])\n",
-    "print(\"delete docid\",res_d)\n",
+    "\n",
+    "res_d=vearch_standalone.delete(['eee5e7468434427eb49829374c1e8220', '2776754da8fc4bb58d3e482006010716', '9223acd6d89d4c2c84ff42677ac0d47c'])\n",
+    "print(\"delete vearch standalone docid\",res_d)\n",
     "query = \"你知道vearch是什么吗?\"\n",
     "response, history = model.chat(tokenizer, query, history=[])\n",
     "print(f\"Human: {query}\\nChatGLM:{response}\\n\")\n",
-    "get_id_doc=vearch_db.get(['04bc84fff5074b7b8990441e92e6df07'])\n",
-    "print(\"after delete docid to query again:\",get_id_doc)\n",
-    "get_delet_doc=vearch_db.get(['7aae36236f784105a0004d8ff3c7c3ad', '7e495d4e5962497db2080e84d52e75ed'])\n",
-    "print(\"get existed docid\",get_delet_doc)"
+    "\n",
+    "res_cluster=vearch_cluster.delete(['-4311783201092343475', '-2899734009733762895', '1342026762029067927'])\n",
+    "print(\"delete vearch cluster docid\",res_cluster)\n",
+    "query_c = \"你知道vearch是什么吗?\"\n",
+    "response_c, history = model.chat(tokenizer, query_c, history=[])\n",
+    "print(f\"Human: {query}\\nChatGLM:{response_c}\\n\")\n",
+    "\n",
+    "\n",
+    "get_delet_doc=vearch_standalone.get(['eee5e7468434427eb49829374c1e8220', '2776754da8fc4bb58d3e482006010716', '9223acd6d89d4c2c84ff42677ac0d47c'])\n",
+    "print(\"after delete docid to query again:\",get_delet_doc)\n",
+    "get_id_doc=vearch_standalone.get(['18ce6747dca04a2c833e60e8dfd83c04', 'aafacb0e46574b378a9f433877ab06a8', '9776bccfdd8643a8b219ccee0596f370','9223acd6d89d4c2c84ff42677ac0d47c'])\n",
+    "print(\"get existed docid\",get_id_doc)\n",
+    "\n",
+    "get_delet_doc=vearch_cluster.get(['-4311783201092343475', '-2899734009733762895', '1342026762029067927'])\n",
+    "print(\"after delete docid to query again:\",get_delet_doc)\n",
+    "get_id_doc=vearch_cluster.get(['1841638988191686991', '-4519586577642625749', '5028230008472292907','1342026762029067927'])\n",
+    "print(\"get existed docid\",get_id_doc)\n"
    ]
   },
   {
@@ -385,7 +417,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.10.12 ('langchainGLM6B')",
+   "display_name": "Python 3.10.13 ('vearch_cluster_langchain')",
    "language": "python",
    "name": "python3"
   },
@@ -399,12 +431,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.13"
   },
   "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
-    "hash": "1fd24e7ef183310e43cbf656d21568350c6a30580b6df7fe3b34654b3770f74d"
+    "hash": "f1da10a89896267ed34b497c9568817f36cc7ea79826b5cfca4d96376f5b4835"
    }
   }
  },

docs/extras/modules/agents/agent_types/chat_conversation_agent.ipynb

@@ -0,0 +1,561 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "69014601",
+   "metadata": {},
+   "source": [
+    "# Conversational\n",
+    "\n",
+    "This walkthrough demonstrates how to use an agent optimized for conversation. Other agents are often optimized for using tools to figure out the best response, which is not ideal in a conversational setting where you may want the agent to be able to chat with the user as well.\n",
+    "\n",
+    "If we compare it to the standard ReAct agent, the main difference is the prompt.\n",
+    "We want it to be much more conversational."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "cc3fad9e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import Tool\n",
+    "from langchain.agents import AgentType\n",
+    "from langchain.memory import ConversationBufferMemory\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.utilities import SerpAPIWrapper\n",
+    "from langchain.agents import initialize_agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2d84b9bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = SerpAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Current Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events or the current state of the world\"\n",
+    "    ),\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "799a31bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm=OpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9d11cb6",
+   "metadata": {},
+   "source": [
+    "## Using LCEL\n",
+    "\n",
+    "We will first show how to create this agent using LCEL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "03c09ef9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.tools.render import render_text_description\n",
+    "from langchain.agents.output_parsers import ReActSingleInputOutputParser\n",
+    "from langchain.agents.format_scratchpad import format_log_to_str\n",
+    "from langchain import hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "6bd84102",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = hub.pull(\"hwchase17/react-chat\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "7ccc785d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = prompt.partial(\n",
+    "    tools=render_text_description(tools),\n",
+    "    tool_names=\", \".join([t.name for t in tools]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d7aac2b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_with_stop = llm.bind(stop=[\"\\nObservation\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "a028bca6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"agent_scratchpad\": lambda x: format_log_to_str(x['intermediate_steps']),\n",
+    "    \"chat_history\": lambda x: x[\"chat_history\"]\n",
+    "} | prompt | llm_with_stop | ReActSingleInputOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b354cfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "9b044ae9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\")\n",
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "adcdd0c7",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Thought: Do I need to use a tool? No\n",
+      "Final Answer: Hi Bob, nice to meet you! How can I help you today?\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Hi Bob, nice to meet you! How can I help you today?'"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"hi, i am bob\"})['output']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "c5846cd1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Thought: Do I need to use a tool? No\n",
+      "Final Answer: Your name is Bob.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Your name is Bob.'"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"whats my name?\"})['output']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "95a1192a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Thought: Do I need to use a tool? Yes\n",
+      "Action: Current Search\n",
+      "Action Input: Movies showing 9/21/2023\u001b[0m\u001b[36;1m\u001b[1;3m['September 2023 Movies: The Creator • Dumb Money • Expend4bles • The Kill Room • The Inventor • The Equalizer 3 • PAW Patrol: The Mighty Movie, ...']\u001b[0m\u001b[32;1m\u001b[1;3m Do I need to use a tool? No\n",
+      "Final Answer: According to current search, some movies showing on 9/21/2023 are The Creator, Dumb Money, Expend4bles, The Kill Room, The Inventor, The Equalizer 3, and PAW Patrol: The Mighty Movie.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'According to current search, some movies showing on 9/21/2023 are The Creator, Dumb Money, Expend4bles, The Kill Room, The Inventor, The Equalizer 3, and PAW Patrol: The Mighty Movie.'"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"what are some movies showing 9/21/2023?\"})['output']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c0b2d86d",
+   "metadata": {},
+   "source": [
+    "## Use the off-the-shelf agent\n",
+    "\n",
+    "We can also create this agent using the off-the-shelf agent class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "53e43064",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = initialize_agent(tools, llm, agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION, verbose=True, memory=memory)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68e45a24",
+   "metadata": {},
+   "source": [
+    "## Use a chat model\n",
+    "\n",
+    "We can also use a chat model here. The main difference here is in the prompts used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5a705b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain import hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "16b17ca8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = hub.pull(\"hwchase17/react-chat-json\")\n",
+    "chat_model = ChatOpenAI(temperature=0, model='gpt-4')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "c8a94b0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = prompt.partial(\n",
+    "    tools=render_text_description(tools),\n",
+    "    tool_names=\", \".join([t.name for t in tools]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "c5d710f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat_model_with_stop = chat_model.bind(stop=[\"\\nObservation\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f50a5ea8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.output_parsers import JSONAgentOutputParser\n",
+    "from langchain.agents.format_scratchpad import format_log_to_messages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "2c845796",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# We need some extra steering, or the chat model forgets how to respond sometimes\n",
+    "TEMPLATE_TOOL_RESPONSE = \"\"\"TOOL RESPONSE: \n",
+    "---------------------\n",
+    "{observation}\n",
+    "\n",
+    "USER'S INPUT\n",
+    "--------------------\n",
+    "\n",
+    "Okay, so what is the response to my last comment? If using information obtained from the tools you must mention it explicitly without mentioning the tool names - I have forgotten all TOOL RESPONSES! Remember to respond with a markdown code snippet of a json blob with a single action, and NOTHING else - even if you just want to respond to the user. Do NOT respond with anything except a JSON snippet no matter what!\"\"\"\n",
+    "\n",
+    "agent = {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"agent_scratchpad\": lambda x: format_log_to_messages(x['intermediate_steps'], template_tool_response=TEMPLATE_TOOL_RESPONSE),\n",
+    "    \"chat_history\": lambda x: x[\"chat_history\"],\n",
+    "} | prompt | chat_model_with_stop | JSONAgentOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6cc033fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "332ba2ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\", return_messages=True)\n",
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "139717b4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m```json\n",
+      "{\n",
+      "    \"action\": \"Final Answer\",\n",
+      "    \"action_input\": \"Hello Bob, how can I assist you today?\"\n",
+      "}\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Hello Bob, how can I assist you today?'"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"hi, i am bob\"})['output']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "7e7cf6d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m```json\n",
+      "{\n",
+      "    \"action\": \"Final Answer\",\n",
+      "    \"action_input\": \"Your name is Bob.\"\n",
+      "}\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Your name is Bob.'"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"whats my name?\"})['output']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "3fc00073",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m```json\n",
+      "{\n",
+      "    \"action\": \"Current Search\",\n",
+      "    \"action_input\": \"movies showing on 9/21/2023\"\n",
+      "}\n",
+      "```\u001b[0m\u001b[36;1m\u001b[1;3m['September 2023 Movies: The Creator • Dumb Money • Expend4bles • The Kill Room • The Inventor • The Equalizer 3 • PAW Patrol: The Mighty Movie, ...']\u001b[0m\u001b[32;1m\u001b[1;3m```json\n",
+      "{\n",
+      "    \"action\": \"Final Answer\",\n",
+      "    \"action_input\": \"Some movies that are showing on 9/21/2023 include 'The Creator', 'Dumb Money', 'Expend4bles', 'The Kill Room', 'The Inventor', 'The Equalizer 3', and 'PAW Patrol: The Mighty Movie'.\"\n",
+      "}\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Some movies that are showing on 9/21/2023 include 'The Creator', 'Dumb Money', 'Expend4bles', 'The Kill Room', 'The Inventor', 'The Equalizer 3', and 'PAW Patrol: The Mighty Movie'.\""
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"what are some movies showing 9/21/2023?\"})['output']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d464ead",
+   "metadata": {},
+   "source": [
+    "We can also initialize the agent executor with a predefined agent type"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "141f2469",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationBufferMemory\n",
+    "from langchain.chat_models import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "734d1b21",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\", return_messages=True)\n",
+    "llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, temperature=0)\n",
+    "agent_chain = initialize_agent(tools, llm, agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION, verbose=True, memory=memory)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/agents/agent_types/openai_functions_agent.ipynb

@@ -0,0 +1,295 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e10aa932",
+   "metadata": {},
+   "source": [
+    "# OpenAI functions\n",
+    "\n",
+    "Certain OpenAI models (like gpt-3.5-turbo-0613 and gpt-4-0613) have been fine-tuned to detect when a function should be called and respond with the inputs that should be passed to the function. In an API call, you can describe functions and have the model intelligently choose to output a JSON object containing arguments to call those functions. The goal of the OpenAI Function APIs is to more reliably return valid and useful function calls than a generic text completion or chat API.\n",
+    "\n",
+    "The OpenAI Functions Agent is designed to work with these models.\n",
+    "\n",
+    "Install `openai`, `google-search-results` packages which are required as the LangChain packages call them internally."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ec89be68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install openai google-search-results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "82787d8d",
+   "metadata": {},
+   "source": [
+    "## Initialize tools\n",
+    "\n",
+    "We will first create some tools we can use"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b812b982",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import initialize_agent, AgentType, Tool\n",
+    "from langchain.chains import LLMMathChain\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.utilities import SerpAPIWrapper, SQLDatabase\n",
+    "from langchain_experimental.sql import SQLDatabaseChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "23fc0aa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo-0613\")\n",
+    "search = SerpAPIWrapper()\n",
+    "llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)\n",
+    "db = SQLDatabase.from_uri(\"sqlite:///../../../../../notebooks/Chinook.db\")\n",
+    "db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events. You should ask targeted questions\"\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name=\"Calculator\",\n",
+    "        func=llm_math_chain.run,\n",
+    "        description=\"useful for when you need to answer questions about math\"\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name=\"FooBar-DB\",\n",
+    "        func=db_chain.run,\n",
+    "        description=\"useful for when you need to answer questions about FooBar. Input should be in the form of a question containing full context\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39c3ba21",
+   "metadata": {},
+   "source": [
+    "## Using LCEL\n",
+    "\n",
+    "We will first use LangChain Expression Language to create this agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eac103f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "55292bed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages([\n",
+    "    (\"system\", \"You are a helpful assistant\"),\n",
+    "    (\"user\", \"{input}\"),\n",
+    "    MessagesPlaceholder(variable_name=\"agent_scratchpad\"),\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "50f40df4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.tools.render import format_tool_to_openai_function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "552421b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_with_tools = llm.bind(\n",
+    "    functions=[format_tool_to_openai_function(t) for t in tools]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3cafa0a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.format_scratchpad import format_to_openai_functions\n",
+    "from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bf514eb4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"agent_scratchpad\": lambda x: format_to_openai_functions(x['intermediate_steps'])\n",
+    "} | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5125573e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "bdc7e506",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2cd65218",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `Search` with `Leo DiCaprio's girlfriend`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3m['Blake Lively and DiCaprio are believed to have enjoyed a whirlwind five-month romance in 2011. The pair were seen on a yacht together in Cannes, ...']\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `Calculator` with `0.43`\n",
+      "\n",
+      "\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Entering new LLMMathChain chain...\u001b[0m\n",
+      "0.43\u001b[32;1m\u001b[1;3m```text\n",
+      "0.43\n",
+      "```\n",
+      "...numexpr.evaluate(\"0.43\")...\n",
+      "\u001b[0m\n",
+      "Answer: \u001b[33;1m\u001b[1;3m0.43\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\u001b[33;1m\u001b[1;3mAnswer: 0.43\u001b[0m\u001b[32;1m\u001b[1;3mI'm sorry, but I couldn't find any information about Leo DiCaprio's current girlfriend. As for raising her age to the power of 0.43, I'm not sure what her current age is, so I can't provide an answer for that.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'input': \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\",\n",
+       " 'output': \"I'm sorry, but I couldn't find any information about Leo DiCaprio's current girlfriend. As for raising her age to the power of 0.43, I'm not sure what her current age is, so I can't provide an answer for that.\"}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8e91393f",
+   "metadata": {},
+   "source": [
+    "## Using OpenAIFunctionsAgent\n",
+    "\n",
+    "We can now use `OpenAIFunctionsAgent`, which creates this agent under the hood"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9ed07c8f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d9fb674",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor.invoke({\"input\": \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2bc581dc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/agents/agent_types/openai_multi_functions_agent.ipynb

@@ -444,9 +444,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "venv",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "name": "venv"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -458,7 +458,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/extras/modules/agents/agent_types/react.ipynb

@@ -0,0 +1,391 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d82e62ec",
+   "metadata": {},
+   "source": [
+    "# ReAct\n",
+    "\n",
+    "This walkthrough showcases using an agent to implement the [ReAct](https://react-lm.github.io/) logic."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "102b0e52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import load_tools\n",
+    "from langchain.agents import initialize_agent\n",
+    "from langchain.agents import AgentType\n",
+    "from langchain.llms import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e0c9c056",
+   "metadata": {},
+   "source": [
+    "First, let's load the language model we're going to use to control the agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "184f0682",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e67a000",
+   "metadata": {},
+   "source": [
+    "Next, let's load some tools to use. Note that the `llm-math` tool uses an LLM, so we need to pass that in."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "256408d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tools = load_tools([\"serpapi\", \"llm-math\"], llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b7d04f53",
+   "metadata": {},
+   "source": [
+    "## Using LCEL\n",
+    "\n",
+    "We will first show how to create the agent using LCEL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "bb0813a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.tools.render import render_text_description\n",
+    "from langchain.agents.output_parsers import ReActSingleInputOutputParser\n",
+    "from langchain.agents.format_scratchpad import format_log_to_str\n",
+    "from langchain import hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d3ae5fcd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = hub.pull(\"hwchase17/react\")\n",
+    "prompt = prompt.partial(\n",
+    "    tools=render_text_description(tools),\n",
+    "    tool_names=\", \".join([t.name for t in tools]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "bf47a3c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_with_stop = llm.bind(stop=[\"\\nObservation\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b3d3958b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"agent_scratchpad\": lambda x: format_log_to_str(x['intermediate_steps'])\n",
+    "} | prompt | llm_with_stop | ReActSingleInputOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0a57769",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "026de6cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "57780ce1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m I need to find out who Leo DiCaprio's girlfriend is and then calculate her age raised to the 0.43 power.\n",
+      "Action: Search\n",
+      "Action Input: \"Leo DiCaprio girlfriend\"\u001b[0m\u001b[36;1m\u001b[1;3mmodel Vittoria Ceretti\u001b[0m\u001b[32;1m\u001b[1;3m I need to find out Vittoria Ceretti's age\n",
+      "Action: Search\n",
+      "Action Input: \"Vittoria Ceretti age\"\u001b[0m\u001b[36;1m\u001b[1;3m25 years\u001b[0m\u001b[32;1m\u001b[1;3m I need to calculate 25 raised to the 0.43 power\n",
+      "Action: Calculator\n",
+      "Action Input: 25^0.43\u001b[0m\u001b[33;1m\u001b[1;3mAnswer: 3.991298452658078\u001b[0m\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: Leo DiCaprio's girlfriend is Vittoria Ceretti and her current age raised to the 0.43 power is 3.991298452658078.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'input': \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\",\n",
+       " 'output': \"Leo DiCaprio's girlfriend is Vittoria Ceretti and her current age raised to the 0.43 power is 3.991298452658078.\"}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4a33ea8",
+   "metadata": {},
+   "source": [
+    "## Using ZeroShotReactAgent\n",
+    "\n",
+    "We will now show how to use the agent with an off-the-shelf agent implementation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9752e90e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "04c5bcf6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m I need to find out who Leo DiCaprio's girlfriend is and then calculate her age raised to the 0.43 power.\n",
+      "Action: Search\n",
+      "Action Input: \"Leo DiCaprio girlfriend\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mmodel Vittoria Ceretti\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to find out Vittoria Ceretti's age\n",
+      "Action: Search\n",
+      "Action Input: \"Vittoria Ceretti age\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3m25 years\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to calculate 25 raised to the 0.43 power\n",
+      "Action: Calculator\n",
+      "Action Input: 25^0.43\u001b[0m\n",
+      "Observation: \u001b[33;1m\u001b[1;3mAnswer: 3.991298452658078\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: Leo DiCaprio's girlfriend is Vittoria Ceretti and her current age raised to the 0.43 power is 3.991298452658078.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'input': \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\",\n",
+       " 'output': \"Leo DiCaprio's girlfriend is Vittoria Ceretti and her current age raised to the 0.43 power is 3.991298452658078.\"}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f3e8fc8",
+   "metadata": {},
+   "source": [
+    "## Using chat models\n",
+    "\n",
+    "You can also create ReAct agents that use chat models instead of LLMs as the agent driver.\n",
+    "\n",
+    "The main difference here is a different prompt. We will use JSON to encode the agent's actions (chat models are a bit tougher to steet, so using JSON helps to enforce the output format)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6eeb1693",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "fe846c48",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat_model = ChatOpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "0843590d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = hub.pull(\"hwchase17/react-json\")\n",
+    "prompt = prompt.partial(\n",
+    "    tools=render_text_description(tools),\n",
+    "    tool_names=\", \".join([t.name for t in tools]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "a863b763",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat_model_with_stop = chat_model.bind(stop=[\"\\nObservation\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "deaeb1f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.output_parsers import ReActJsonSingleInputOutputParser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "6336a378",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"agent_scratchpad\": lambda x: format_log_to_str(x['intermediate_steps'])\n",
+    "} | prompt | chat_model_with_stop | ReActJsonSingleInputOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "13ad514e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a3394a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor.invoke({\"input\": \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ffc28e29",
+   "metadata": {},
+   "source": [
+    "We can also use an off-the-shelf agent class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6c41464c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "agent = initialize_agent(tools, chat_model, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)\n",
+    "agent.run(\"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/agents/agent_types/self_ask_with_search.ipynb

@@ -13,6 +13,154 @@
   {
    "cell_type": "code",
    "execution_count": 1,
+   "id": "2018da2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.utilities import SerpAPIWrapper\n",
+    "from langchain.agents import initialize_agent, Tool\n",
+    "from langchain.agents import AgentType\n",
+    "\n",
+    "llm = OpenAI(temperature=0)\n",
+    "search = SerpAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name=\"Intermediate Answer\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to ask with search\",\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "769c5940",
+   "metadata": {},
+   "source": [
+    "## Using LangChain Expression Language\n",
+    "\n",
+    "First we will show how to construct this agent from components using LangChain Expression Language"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6be0e94d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.output_parsers import SelfAskOutputParser\n",
+    "from langchain.agents.format_scratchpad import format_log_to_str\n",
+    "from langchain import hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "933ca47b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = hub.pull(\"hwchase17/self-ask-with-search\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d1437a27",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_with_stop = llm.bind(stop=[\"\\nIntermediate answer:\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d793401e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    # Use some custom observation_prefix/llm_prefix for formatting\n",
+    "    \"agent_scratchpad\": lambda x: format_log_to_str(\n",
+    "        x['intermediate_steps'], \n",
+    "        observation_prefix=\"\\nIntermediate answer: \",\n",
+    "        llm_prefix=\"\",\n",
+    "    ),\n",
+    "} | prompt | llm_with_stop | SelfAskOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "643c3bfa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "a1bb513c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5181f35f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m Yes.\n",
+      "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\u001b[36;1m\u001b[1;3mMen's US Open Tennis Champions Novak Djokovic earned his 24th major singles title against 2021 US Open champion Daniil Medvedev, 6-3, 7-6 (7-5), 6-3. The victory ties the Serbian player with the legendary Margaret Court for the most Grand Slam wins across both men's and women's singles.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Follow up: Where is Novak Djokovic from?\u001b[0m\u001b[36;1m\u001b[1;3mBelgrade, Serbia\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "So the final answer is: Belgrade, Serbia\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'input': \"What is the hometown of the reigning men's U.S. Open champion?\",\n",
+       " 'output': 'Belgrade, Serbia'}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"input\": \"What is the hometown of the reigning men's U.S. Open champion?\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6556f348",
+   "metadata": {},
+   "source": [
+    "## Use off-the-shelf agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
    "id": "7e3b513e",
    "metadata": {},
    "outputs": [
@@ -25,10 +173,11 @@
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
       "\u001b[32;1m\u001b[1;3m Yes.\n",
       "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\n",
-      "Intermediate answer: \u001b[36;1m\u001b[1;3mCarlos Alcaraz Garfia\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mFollow up: Where is Carlos Alcaraz Garfia from?\u001b[0m\n",
-      "Intermediate answer: \u001b[36;1m\u001b[1;3mEl Palmar, Spain\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mSo the final answer is: El Palmar, Spain\u001b[0m\n",
+      "Intermediate answer: \u001b[36;1m\u001b[1;3mMen's US Open Tennis Champions Novak Djokovic earned his 24th major singles title against 2021 US Open champion Daniil Medvedev, 6-3, 7-6 (7-5), 6-3. The victory ties the Serbian player with the legendary Margaret Court for the most Grand Slam wins across both men's and women's singles.\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\n",
+      "Follow up: Where is Novak Djokovic from?\u001b[0m\n",
+      "Intermediate answer: \u001b[36;1m\u001b[1;3mBelgrade, Serbia\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mSo the final answer is: Belgrade, Serbia\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -36,29 +185,15 @@
     {
      "data": {
       "text/plain": [
-       "'El Palmar, Spain'"
+       "'Belgrade, Serbia'"
       ]
      },
-     "execution_count": 1,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "from langchain.llms import OpenAI\nfrom langchain.utilities import SerpAPIWrapper\n",
-    "from langchain.agents import initialize_agent, Tool\n",
-    "from langchain.agents import AgentType\n",
-    "\n",
-    "llm = OpenAI(temperature=0)\n",
-    "search = SerpAPIWrapper()\n",
-    "tools = [\n",
-    "    Tool(\n",
-    "        name=\"Intermediate Answer\",\n",
-    "        func=search.run,\n",
-    "        description=\"useful for when you need to ask with search\",\n",
-    "    )\n",
-    "]\n",
-    "\n",
     "self_ask_with_search = initialize_agent(\n",
     "    tools, llm, agent=AgentType.SELF_ASK_WITH_SEARCH, verbose=True\n",
     ")\n",
@@ -92,7 +227,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.1"
   },
   "vscode": {
    "interpreter": {

docs/extras/modules/agents/agent_types/structured_chat.ipynb

@@ -0,0 +1,330 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2ac2115b",
+   "metadata": {},
+   "source": [
+    "# Structured tool chat\n",
+    "\n",
+    "The structured tool chat agent is capable of using multi-input tools.\n",
+    "\n",
+    "Older agents are configured to specify an action input as a single string, but this agent can use the provided tools' `args_schema` to populate the action input.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "68d58093",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentType\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.agents import initialize_agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9414475b",
+   "metadata": {},
+   "source": [
+    "## Initialize Tools\n",
+    "\n",
+    "We will test the agent using a web browser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a990cea8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.agent_toolkits import PlayWrightBrowserToolkit\n",
+    "from langchain.tools.playwright.utils import (\n",
+    "    create_async_playwright_browser,\n",
+    "    create_sync_playwright_browser, # A synchronous browser is available, though it isn't compatible with jupyter.\n",
+    ")\n",
+    "\n",
+    "# This import is required only for jupyter notebooks, since they have their own eventloop\n",
+    "import nest_asyncio\n",
+    "nest_asyncio.apply()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "536fa92a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install playwright\n",
+    "\n",
+    "!playwright install"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "daa3d594",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "async_browser = create_async_playwright_browser()\n",
+    "browser_toolkit = PlayWrightBrowserToolkit.from_browser(async_browser=async_browser)\n",
+    "tools = browser_toolkit.get_tools()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3089aa8",
+   "metadata": {},
+   "source": [
+    "## Use LCEL\n",
+    "\n",
+    "We can first construct this agent using LangChain Expression Language"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf35a623",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "319e6c40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = hub.pull(\"hwchase17/react-multi-input-json\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "38c6496f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.tools.render import render_text_description_and_args"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "d25b216f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = prompt.partial(\n",
+    "    tools=render_text_description_and_args(tools),\n",
+    "    tool_names=\", \".join([t.name for t in tools]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "fffcad76",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = ChatOpenAI(temperature=0)\n",
+    "llm_with_stop = llm.bind(stop=[\"Observation\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2ceceadb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.output_parsers import JSONAgentOutputParser\n",
+    "from langchain.agents.format_scratchpad import format_log_to_str"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "d410855f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"agent_scratchpad\": lambda x: format_log_to_str(x['intermediate_steps']),\n",
+    "} | prompt | llm_with_stop | JSONAgentOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "470b0859",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "b62702b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "97c15ef5",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mAction:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"navigate_browser\",\n",
+      "  \"action_input\": {\n",
+      "    \"url\": \"https://blog.langchain.dev\"\n",
+      "  }\n",
+      "}\n",
+      "```\n",
+      "\u001b[0m\u001b[33;1m\u001b[1;3mNavigating to https://blog.langchain.dev returned status code 200\u001b[0m\u001b[32;1m\u001b[1;3mAction:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"extract_text\",\n",
+      "  \"action_input\": {}\n",
+      "}\n",
+      "```\n",
+      "\n",
+      "\u001b[0m\u001b[31;1m\u001b[1;3mLangChain LangChain Home GitHub Docs By LangChain Release Notes Write with Us Sign in Subscribe The official LangChain blog. Subscribe now Login Featured Posts Announcing LangChain Hub Using LangSmith to Support Fine-tuning Announcing LangSmith, a unified platform for debugging, testing, evaluating, and monitoring your LLM applications Sep 20 Peering Into the Soul of AI Decision-Making with LangSmith 10 min read Sep 20 LangChain + Docugami Webinar: Lessons from Deploying LLMs with LangSmith 3 min read Sep 18 TED AI Hackathon Kickoff (and projects we’d love to see) 2 min read Sep 12 How to Safely Query Enterprise Data with LangChain Agents + SQL + OpenAI + Gretel 6 min read Sep 12 OpaquePrompts x LangChain: Enhance the privacy of your LangChain application with just one code change 4 min read Load more LangChain © 2023 Sign up Powered by Ghost\u001b[0m\u001b[32;1m\u001b[1;3mAction:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"Final Answer\",\n",
+      "  \"action_input\": \"The LangChain blog features posts on topics such as using LangSmith for fine-tuning, AI decision-making with LangSmith, deploying LLMs with LangSmith, and more. It also includes information on LangChain Hub and upcoming webinars. LangChain is a platform for debugging, testing, evaluating, and monitoring LLM applications.\"\n",
+      "}\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "The LangChain blog features posts on topics such as using LangSmith for fine-tuning, AI decision-making with LangSmith, deploying LLMs with LangSmith, and more. It also includes information on LangChain Hub and upcoming webinars. LangChain is a platform for debugging, testing, evaluating, and monitoring LLM applications.\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = await agent_executor.ainvoke({\"input\": \"Browse to blog.langchain.dev and summarize the text, please.\"})\n",
+    "print(response['output'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62fc1fdf",
+   "metadata": {},
+   "source": [
+    "## Use off the shelf agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "4b585225",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = ChatOpenAI(temperature=0) # Also works well with Anthropic models\n",
+    "agent_chain = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c2a9e29c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mAction:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"navigate_browser\",\n",
+      "  \"action_input\": {\n",
+      "    \"url\": \"https://blog.langchain.dev\"\n",
+      "  }\n",
+      "}\n",
+      "```\u001b[0m\n",
+      "Observation: \u001b[33;1m\u001b[1;3mNavigating to https://blog.langchain.dev returned status code 200\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3mI have successfully navigated to the blog.langchain.dev website. Now I need to extract the text from the webpage to summarize it.\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"extract_text\",\n",
+      "  \"action_input\": {}\n",
+      "}\n",
+      "```\u001b[0m\n",
+      "Observation: \u001b[31;1m\u001b[1;3mLangChain LangChain Home GitHub Docs By LangChain Release Notes Write with Us Sign in Subscribe The official LangChain blog. Subscribe now Login Featured Posts Announcing LangChain Hub Using LangSmith to Support Fine-tuning Announcing LangSmith, a unified platform for debugging, testing, evaluating, and monitoring your LLM applications Sep 20 Peering Into the Soul of AI Decision-Making with LangSmith 10 min read Sep 20 LangChain + Docugami Webinar: Lessons from Deploying LLMs with LangSmith 3 min read Sep 18 TED AI Hackathon Kickoff (and projects we’d love to see) 2 min read Sep 12 How to Safely Query Enterprise Data with LangChain Agents + SQL + OpenAI + Gretel 6 min read Sep 12 OpaquePrompts x LangChain: Enhance the privacy of your LangChain application with just one code change 4 min read Load more LangChain © 2023 Sign up Powered by Ghost\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3mI have successfully navigated to the blog.langchain.dev website. The text on the webpage includes featured posts such as \"Announcing LangChain Hub,\" \"Using LangSmith to Support Fine-tuning,\" \"Peering Into the Soul of AI Decision-Making with LangSmith,\" \"LangChain + Docugami Webinar: Lessons from Deploying LLMs with LangSmith,\" \"TED AI Hackathon Kickoff (and projects we’d love to see),\" \"How to Safely Query Enterprise Data with LangChain Agents + SQL + OpenAI + Gretel,\" and \"OpaquePrompts x LangChain: Enhance the privacy of your LangChain application with just one code change.\" There are also links to other pages on the website.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "I have successfully navigated to the blog.langchain.dev website. The text on the webpage includes featured posts such as \"Announcing LangChain Hub,\" \"Using LangSmith to Support Fine-tuning,\" \"Peering Into the Soul of AI Decision-Making with LangSmith,\" \"LangChain + Docugami Webinar: Lessons from Deploying LLMs with LangSmith,\" \"TED AI Hackathon Kickoff (and projects we’d love to see),\" \"How to Safely Query Enterprise Data with LangChain Agents + SQL + OpenAI + Gretel,\" and \"OpaquePrompts x LangChain: Enhance the privacy of your LangChain application with just one code change.\" There are also links to other pages on the website.\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = await agent_chain.ainvoke({\"input\": \"Browse to blog.langchain.dev and summarize the text, please.\"})\n",
+    "print(response['output'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc3ce811",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/agents/agent_types/xml_agent.ipynb

@@ -11,34 +11,24 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f9d2ead2",
+   "cell_type": "markdown",
+   "id": "fe972808",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "from langchain.agents import XMLAgent, tool, AgentExecutor\n",
-    "from langchain.chat_models import ChatAnthropic\n",
-    "from langchain.chains import LLMChain"
+    "## Initialize the tools\n",
+    "\n",
+    "We will initialize some fake tools for demo purposes"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "ebadf04f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = ChatAnthropic(model=\"claude-2\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "6ce9f9a5",
+   "execution_count": 1,
+   "id": "ba547497",
    "metadata": {},
    "outputs": [],
    "source": [
+    "from langchain.agents import tool\n",
+    "\n",
     "@tool\n",
     "def search(query: str) -> str:\n",
     "    \"\"\"Search things about current events.\"\"\"\n",
@@ -47,17 +37,174 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "c589944e",
+   "execution_count": 6,
+   "id": "e30e99e2",
    "metadata": {},
    "outputs": [],
    "source": [
-    "tool_list = [search]"
+    "tools = [search]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 2,
+   "id": "401db6ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatAnthropic\n",
+    "model = ChatAnthropic(model=\"claude-2\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90f83099",
+   "metadata": {},
+   "source": [
+    "## Use LangChain Expression Language\n",
+    "\n",
+    "We will first show how to create this agent using LangChain Expression Language"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "78937679",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.tools.render import render_text_description\n",
+    "from langchain.agents.output_parsers import XMLAgentOutputParser\n",
+    "from langchain.agents.format_scratchpad import format_xml\n",
+    "from langchain import hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "54fc5a22",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = hub.pull(\"hwchase17/xml-agent\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b1802fcc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = prompt.partial(\n",
+    "    tools=render_text_description(tools),\n",
+    "    tool_names=\", \".join([t.name for t in tools]),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f9d2ead2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_with_stop = model.bind(stop=[\"</tool_input>\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "ebadf04f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = {\n",
+    "    \"question\": lambda x: x[\"question\"],\n",
+    "    \"agent_scratchpad\": lambda x: format_xml(x['intermediate_steps']),\n",
+    "} | prompt | llm_with_stop | XMLAgentOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4e2bb03e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentExecutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "6ce9f9a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "e14affef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m <tool>search</tool>\n",
+      "<tool_input>weather in new york\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m <tool>search</tool>\n",
+      "<tool_input>weather in new york\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m <final_answer>\n",
+      "The weather in New York is 32 degrees.\n",
+      "</final_answer>\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'whats the weather in New york?',\n",
+       " 'output': '\\nThe weather in New York is 32 degrees.\\n'}"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"question\": \"whats the weather in New york?\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42ff473d",
+   "metadata": {},
+   "source": [
+    "## Use off-the-shelf agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "7e5e73e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import LLMChain\n",
+    "from langchain.agents import XMLAgent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
    "id": "2d8454be",
    "metadata": {},
    "outputs": [],
@@ -67,22 +214,22 @@
     "    prompt=XMLAgent.get_default_prompt(),\n",
     "    output_parser=XMLAgent.get_default_output_parser()\n",
     ")\n",
-    "agent = XMLAgent(tools=tool_list, llm_chain=chain)"
+    "agent = XMLAgent(tools=tools, llm_chain=chain)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 25,
    "id": "bca6096f",
    "metadata": {},
    "outputs": [],
    "source": [
-    "agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True)"
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 28,
    "id": "71b872b1",
    "metadata": {},
    "outputs": [
@@ -94,7 +241,7 @@
       "\n",
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
       "\u001b[32;1m\u001b[1;3m <tool>search</tool>\n",
-      "<tool_input>weather in New York\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "<tool_input>weather in new york\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m\n",
       "\n",
       "<final_answer>The weather in New York is 32 degrees\u001b[0m\n",
       "\n",
@@ -104,16 +251,17 @@
     {
      "data": {
       "text/plain": [
-       "'The weather in New York is 32 degrees'"
+       "{'input': 'whats the weather in New york?',\n",
+       " 'output': 'The weather in New York is 32 degrees'}"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "agent_executor.run(\"whats the weather in New york?\")"
+    "agent_executor.invoke({\"input\": \"whats the weather in New york?\"})"
    ]
   },
   {

docs/extras/modules/data_connection/retrievers/self_query/timescalevector_self_query.ipynb

@@ -0,0 +1,534 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "13afcae7",
+   "metadata": {},
+   "source": [
+    "# Timescale Vector (Postgres) self-querying \n",
+    "\n",
+    "[Timescale Vector](https://www.timescale.com/ai) is PostgreSQL++ for AI applications. It enables you to efficiently store and query billions of vector embeddings in `PostgreSQL`.\n",
+    "\n",
+    "This notebook shows how to use the Postgres vector database (`TimescaleVector`) to perform self-querying. In the notebook we'll demo the `SelfQueryRetriever` wrapped around a TimescaleVector vector store. \n",
+    "\n",
+    "## What is Timescale Vector?\n",
+    "**[Timescale Vector](https://www.timescale.com/ai) is PostgreSQL++ for AI applications.**\n",
+    "\n",
+    "Timescale Vector enables you to efficiently store and query millions of vector embeddings in `PostgreSQL`.\n",
+    "- Enhances `pgvector` with faster and more accurate similarity search on 1B+ vectors via DiskANN inspired indexing algorithm.\n",
+    "- Enables fast time-based vector search via automatic time-based partitioning and indexing.\n",
+    "- Provides a familiar SQL interface for querying vector embeddings and relational data.\n",
+    "\n",
+    "Timescale Vector is cloud PostgreSQL for AI that scales with you from POC to production:\n",
+    "- Simplifies operations by enabling you to store relational metadata, vector embeddings, and time-series data in a single database.\n",
+    "- Benefits from rock-solid PostgreSQL foundation with enterprise-grade feature liked streaming backups and replication, high-availability and row-level security.\n",
+    "- Enables a worry-free experience with enterprise-grade security and compliance.\n",
+    "\n",
+    "## How to access Timescale Vector\n",
+    "Timescale Vector is available on [Timescale](https://www.timescale.com/ai), the cloud PostgreSQL platform. (There is no self-hosted version at this time.)\n",
+    "\n",
+    "LangChain users get a 90-day free trial for Timescale Vector.\n",
+    "- To get started, [signup](https://console.cloud.timescale.com/signup?utm_campaign=vectorlaunch&utm_source=langchain&utm_medium=referral) to Timescale, create a new database and follow this notebook!\n",
+    "- See the [Timescale Vector explainer blog](https://www.timescale.com/blog/how-we-made-postgresql-the-best-vector-database/?utm_campaign=vectorlaunch&utm_source=langchain&utm_medium=referral) for more details and performance benchmarks.\n",
+    "- See the [installation instructions](https://github.com/timescale/python-vector) for more details on using Timescale Vector in python.\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "68e75fb9",
+   "metadata": {},
+   "source": [
+    "## Creating a TimescaleVector vectorstore\n",
+    "First we'll want to create a Timescale Vector vectorstore and seed it with some data. We've created a small demo set of documents that contain summaries of movies.\n",
+    "\n",
+    "NOTE: The self-query retriever requires you to have `lark` installed (`pip install lark`). We also need the `timescale-vector` package."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "63a8af5b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#!pip install lark"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "22431060-52c4-48a7-a97b-9f542b8b0928",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#!pip install timescale-vector "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "83811610-7df3-4ede-b268-68a6a83ba9e2",
+   "metadata": {},
+   "source": [
+    "In this example, we'll use `OpenAIEmbeddings`, so let's load your OpenAI API key."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "dd01b61b-7d32-4a55-85d6-b2d2d4f18840",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Get openAI api key by reading local .env file\n",
+    "# The .env file should contain a line starting with `OPENAI_API_KEY=sk-`\n",
+    "import os\n",
+    "from dotenv import load_dotenv, find_dotenv\n",
+    "_ = load_dotenv(find_dotenv())\n",
+    "\n",
+    "OPENAI_API_KEY  = os.environ['OPENAI_API_KEY']\n",
+    "# Alternatively, use getpass to enter the key in a prompt\n",
+    "#import os\n",
+    "#import getpass\n",
+    "#os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "766e9c4b",
+   "metadata": {},
+   "source": [
+    "To connect to your PostgreSQL database, you'll need your service URI, which can be found in the cheatsheet or `.env` file you downloaded after creating a new database. \n",
+    "\n",
+    "If you haven't already, [signup for Timescale](https://console.cloud.timescale.com/signup?utm_campaign=vectorlaunch&utm_source=langchain&utm_medium=referral), and create a new database.\n",
+    "\n",
+    "The URI will look something like this: `postgres://tsdbadmin:<password>@<id>.tsdb.cloud.timescale.com:<port>/tsdb?sslmode=require`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6bd6877e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get the service url by reading local .env file\n",
+    "# The .env file should contain a line starting with `TIMESCALE_SERVICE_URL=postgresql://`\n",
+    "_ = load_dotenv(find_dotenv())\n",
+    "TIMESCALE_SERVICE_URL = os.environ[\"TIMESCALE_SERVICE_URL\"]\n",
+    "\n",
+    "# Alternatively, use getpass to enter the key in a prompt\n",
+    "#import os\n",
+    "#import getpass\n",
+    "#TIMESCALE_SERVICE_URL = getpass.getpass(\"Timescale Service URL:\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cb4a5787",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.schema import Document\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.vectorstores.timescalevector import TimescaleVector\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a4f863f5",
+   "metadata": {},
+   "source": [
+    "Here's the sample documents we'll use for this demo. The data is about movies, and has both content and metadata fields with information about particular movie."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "bcbe04d9",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "docs = [\n",
+    "    Document(\n",
+    "        page_content=\"A bunch of scientists bring back dinosaurs and mayhem breaks loose\",\n",
+    "        metadata={\"year\": 1993, \"rating\": 7.7, \"genre\": \"science fiction\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Leo DiCaprio gets lost in a dream within a dream within a dream within a ...\",\n",
+    "        metadata={\"year\": 2010, \"director\": \"Christopher Nolan\", \"rating\": 8.2},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea\",\n",
+    "        metadata={\"year\": 2006, \"director\": \"Satoshi Kon\", \"rating\": 8.6},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"A bunch of normal-sized women are supremely wholesome and some men pine after them\",\n",
+    "        metadata={\"year\": 2019, \"director\": \"Greta Gerwig\", \"rating\": 8.3},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Toys come alive and have a blast doing so\",\n",
+    "        metadata={\"year\": 1995, \"genre\": \"animated\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Three men walk into the Zone, three men walk out of the Zone\",\n",
+    "        metadata={\n",
+    "            \"year\": 1979,\n",
+    "            \"rating\": 9.9,\n",
+    "            \"director\": \"Andrei Tarkovsky\",\n",
+    "            \"genre\": \"science fiction\",\n",
+    "            \"rating\": 9.9,\n",
+    "        },\n",
+    "    ),\n",
+    "]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "7d0d771e",
+   "metadata": {},
+   "source": [
+    "Finally, we'll create our Timescale Vector vectorstore. Note that the collection name will be the name of the PostgreSQL table in which the documents are stored in."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2428d1ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "COLLECTION_NAME = \"langchain_self_query_demo\"\n",
+    "vectorstore = TimescaleVector.from_documents(\n",
+    "    embedding=embeddings,\n",
+    "    documents=docs,\n",
+    "    collection_name=COLLECTION_NAME,\n",
+    "    service_url=TIMESCALE_SERVICE_URL,\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "5ecaab6d",
+   "metadata": {},
+   "source": [
+    "## Creating our self-querying retriever\n",
+    "Now we can instantiate our retriever. To do this we'll need to provide some information upfront about the metadata fields that our documents support and a short description of the document contents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "86e34dbf",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.retrievers.self_query.base import SelfQueryRetriever\n",
+    "from langchain.chains.query_constructor.base import AttributeInfo\n",
+    "\n",
+    "# Give LLM info about the metadata fields\n",
+    "metadata_field_info = [\n",
+    "    AttributeInfo(\n",
+    "        name=\"genre\",\n",
+    "        description=\"The genre of the movie\",\n",
+    "        type=\"string or list[string]\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"year\",\n",
+    "        description=\"The year the movie was released\",\n",
+    "        type=\"integer\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"director\",\n",
+    "        description=\"The name of the movie director\",\n",
+    "        type=\"string\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"rating\", description=\"A 1-10 rating for the movie\", type=\"float\"\n",
+    "    ),\n",
+    "]\n",
+    "document_content_description = \"Brief summary of a movie\"\n",
+    "\n",
+    "# Instantiate the self-query retriever from an LLM\n",
+    "llm = OpenAI(temperature=0)\n",
+    "retriever = SelfQueryRetriever.from_llm(\n",
+    "    llm, vectorstore, document_content_description, metadata_field_info, verbose=True\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "ea9df8d4",
+   "metadata": {},
+   "source": [
+    "## Self Querying Retrieval with Timescale Vector\n",
+    "And now we can try actually using our retriever!\n",
+    "\n",
+    "Run the queries below and note how you can specify a query, filter, composite filter (filters with AND, OR) in natural language and the self-query retriever will translate that query into SQL and perform the search on the Timescale Vector (Postgres) vectorstore.\n",
+    "\n",
+    "This illustrates the power of the self-query retriever. You can use it to perform complex searches over your vectorstore without you or your users having to write any SQL directly!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "38a126e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/avtharsewrathan/sideprojects2023/timescaleai/tsv-langchain/langchain/libs/langchain/langchain/chains/llm.py:275: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query='dinosaur' filter=None limit=None\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'year': 1993, 'genre': 'science fiction', 'rating': 7.7}),\n",
+       " Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'year': 1993, 'genre': 'science fiction', 'rating': 7.7}),\n",
+       " Document(page_content='Toys come alive and have a blast doing so', metadata={'year': 1995, 'genre': 'animated'}),\n",
+       " Document(page_content='Toys come alive and have a blast doing so', metadata={'year': 1995, 'genre': 'animated'})]"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This example only specifies a relevant query\n",
+    "retriever.get_relevant_documents(\"What are some movies about dinosaurs\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "fc3f1e6e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query=' ' filter=Comparison(comparator=<Comparator.GT: 'gt'>, attribute='rating', value=8.5) limit=None\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'year': 1979, 'genre': 'science fiction', 'rating': 9.9, 'director': 'Andrei Tarkovsky'}),\n",
+       " Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'year': 1979, 'genre': 'science fiction', 'rating': 9.9, 'director': 'Andrei Tarkovsky'}),\n",
+       " Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'year': 2006, 'rating': 8.6, 'director': 'Satoshi Kon'}),\n",
+       " Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'year': 2006, 'rating': 8.6, 'director': 'Satoshi Kon'})]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This example only specifies a filter\n",
+    "retriever.get_relevant_documents(\"I want to watch a movie rated higher than 8.5\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "b19d4da0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query='women' filter=Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='director', value='Greta Gerwig') limit=None\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='A bunch of normal-sized women are supremely wholesome and some men pine after them', metadata={'year': 2019, 'rating': 8.3, 'director': 'Greta Gerwig'}),\n",
+       " Document(page_content='A bunch of normal-sized women are supremely wholesome and some men pine after them', metadata={'year': 2019, 'rating': 8.3, 'director': 'Greta Gerwig'})]"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This example specifies a query and a filter\n",
+    "retriever.get_relevant_documents(\"Has Greta Gerwig directed any movies about women\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "f900e40e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query=' ' filter=Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.GTE: 'gte'>, attribute='rating', value=8.5), Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='genre', value='science fiction')]) limit=None\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'year': 1979, 'genre': 'science fiction', 'rating': 9.9, 'director': 'Andrei Tarkovsky'}),\n",
+       " Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'year': 1979, 'genre': 'science fiction', 'rating': 9.9, 'director': 'Andrei Tarkovsky'})]"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This example specifies a composite filter\n",
+    "retriever.get_relevant_documents(\n",
+    "    \"What's a highly rated (above 8.5) science fiction film?\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "12a51522",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query='toys' filter=Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.GT: 'gt'>, attribute='year', value=1990), Comparison(comparator=<Comparator.LT: 'lt'>, attribute='year', value=2005), Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='genre', value='animated')]) limit=None\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='Toys come alive and have a blast doing so', metadata={'year': 1995, 'genre': 'animated'})]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This example specifies a query and composite filter\n",
+    "retriever.get_relevant_documents(\n",
+    "    \"What's a movie after 1990 but before 2005 that's all about toys, and preferably is animated\"\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "39bd1de1-b9fe-4a98-89da-58d8a7a6ae51",
+   "metadata": {},
+   "source": [
+    "### Filter k\n",
+    "\n",
+    "We can also use the self query retriever to specify `k`: the number of documents to fetch.\n",
+    "\n",
+    "We can do this by passing `enable_limit=True` to the constructor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "bff36b88-b506-4877-9c63-e5a1a8d78e64",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "retriever = SelfQueryRetriever.from_llm(\n",
+    "    llm,\n",
+    "    vectorstore,\n",
+    "    document_content_description,\n",
+    "    metadata_field_info,\n",
+    "    enable_limit=True,\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "2758d229-4f97-499c-819f-888acaf8ee10",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query='dinosaur' filter=None limit=2\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'year': 1993, 'genre': 'science fiction', 'rating': 7.7}),\n",
+       " Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'year': 1993, 'genre': 'science fiction', 'rating': 7.7})]"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This example specifies a query with a LIMIT value\n",
+    "retriever.get_relevant_documents(\"what are two movies about dinosaurs\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/model_io/output_parsers/xml.ipynb

@@ -0,0 +1,213 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "181b5b6d",
+   "metadata": {},
+   "source": [
+    "# XML parser\n",
+    "This output parser allows users to obtain results from LLM in the popular XML format. \n",
+    "\n",
+    "Keep in mind that large language models are leaky abstractions! You'll have to use an LLM with sufficient capacity to generate well-formed XML. \n",
+    "\n",
+    "In the following example we use Claude model (https://docs.anthropic.com/claude/docs) which works really well with XML tags."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3b10fc55",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.llms import Anthropic\n",
+    "from langchain.output_parsers import XMLOutputParser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "909161d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/llms/anthropic.py:171: UserWarning: This Anthropic LLM is deprecated. Please use `from langchain.chat_models import ChatAnthropic` instead\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = Anthropic(model=\"claude-2\", max_tokens_to_sample=512, temperature=0.1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da312f86-0d2a-4aef-a09d-1e72bd0ea9b1",
+   "metadata": {},
+   "source": [
+    "Let's start with the simple request to the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b03785af-69fc-40a1-a1be-c04ed6fade70",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Here is the shortened filmography for Tom Hanks enclosed in <movie> tags:\n",
+      "\n",
+      "<movie>Splash (1984)</movie>\n",
+      "<movie>Big (1988)</movie> \n",
+      "<movie>A League of Their Own (1992)</movie>\n",
+      "<movie>Sleepless in Seattle (1993)</movie>  \n",
+      "<movie>Forrest Gump (1994)</movie>\n",
+      "<movie>Apollo 13 (1995)</movie>\n",
+      "<movie>Toy Story (1995)</movie>\n",
+      "<movie>Saving Private Ryan (1998)</movie>\n",
+      "<movie>Cast Away (2000)</movie>\n",
+      "<movie>The Da Vinci Code (2006)</movie>\n",
+      "<movie>Toy Story 3 (2010)</movie>\n",
+      "<movie>Captain Phillips (2013)</movie>\n",
+      "<movie>Bridge of Spies (2015)</movie>\n",
+      "<movie>Toy Story 4 (2019)</movie>\n"
+     ]
+    }
+   ],
+   "source": [
+    "actor_query = \"Generate the shortened filmography for Tom Hanks.\"\n",
+    "output = model(\n",
+    "    f\"\"\"\n",
+    "\n",
+    "Human:\n",
+    "{actor_query}\n",
+    "Please enclose the movies in <movie></movie> tags\n",
+    "Assistant:\n",
+    "\"\"\"\n",
+    ")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4db65781-3d54-4ba6-ae26-5b4ead47a4c8",
+   "metadata": {},
+   "source": [
+    "Now we will use the XMLOutputParser in order to get the structured output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "87ba8d11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'filmography': [{'movie': [{'title': 'Splash'}, {'year': '1984'}]}, {'movie': [{'title': 'Big'}, {'year': '1988'}]}, {'movie': [{'title': 'A League of Their Own'}, {'year': '1992'}]}, {'movie': [{'title': 'Sleepless in Seattle'}, {'year': '1993'}]}, {'movie': [{'title': 'Forrest Gump'}, {'year': '1994'}]}, {'movie': [{'title': 'Toy Story'}, {'year': '1995'}]}, {'movie': [{'title': 'Apollo 13'}, {'year': '1995'}]}, {'movie': [{'title': 'Saving Private Ryan'}, {'year': '1998'}]}, {'movie': [{'title': 'Cast Away'}, {'year': '2000'}]}, {'movie': [{'title': 'Catch Me If You Can'}, {'year': '2002'}]}, {'movie': [{'title': 'The Polar Express'}, {'year': '2004'}]}, {'movie': [{'title': 'Bridge of Spies'}, {'year': '2015'}]}]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "parser = XMLOutputParser()\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    template=\"\"\"\n",
+    "    \n",
+    "    Human:\n",
+    "    {query}\n",
+    "    {format_instructions}\n",
+    "    Assistant:\"\"\",\n",
+    "    input_variables=[\"query\"],\n",
+    "    partial_variables={\"format_instructions\": parser.get_format_instructions()},\n",
+    ")\n",
+    "\n",
+    "chain = prompt | model | parser\n",
+    "\n",
+    "output = chain.invoke({\"query\": actor_query})\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "327f5479-77e0-4549-8393-2cd7a286d491",
+   "metadata": {},
+   "source": [
+    "Finally, let's add some tags to tailor the output to our needs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b722a235",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'movies': [{'actor': [{'name': 'Tom Hanks'}, {'film': [{'name': 'Splash'}, {'genre': 'Comedy'}]}, {'film': [{'name': 'Big'}, {'genre': 'Comedy'}]}, {'film': [{'name': 'A League of Their Own'}, {'genre': 'Comedy'}]}, {'film': [{'name': 'Sleepless in Seattle'}, {'genre': 'Romance'}]}, {'film': [{'name': 'Forrest Gump'}, {'genre': 'Drama'}]}, {'film': [{'name': 'Toy Story'}, {'genre': 'Animation'}]}, {'film': [{'name': 'Apollo 13'}, {'genre': 'Drama'}]}, {'film': [{'name': 'Saving Private Ryan'}, {'genre': 'War'}]}, {'film': [{'name': 'Cast Away'}, {'genre': 'Adventure'}]}, {'film': [{'name': 'The Green Mile'}, {'genre': 'Drama'}]}]}]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "parser = XMLOutputParser(tags=[\"movies\", \"actor\", \"film\", \"name\", \"genre\"])\n",
+    "prompt = PromptTemplate(\n",
+    "    template=\"\"\"\n",
+    "    \n",
+    "    Human:\n",
+    "    {query}\n",
+    "    {format_instructions}\n",
+    "    Assistant:\"\"\",\n",
+    "    input_variables=[\"query\"],\n",
+    "    partial_variables={\"format_instructions\": parser.get_format_instructions()},\n",
+    ")\n",
+    "\n",
+    "\n",
+    "chain = prompt | model | parser\n",
+    "\n",
+    "output = chain.invoke({\"query\": actor_query})\n",
+    "\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "808a5df5-b11e-42a0-bd7a-6b95ca0c3eba",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/use_cases/more/agents/autonomous_agents/plan_and_execute.mdx

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

docs/extras/use_cases/more/data_generation.ipynb

@@ -0,0 +1,437 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "aa3571cc",
+   "metadata": {},
+   "source": [
+    "# Data generation\n",
+    "\n",
+    "[![Open In Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/extras/use_cases/data_generation.ipynb)\n",
+    "\n",
+    "## Use case\n",
+    "\n",
+    "Creating synthethic language data can be beneficial for multiple reasons:\n",
+    "- providing data augmentation\n",
+    "- obtaining domain-specific examples\n",
+    "- increasing data diversity\n",
+    "- enabling quick iteration and experimentation\n",
+    "\n",
+    "## Quickstart\n",
+    "\n",
+    "Let's see a very straightforward example of how we can use OpenAI functions for creating synthetic data in LangChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ae36b66",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "!pip install langchain openai \n",
+    "\n",
+    "# Set env var OPENAI_API_KEY or load from a .env file:\n",
+    "# import dotenv\n",
+    "# dotenv.load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9e715d94",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain_experimental.synthetic_data import create_data_generation_chain, DatasetGenerator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "94fccedd",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# LLM\n",
+    "model = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0.7)\n",
+    "chain = create_data_generation_chain(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4314c3ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'fields': ['blue', 'yellow'],\n",
+       " 'preferences': {},\n",
+       " 'text': 'The vibrant blue sky contrasted beautifully with the bright yellow sun, creating a stunning display of colors that instantly lifted the spirits of all who gazed upon it.'}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain({\"fields\": [\"blue\", \"yellow\"], \"preferences\": {}})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b116c487",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'fields': {'colors': ['blue', 'yellow']},\n",
+       " 'preferences': {'style': 'Make it in a style of a weather forecast.'},\n",
+       " 'text': \"Good morning! Today's weather forecast brings a beautiful combination of colors to the sky, with hues of blue and yellow gently blending together like a mesmerizing painting.\"}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain({\"fields\": {\"colors\": [\"blue\", \"yellow\"]}, \"preferences\": {\"style\": \"Make it in a style of a weather forecast.\"}})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ff823394",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'fields': {'actor': 'Tom Hanks', 'movies': ['Forrest Gump', 'Green Mile']},\n",
+       " 'preferences': None,\n",
+       " 'text': 'Tom Hanks, the renowned actor known for his incredible versatility and charm, has graced the silver screen in unforgettable movies such as \"Forrest Gump\" and \"Green Mile\".'}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain({\"fields\": {\"actor\": \"Tom Hanks\", \"movies\": [\"Forrest Gump\", \"Green Mile\"]}, \"preferences\": None})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "1ea1ad5b",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'fields': [{'actor': 'Tom Hanks', 'movies': ['Forrest Gump', 'Green Mile']},\n",
+       "  {'actor': 'Mads Mikkelsen', 'movies': ['Hannibal', 'Another round']}],\n",
+       " 'preferences': {'minimum_length': 200, 'style': 'gossip'},\n",
+       " 'text': 'Did you know that Tom Hanks, the beloved Hollywood actor known for his roles in \"Forrest Gump\" and \"Green Mile\", has shared the screen with the talented Mads Mikkelsen, who gained international acclaim for his performances in \"Hannibal\" and \"Another round\"? These two incredible actors have brought their exceptional skills and captivating charisma to the big screen, delivering unforgettable performances that have enthralled audiences around the world. Whether it\\'s Hanks\\' endearing portrayal of Forrest Gump or Mikkelsen\\'s chilling depiction of Hannibal Lecter, these movies have solidified their places in cinematic history, leaving a lasting impact on viewers and cementing their status as true icons of the silver screen.'}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain(\n",
+    "    {\n",
+    "        \"fields\": [\n",
+    "            {\"actor\": \"Tom Hanks\", \"movies\": [\"Forrest Gump\", \"Green Mile\"]},\n",
+    "            {\"actor\": \"Mads Mikkelsen\", \"movies\": [\"Hannibal\", \"Another round\"]}\n",
+    "        ],\n",
+    "        \"preferences\": {\"minimum_length\": 200, \"style\": \"gossip\"}\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93c7a4bb",
+   "metadata": {},
+   "source": [
+    "As we can see created examples are diversified and possess information we wanted them to have. Also, their style reflects the given preferences quite well."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "75f7f55a",
+   "metadata": {},
+   "source": [
+    "## Generating exemplary dataset for extraction benchmarking purposes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "94e98bc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inp = [\n",
+    "    {\n",
+    "        'Actor': 'Tom Hanks',\n",
+    "        'Film': [\n",
+    "            'Forrest Gump',\n",
+    "            'Saving Private Ryan',\n",
+    "            'The Green Mile',\n",
+    "            'Toy Story',\n",
+    "            'Catch Me If You Can']\n",
+    "    },\n",
+    "    {\n",
+    "        'Actor': 'Tom Hardy',\n",
+    "        'Film': [\n",
+    "            'Inception',\n",
+    "            'The Dark Knight Rises',\n",
+    "            'Mad Max: Fury Road',\n",
+    "            'The Revenant',\n",
+    "            'Dunkirk'\n",
+    "        ]\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "generator = DatasetGenerator(model, {\"style\": \"informal\", \"minimal length\": 500})\n",
+    "dataset = generator(inp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "478eaca4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'fields': {'Actor': 'Tom Hanks',\n",
+       "   'Film': ['Forrest Gump',\n",
+       "    'Saving Private Ryan',\n",
+       "    'The Green Mile',\n",
+       "    'Toy Story',\n",
+       "    'Catch Me If You Can']},\n",
+       "  'preferences': {'style': 'informal', 'minimal length': 500},\n",
+       "  'text': 'Tom Hanks, the versatile and charismatic actor, has graced the silver screen in numerous iconic films including the heartwarming and inspirational \"Forrest Gump,\" the intense and gripping war drama \"Saving Private Ryan,\" the emotionally charged and thought-provoking \"The Green Mile,\" the beloved animated classic \"Toy Story,\" and the thrilling and captivating true story adaptation \"Catch Me If You Can.\" With his impressive range and genuine talent, Hanks continues to captivate audiences worldwide, leaving an indelible mark on the world of cinema.'},\n",
+       " {'fields': {'Actor': 'Tom Hardy',\n",
+       "   'Film': ['Inception',\n",
+       "    'The Dark Knight Rises',\n",
+       "    'Mad Max: Fury Road',\n",
+       "    'The Revenant',\n",
+       "    'Dunkirk']},\n",
+       "  'preferences': {'style': 'informal', 'minimal length': 500},\n",
+       "  'text': 'Tom Hardy, the versatile actor known for his intense performances, has graced the silver screen in numerous iconic films, including \"Inception,\" \"The Dark Knight Rises,\" \"Mad Max: Fury Road,\" \"The Revenant,\" and \"Dunkirk.\" Whether he\\'s delving into the depths of the subconscious mind, donning the mask of the infamous Bane, or navigating the treacherous wasteland as the enigmatic Max Rockatansky, Hardy\\'s commitment to his craft is always evident. From his breathtaking portrayal of the ruthless Eames in \"Inception\" to his captivating transformation into the ferocious Max in \"Mad Max: Fury Road,\" Hardy\\'s dynamic range and magnetic presence captivate audiences and leave an indelible mark on the world of cinema. In his most physically demanding role to date, he endured the harsh conditions of the freezing wilderness as he portrayed the rugged frontiersman John Fitzgerald in \"The Revenant,\" earning him critical acclaim and an Academy Award nomination. In Christopher Nolan\\'s war epic \"Dunkirk,\" Hardy\\'s stoic and heroic portrayal of Royal Air Force pilot Farrier showcases his ability to convey deep emotion through nuanced performances. With his chameleon-like ability to inhabit a wide range of characters and his unwavering commitment to his craft, Tom Hardy has undoubtedly solidified his place as one of the most talented and sought-after actors of his generation.'}]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "293a7d64",
+   "metadata": {},
+   "source": [
+    "## Extraction from generated examples\n",
+    "Okay, let's see if we can now extract output from this generated data and how it compares with our case!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "03c6a375",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.output_parsers import PydanticOutputParser\n",
+    "from langchain.chains import create_extraction_chain_pydantic, SimpleSequentialChain\n",
+    "from pydantic import BaseModel, Field\n",
+    "from typing import List"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9461d225",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Actor(BaseModel):\n",
+    "    Actor: str = Field(description=\"name of an actor\")\n",
+    "    Film: List[str] = Field(description=\"list of names of films they starred in\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8390171d",
+   "metadata": {},
+   "source": [
+    "### Parsers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "8a5528d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Actor(Actor='Tom Hanks', Film=['Forrest Gump', 'Saving Private Ryan', 'The Green Mile', 'Toy Story', 'Catch Me If You Can'])"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm = OpenAI()\n",
+    "parser = PydanticOutputParser(pydantic_object=Actor)\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    template=\"Extract fields from a given text.\\n{format_instructions}\\n{text}\\n\",\n",
+    "    input_variables=[\"text\"],\n",
+    "    partial_variables={\"format_instructions\": parser.get_format_instructions()},\n",
+    ")\n",
+    "\n",
+    "_input = prompt.format_prompt(text=dataset[0][\"text\"])\n",
+    "output = llm(_input.to_string())\n",
+    "\n",
+    "parsed = parser.parse(output)\n",
+    "parsed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "926a7eed",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(parsed.Actor == inp[0][\"Actor\"]) & (parsed.Film == inp[0][\"Film\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b00f0b87",
+   "metadata": {},
+   "source": [
+    "### Extractors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "523bb584",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Actor(Actor='Tom Hardy', Film=['Inception', 'The Dark Knight Rises', 'Mad Max: Fury Road', 'The Revenant', 'Dunkirk'])]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "extractor = create_extraction_chain_pydantic(pydantic_schema=Actor, llm=model)\n",
+    "extracted = extractor.run(dataset[1][\"text\"])\n",
+    "extracted"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "f8451c2b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(extracted[0].Actor == inp[1][\"Actor\"]) & (extracted[0].Film == inp[1][\"Film\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b03de4d",
+   "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.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/package-lock.json

@@ -1,6 +0,0 @@
-{
-  "name": "docs",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}

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

@@ -1,130 +0,0 @@
-The `chat-conversational-react-description` agent type lets us create a conversational agent using a chat model instead of an LLM.
-
-```python
-from langchain.memory import ConversationBufferMemory
-from langchain.chat_models import ChatOpenAI
-
-memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
-llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, temperature=0)
-agent_chain = initialize_agent(tools, llm, agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION, verbose=True, memory=memory)
-```
-
-
-```python
-agent_chain.run(input="hi, i am bob")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    {
-        "action": "Final Answer",
-        "action_input": "Hello Bob! How can I assist you today?"
-    }
-    
-    > Finished chain.
-
-
-    'Hello Bob! How can I assist you today?'
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run(input="what's my name?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    {
-        "action": "Final Answer",
-        "action_input": "Your name is Bob."
-    }
-    
-    > Finished chain.
-
-
-    'Your name is Bob.'
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run("what are some good dinners to make this week, if i like thai food?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    {
-        "action": "Current Search",
-        "action_input": "Thai food dinner recipes"
-    }
-    Observation: 64 easy Thai recipes for any night of the week · Thai curry noodle soup · Thai yellow cauliflower, snake bean and tofu curry · Thai-spiced chicken hand pies · Thai ...
-    Thought:{
-        "action": "Final Answer",
-        "action_input": "Here are some Thai food dinner recipes you can try this week: Thai curry noodle soup, Thai yellow cauliflower, snake bean and tofu curry, Thai-spiced chicken hand pies, and many more. You can find the full list of recipes at the source I found earlier."
-    }
-    
-    > Finished chain.
-
-
-    'Here are some Thai food dinner recipes you can try this week: Thai curry noodle soup, Thai yellow cauliflower, snake bean and tofu curry, Thai-spiced chicken hand pies, and many more. You can find the full list of recipes at the source I found earlier.'
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run(input="tell me the last letter in my name, and also tell me who won the world cup in 1978?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    {
-        "action": "Final Answer",
-        "action_input": "The last letter in your name is 'b'. Argentina won the World Cup in 1978."
-    }
-    
-    > Finished chain.
-
-
-    "The last letter in your name is 'b'. Argentina won the World Cup in 1978."
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run(input="whats the weather like in pomfret?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    {
-        "action": "Current Search",
-        "action_input": "weather in pomfret"
-    }
-    Observation: Cloudy with showers. Low around 55F. Winds S at 5 to 10 mph. Chance of rain 60%. Humidity76%.
-    Thought:{
-        "action": "Final Answer",
-        "action_input": "Cloudy with showers. Low around 55F. Winds S at 5 to 10 mph. Chance of rain 60%. Humidity76%."
-    }
-    
-    > Finished chain.
-
-
-    'Cloudy with showers. Low around 55F. Winds S at 5 to 10 mph. Chance of rain 60%. Humidity76%.'
-```
-
-</CodeOutputBlock>

docs/snippets/modules/agents/agent_types/conversational_agent.mdx

@@ -1,150 +0,0 @@
-This is accomplished with a specific type of agent (`conversational-react-description`) which expects to be used with a memory component.
-
-```python
-from langchain.agents import Tool
-from langchain.agents import AgentType
-from langchain.memory import ConversationBufferMemory
-from langchain.llms import OpenAI
-from langchain.utilities import SerpAPIWrapper
-from langchain.agents import initialize_agent
-```
-
-
-```python
-search = SerpAPIWrapper()
-tools = [
-    Tool(
-        name = "Current Search",
-        func=search.run,
-        description="useful for when you need to answer questions about current events or the current state of the world"
-    ),
-]
-```
-
-
-```python
-memory = ConversationBufferMemory(memory_key="chat_history")
-```
-
-
-```python
-llm=OpenAI(temperature=0)
-agent_chain = initialize_agent(tools, llm, agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION, verbose=True, memory=memory)
-```
-
-
-```python
-agent_chain.run(input="hi, i am bob")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    
-    Thought: Do I need to use a tool? No
-    AI: Hi Bob, nice to meet you! How can I help you today?
-    
-    > Finished chain.
-
-
-    'Hi Bob, nice to meet you! How can I help you today?'
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run(input="what's my name?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    
-    Thought: Do I need to use a tool? No
-    AI: Your name is Bob!
-    
-    > Finished chain.
-
-
-    'Your name is Bob!'
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run("what are some good dinners to make this week, if i like thai food?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    
-    Thought: Do I need to use a tool? Yes
-    Action: Current Search
-    Action Input: Thai food dinner recipes
-    Observation: 59 easy Thai recipes for any night of the week · Marion Grasby's Thai spicy chilli and basil fried rice · Thai curry noodle soup · Marion Grasby's Thai Spicy ...
-    Thought: Do I need to use a tool? No
-    AI: Here are some great Thai dinner recipes you can try this week: Marion Grasby's Thai Spicy Chilli and Basil Fried Rice, Thai Curry Noodle Soup, Thai Green Curry with Coconut Rice, Thai Red Curry with Vegetables, and Thai Coconut Soup. I hope you enjoy them!
-    
-    > Finished chain.
-
-
-    "Here are some great Thai dinner recipes you can try this week: Marion Grasby's Thai Spicy Chilli and Basil Fried Rice, Thai Curry Noodle Soup, Thai Green Curry with Coconut Rice, Thai Red Curry with Vegetables, and Thai Coconut Soup. I hope you enjoy them!"
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run(input="tell me the last letter in my name, and also tell me who won the world cup in 1978?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    
-    Thought: Do I need to use a tool? Yes
-    Action: Current Search
-    Action Input: Who won the World Cup in 1978
-    Observation: Argentina national football team
-    Thought: Do I need to use a tool? No
-    AI: The last letter in your name is "b" and the winner of the 1978 World Cup was the Argentina national football team.
-    
-    > Finished chain.
-
-
-    'The last letter in your name is "b" and the winner of the 1978 World Cup was the Argentina national football team.'
-```
-
-</CodeOutputBlock>
-
-
-```python
-agent_chain.run(input="whats the current temperature in pomfret?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-    
-    Thought: Do I need to use a tool? Yes
-    Action: Current Search
-    Action Input: Current temperature in Pomfret
-    Observation: Partly cloudy skies. High around 70F. Winds W at 5 to 10 mph. Humidity41%.
-    Thought: Do I need to use a tool? No
-    AI: The current temperature in Pomfret is around 70F with partly cloudy skies and winds W at 5 to 10 mph. The humidity is 41%.
-    
-    > Finished chain.
-
-
-    'The current temperature in Pomfret is around 70F with partly cloudy skies and winds W at 5 to 10 mph. The humidity is 41%.'
-```
-
-</CodeOutputBlock>

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

@@ -1,80 +0,0 @@
-Install `openai`, `google-search-results` packages which are required as the LangChain packages call them internally.
-
-```bash
-pip install openai google-search-results
-```
-
-```python
-from langchain.agents import initialize_agent, AgentType, Tool
-from langchain.chains import LLMMathChain
-from langchain.chat_models import ChatOpenAI
-from langchain.llms import OpenAI
-from langchain.utilities import SerpAPIWrapper, SQLDatabase
-from langchain_experimental.sql import SQLDatabaseChain
-```
-
-
-```python
-llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
-search = SerpAPIWrapper()
-llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
-db = SQLDatabase.from_uri("sqlite:///../../../../../notebooks/Chinook.db")
-db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)
-tools = [
-    Tool(
-        name = "Search",
-        func=search.run,
-        description="useful for when you need to answer questions about current events. You should ask targeted questions"
-    ),
-    Tool(
-        name="Calculator",
-        func=llm_math_chain.run,
-        description="useful for when you need to answer questions about math"
-    ),
-    Tool(
-        name="FooBar-DB",
-        func=db_chain.run,
-        description="useful for when you need to answer questions about FooBar. Input should be in the form of a question containing full context"
-    )
-]
-```
-
-
-```python
-agent = initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)
-```
-
-
-```python
-agent.run("Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new  chain...
-    
-    Invoking: `Search` with `{'query': 'Leo DiCaprio girlfriend'}`
-    
-    
-    Amidst his casual romance with Gigi, Leo allegedly entered a relationship with 19-year old model, Eden Polani, in February 2023.
-    Invoking: `Calculator` with `{'expression': '19^0.43'}`
-    
-
-    > Entering new  chain...
-    19^0.43```text
-    19**0.43
-    ```
-    ...numexpr.evaluate("19**0.43")...
-    
-    Answer: 3.547023357958959
-    > Finished chain.
-    Answer: 3.547023357958959Leo DiCaprio's girlfriend is reportedly Eden Polani. Her current age raised to the power of 0.43 is approximately 3.55.
-    
-    > Finished chain.
-
-
-    "Leo DiCaprio's girlfriend is reportedly Eden Polani. Her current age raised to the power of 0.43 is approximately 3.55."
-```
-
-</CodeOutputBlock>

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

@@ -1,62 +0,0 @@
-```python
-from langchain.agents import load_tools
-from langchain.agents import initialize_agent
-from langchain.agents import AgentType
-from langchain.llms import OpenAI
-```
-
-First, let's load the language model we're going to use to control the agent.
-
-
-```python
-llm = OpenAI(temperature=0)
-```
-
-Next, let's load some tools to use. Note that the `llm-math` tool uses an LLM, so we need to pass that in.
-
-
-```python
-tools = load_tools(["serpapi", "llm-math"], llm=llm)
-```
-
-Finally, let's initialize an agent with the tools, the language model, and the type of agent we want to use.
-
-
-```python
-agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
-```
-
-Now let's test it out!
-
-
-```python
-agent.run("Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    > Entering new AgentExecutor chain...
-     I need to find out who Leo DiCaprio's girlfriend is and then calculate her age raised to the 0.43 power.
-    Action: Search
-    Action Input: "Leo DiCaprio girlfriend"
-    Observation: Camila Morrone
-    Thought: I need to find out Camila Morrone's age
-    Action: Search
-    Action Input: "Camila Morrone age"
-    Observation: 25 years
-    Thought: I need to calculate 25 raised to the 0.43 power
-    Action: Calculator
-    Action Input: 25^0.43
-    Observation: Answer: 3.991298452658078
-    
-    Thought: I now know the final answer
-    Final Answer: Camila Morrone is Leo DiCaprio's girlfriend and her current age raised to the 0.43 power is 3.991298452658078.
-    
-    > Finished chain.
-
-
-    "Camila Morrone is Leo DiCaprio's girlfriend and her current age raised to the 0.43 power is 3.991298452658078."
-```
-
-</CodeOutputBlock>

docs/snippets/modules/agents/agent_types/react_chat.mdx

@@ -1,7 +0,0 @@
-```python
-from langchain.chat_models import ChatOpenAI
-
-chat_model = ChatOpenAI(temperature=0)
-agent = initialize_agent(tools, chat_model, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
-agent.run("Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?")
-```

docs/snippets/modules/agents/get_started.mdx

@@ -1,13 +1,15 @@
 This will go over how to get started building an agent.
-We will use a LangChain agent class, but show how to customize it to give it specific context.
-We will then define custom tools, and then run it all in the standard LangChain `AgentExecutor`.
+We will create this agent from scratch, using LangChain Expression Language.
+We will then define custom tools, and then run it in a custom loop (we will also show how to use the standard LangChain `AgentExecutor`).
 
 ### Set up the agent
 
-We will use the `OpenAIFunctionsAgent`.
-This is easiest and best agent to get started with.
-It does however require usage of `ChatOpenAI` models.
-If you want to use a different language model, we would recommend using the [ReAct](/docs/modules/agents/agent_types/react) agent.
+We first need to create our agent.
+This is the chain responsible for determining what action to take next.
+
+In this example, we will use OpenAI Function Calling to create this agent.
+This is generally the most reliable way create agents.
+In this example we will show what it is like to construct this agent from scratch, using LangChain Expression Language.
 
 For this guide, we will construct a custom agent that has access to a custom tool.
 We are choosing this example because we think for most use cases you will NEED to customize either the agent or the tools.
@@ -39,23 +41,94 @@ tools = [get_word_length]
 ```
 
 Now let us create the prompt.
-We can use the `OpenAIFunctionsAgent.create_prompt` helper function to create a prompt automatically.
-This allows for a few different ways to customize, including passing in a custom `SystemMessage`, which we will do.
+Because OpenAI Function Calling is finetuned for tool usage, we hardly need any instructions on how to reason, or how to output format.
+We will just have two input variables: `input` (for the user question) and `agent_scratchpad` (for any previous steps taken)
 
 ```python
-from langchain.schema import SystemMessage
-from langchain.agents import OpenAIFunctionsAgent
-system_message = SystemMessage(content="You are very powerful assistant, but bad at calculating lengths of words.")
-prompt = OpenAIFunctionsAgent.create_prompt(system_message=system_message)
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are very powerful assistant, but bad at calculating lengths of words."),
+    ("user", "{input}"),
+    MessagesPlaceholder(variable_name="agent_scratchpad"),
+])
+```
+
+How does the agent know what tools it can use?
+Those are passed in as a separate argument, so we can bind those as key word arguments to the LLM.
+
+```python
+from langchain.tools.render import format_tool_to_openai_function
+llm_with_tools = llm.bind(
+    functions=[format_tool_to_openai_function(t) for t in tools]
+)
 ```
 
 Putting those pieces together, we can now create the agent.
+We will import two last utility functions: a component for formatting intermediate steps to messages, and a component for converting the output message into an agent action/agent finish.
+
 
 ```python
-agent = OpenAIFunctionsAgent(llm=llm, tools=tools, prompt=prompt)
+from langchain.agents.format_scratchpad import format_to_openai_functions
+from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
+agent = {
+    "input": lambda x: x["input"],
+    "agent_scratchpad": lambda x: format_to_openai_functions(x['intermediate_steps'])
+} | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
 ```
 
-Finally, we create the `AgentExecutor` - the runtime for our agent.
+Now that we have our agent, let's play around with it!
+Let's pass in a simple question and empty intermediate steps and see what it returns:
+
+```python
+agent.invoke({
+    "input": "how many letters in the word educa?",
+    "intermediate_steps": []
+})
+```
+
+We can see that it responds with an `AgentAction` to take (it's actually an `AgentActionMessageLog` - a subclass of `AgentAction` which also tracks the full message log).
+
+So this is just the first step - now we need to write a runtime for this.
+The simplest one is just one that continuously loops, calling the agent, then taking the action, and repeating until an `AgentFinish` is returned.
+Let's code that up below:
+
+```python
+from langchain.schema.agent import AgentFinish
+intermediate_steps = []
+while True:
+    output = agent.invoke({
+        "input": "how many letters in the word educa?",
+        "intermediate_steps": intermediate_steps
+    })
+    if isinstance(output, AgentFinish):
+        final_result = output.return_values["output"]
+        break
+    else:
+        print(output.tool, output.tool_input)
+        tool = {
+            "get_word_length": get_word_length
+        }[output.tool]
+        observation = tool.run(output.tool_input)
+        intermediate_steps.append((output, observation))
+print(final_result)
+```
+
+We can see this prints out the following:
+
+<CodeOutputBlock lang="python">
+
+```
+get_word_length {'word': 'educa'}
+There are 5 letters in the word "educa".
+```
+
+</CodeOutputBlock>
+
+Woo! It's working.
+
+To simplify this a bit, we can import and use the `AgentExecutor` class.
+This bundles up all of the above and adds in error handling, early stopping, tracing, and other quality-of-life improvements that reduce safeguards you need to write.
+
 
 ```python
 from langchain.agents import AgentExecutor
@@ -66,7 +139,7 @@ Now let's test it out!
 
 
 ```python
-agent_executor.run("how many letters in the word educa?")
+agent_executor.invoke({"input": "how many letters in the word educa?"})
 ```
 
 <CodeOutputBlock lang="python">
@@ -97,36 +170,44 @@ Let's fix that by adding in memory.
 In order to do this, we need to do two things:
 
 1. Add a place for memory variables to go in the prompt
-2. Add memory to the `AgentExecutor` (note that we add it here, and NOT to the agent, as this is the outermost chain)
+2. Keep track of the chat history
 
 First, let's add a place for memory in the prompt.
 We do this by adding a placeholder for messages with the key `"chat_history"`.
+Notice that we put this ABOVE the new user input (to follow the conversation flow).
 
 ```python
 from langchain.prompts import MessagesPlaceholder
 
 MEMORY_KEY = "chat_history"
-prompt = OpenAIFunctionsAgent.create_prompt(
-    system_message=system_message,
-    extra_prompt_messages=[MessagesPlaceholder(variable_name=MEMORY_KEY)]
-)
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are very powerful assistant, but bad at calculating lengths of words."),
+    MessagesPlaceholder(variable_name=MEMORY_KEY),
+    ("user", "{input}"),
+    MessagesPlaceholder(variable_name="agent_scratchpad"),
+])
 ```
-
-Next, let's create a memory object.
-We will do this by using `ConversationBufferMemory`.
-Importantly, we set `memory_key` also equal to `"chat_history"` (to align it with the prompt) and set `return_messages` (to make it return messages rather than a string).
-
-```python
-from langchain.memory import ConversationBufferMemory
-
-memory = ConversationBufferMemory(memory_key=MEMORY_KEY, return_messages=True)
+We can then set up a list to track the chat history
+```
+from langchain.schema.messages import HumanMessage, AIMessage
+chat_history = []
 ```
 
 We can then put it all together!
 
 ```python
-agent = OpenAIFunctionsAgent(llm=llm, tools=tools, prompt=prompt)
-agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)
-agent_executor.run("how many letters in the word educa?")
-agent_executor.run("is that a real word?")
+agent = {
+    "input": lambda x: x["input"],
+    "agent_scratchpad": lambda x: format_to_openai_functions(x['intermediate_steps']),
+    "chat_history": lambda x: x["chat_history"]
+} | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+```
+When running, we now need to track the inputs and outputs as chat history
+```
+input1 = "how many letters in the word educa?"
+result = agent_executor.invoke({"input": input1, "chat_history": chat_history})
+chat_history.append(HumanMessage(content=input1))
+chat_history.append(AIMessage(content=result['output']))
+agent_executor.invoke({"input": "is that a real word?", "chat_history": chat_history})
 ```

docs/snippets/modules/data_connection/document_loaders/how_to/json.mdx

@@ -89,7 +89,8 @@ Suppose we are interested in extracting the values under the `content` field wit
 ```python
 loader = JSONLoader(
     file_path='./example_data/facebook_chat.json',
-    jq_schema='.messages[].content')
+    jq_schema='.messages[].content',
+    text_content=False)
 
 data = loader.load()
 ```
@@ -145,6 +146,7 @@ pprint(Path(file_path).read_text())
 loader = JSONLoader(
     file_path='./example_data/facebook_chat_messages.jsonl',
     jq_schema='.content',
+    text_content=False,
     json_lines=True)
 
 data = loader.load()

libs/experimental/langchain_experimental/synthetic_data/__init__.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, List, Optional
+
+from langchain.chains.base import Chain
+from langchain.chains.llm import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain.schema.language_model import BaseLanguageModel
+
+from langchain_experimental.synthetic_data.prompts import SENTENCE_PROMPT
+
+
+def create_data_generation_chain(
+    llm: BaseLanguageModel,
+    prompt: Optional[PromptTemplate] = None,
+) -> Chain:
+    """Creates a chain that generates synthetic sentences with
+     provided fields.
+
+    Args:
+        llm: The language model to use.
+        prompt: Prompt to feed the language model with.
+        If not provided, the default one will be used.
+    """
+    prompt = prompt or SENTENCE_PROMPT
+    return LLMChain(
+        llm=llm,
+        prompt=prompt,
+    )
+
+
+class DatasetGenerator:
+    """Generates synthetic dataset with a given language model."""
+
+    def __init__(
+        self,
+        llm: BaseLanguageModel,
+        sentence_preferences: Optional[Dict[str, Any]] = None,
+    ):
+        self.generator = create_data_generation_chain(llm)
+        self.sentence_preferences = sentence_preferences or {}
+
+    def __call__(self, fields_collection: List[List[Any]]) -> List[Dict[str, Any]]:
+        results: List[Dict[str, Any]] = []
+        for fields in fields_collection:
+            results.append(
+                self.generator(
+                    {"fields": fields, "preferences": self.sentence_preferences}
+                )
+            )
+        return results

libs/experimental/langchain_experimental/synthetic_data/prompts.py

@@ -0,0 +1,15 @@
+from langchain.prompts.prompt import PromptTemplate
+
+sentence_template = """Given the following fields, create a sentence about them. 
+Make the sentence detailed and interesting. Use every given field.
+If any additional preferences are given, use them during sentence construction as well.
+Fields:
+{fields}
+Preferences:
+{preferences}
+Sentence:
+"""
+
+SENTENCE_PROMPT = PromptTemplate(
+    template=sentence_template, input_variables=["fields", "preferences"]
+)

libs/experimental/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-experimental"
-version = "0.0.18"
+version = "0.0.20"
 description = "Building applications with LLMs through composability"
 authors = []
 license = "MIT"

libs/langchain/langchain/agents/agent_toolkits/openapi/planner.py

@@ -19,10 +19,12 @@ from langchain.agents.agent_toolkits.openapi.planner_prompt import (
     PARSING_GET_PROMPT,
     PARSING_PATCH_PROMPT,
     PARSING_POST_PROMPT,
+    PARSING_PUT_PROMPT,
     REQUESTS_DELETE_TOOL_DESCRIPTION,
     REQUESTS_GET_TOOL_DESCRIPTION,
     REQUESTS_PATCH_TOOL_DESCRIPTION,
     REQUESTS_POST_TOOL_DESCRIPTION,
+    REQUESTS_PUT_TOOL_DESCRIPTION,
 )
 from langchain.agents.agent_toolkits.openapi.spec import ReducedOpenAPISpec
 from langchain.agents.mrkl.base import ZeroShotAgent
@@ -151,6 +153,35 @@ class RequestsPatchToolWithParsing(BaseRequestsTool, BaseTool):
         raise NotImplementedError()
 
 
+class RequestsPutToolWithParsing(BaseRequestsTool, BaseTool):
+    """Requests PUT tool with LLM-instructed extraction of truncated responses."""
+
+    name: str = "requests_put"
+    """Tool name."""
+    description = REQUESTS_PUT_TOOL_DESCRIPTION
+    """Tool description."""
+    response_length: Optional[int] = MAX_RESPONSE_LENGTH
+    """Maximum length of the response to be returned."""
+    llm_chain: LLMChain = Field(
+        default_factory=_get_default_llm_chain_factory(PARSING_PUT_PROMPT)
+    )
+    """LLMChain used to extract the response."""
+
+    def _run(self, text: str) -> str:
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError as e:
+            raise e
+        response = self.requests_wrapper.put(data["url"], data["data"])
+        response = response[: self.response_length]
+        return self.llm_chain.predict(
+            response=response, instructions=data["output_instructions"]
+        ).strip()
+
+    async def _arun(self, text: str) -> str:
+        raise NotImplementedError()
+
+
 class RequestsDeleteToolWithParsing(BaseRequestsTool, BaseTool):
     """A tool that sends a DELETE request and parses the response."""
 

libs/langchain/langchain/agents/agent_toolkits/openapi/planner_prompt.py

@@ -24,6 +24,7 @@ GET /user to get information about the current user
 GET /products/search search across products
 POST /users/{{id}}/cart to add products to a user's cart
 PATCH /users/{{id}}/cart to update a user's cart
+PUT /users/{{id}}/coupon to apply idempotent coupon to a user's cart
 DELETE /users/{{id}}/cart to delete a user's cart
 
 User query: tell me a joke
@@ -39,6 +40,10 @@ Plan: 1. GET /products with a query param to search for lamps
 2. GET /user to find the user's id
 3. PATCH /users/{{id}}/cart to add a lamp to the user's cart
 
+User query: I want to add a coupon to my cart
+Plan: 1. GET /user to find the user's id
+2. PUT /users/{{id}}/coupon to apply the coupon
+
 User query: I want to delete my cart
 Plan: 1. GET /user to find the user's id
 2. DELETE required. Did user specify DELETE or previously authorize? Yes, proceed.
@@ -195,6 +200,23 @@ Output:""",
     input_variables=["response", "instructions"],
 )
 
+REQUESTS_PUT_TOOL_DESCRIPTION = """Use this when you want to PUT to a website.
+Input to the tool should be a json string with 3 keys: "url", "data", and "output_instructions".
+The value of "url" should be a string.
+The value of "data" should be a dictionary of key-value pairs you want to PUT to the url.
+The value of "output_instructions" should be instructions on what information to extract from the response, for example the id(s) for a resource(s) that the PUT request creates.
+Always use double quotes for strings in the json string."""
+
+PARSING_PUT_PROMPT = PromptTemplate(
+    template="""Here is an API response:\n\n{response}\n\n====
+Your task is to extract some information according to these instructions: {instructions}
+When working with API objects, you should usually use ids over names. Do not return any ids or names that are not in the response.
+If the response indicates an error, you should instead output a summary of the error.
+
+Output:""",
+    input_variables=["response", "instructions"],
+)
+
 REQUESTS_DELETE_TOOL_DESCRIPTION = """ONLY USE THIS TOOL WHEN THE USER HAS SPECIFICALLY REQUESTED TO DELETE CONTENT FROM A WEBSITE.
 Input to the tool should be a json string with 2 keys: "url", and "output_instructions".
 The value of "url" should be a string.

libs/langchain/langchain/agents/agent_toolkits/openapi/spec.py

@@ -31,12 +31,12 @@ def reduce_openapi_spec(spec: dict, dereference: bool = True) -> ReducedOpenAPIS
     I was hoping https://openapi.tools/ would have some useful bits
     to this end, but doesn't seem so.
     """
-    # 1. Consider only get, post, patch, delete endpoints.
+    # 1. Consider only get, post, patch, put, delete endpoints.
     endpoints = [
         (f"{operation_name.upper()} {route}", docs.get("description"), docs)
         for route, operation in spec["paths"].items()
         for operation_name, docs in operation.items()
-        if operation_name in ["get", "post", "patch", "delete"]
+        if operation_name in ["get", "post", "patch", "put", "delete"]
     ]
 
     # 2. Replace any refs so that complete docs are retrieved.

libs/langchain/langchain/agents/format_scratchpad/__init__.py

@@ -0,0 +1,20 @@
+"""Logic for formatting intermediate steps into an agent scratchpad.
+
+Intermediate steps refers to the list of (AgentAction, observation) tuples
+that result from previous iterations of the agent.
+Depending on the prompting strategy you are using, you may want to format these
+differently before passing them into the LLM.
+"""
+from langchain.agents.format_scratchpad.log import format_log_to_str
+from langchain.agents.format_scratchpad.log_to_messages import format_log_to_messages
+from langchain.agents.format_scratchpad.openai_functions import (
+    format_to_openai_functions,
+)
+from langchain.agents.format_scratchpad.xml import format_xml
+
+__all__ = [
+    "format_xml",
+    "format_to_openai_functions",
+    "format_log_to_str",
+    "format_log_to_messages",
+]

libs/langchain/langchain/agents/format_scratchpad/log.py

@@ -0,0 +1,16 @@
+from typing import List, Tuple
+
+from langchain.schema.agent import AgentAction
+
+
+def format_log_to_str(
+    intermediate_steps: List[Tuple[AgentAction, str]],
+    observation_prefix: str = "Observation: ",
+    llm_prefix: str = "Thought: ",
+) -> str:
+    """Construct the scratchpad that lets the agent continue its thought process."""
+    thoughts = ""
+    for action, observation in intermediate_steps:
+        thoughts += action.log
+        thoughts += f"\n{observation_prefix}{observation}\n{llm_prefix}"
+    return thoughts

libs/langchain/langchain/agents/format_scratchpad/log_to_messages.py

@@ -0,0 +1,19 @@
+from typing import List, Tuple
+
+from langchain.schema.agent import AgentAction
+from langchain.schema.messages import AIMessage, BaseMessage, HumanMessage
+
+
+def format_log_to_messages(
+    intermediate_steps: List[Tuple[AgentAction, str]],
+    template_tool_response: str = "{observation}",
+) -> List[BaseMessage]:
+    """Construct the scratchpad that lets the agent continue its thought process."""
+    thoughts: List[BaseMessage] = []
+    for action, observation in intermediate_steps:
+        thoughts.append(AIMessage(content=action.log))
+        human_message = HumanMessage(
+            content=template_tool_response.format(observation=observation)
+        )
+        thoughts.append(human_message)
+    return thoughts

libs/langchain/langchain/agents/format_scratchpad/openai_functions.py

@@ -0,0 +1,66 @@
+import json
+from typing import List, Sequence, Tuple
+
+from langchain.schema.agent import AgentAction, AgentActionMessageLog
+from langchain.schema.messages import AIMessage, BaseMessage, FunctionMessage
+
+
+def _convert_agent_action_to_messages(
+    agent_action: AgentAction, observation: str
+) -> List[BaseMessage]:
+    """Convert an agent action to a message.
+
+    This code is used to reconstruct the original AI message from the agent action.
+
+    Args:
+        agent_action: Agent action to convert.
+
+    Returns:
+        AIMessage that corresponds to the original tool invocation.
+    """
+    if isinstance(agent_action, AgentActionMessageLog):
+        return list(agent_action.message_log) + [
+            _create_function_message(agent_action, observation)
+        ]
+    else:
+        return [AIMessage(content=agent_action.log)]
+
+
+def _create_function_message(
+    agent_action: AgentAction, observation: str
+) -> FunctionMessage:
+    """Convert agent action and observation into a function message.
+    Args:
+        agent_action: the tool invocation request from the agent
+        observation: the result of the tool invocation
+    Returns:
+        FunctionMessage that corresponds to the original tool invocation
+    """
+    if not isinstance(observation, str):
+        try:
+            content = json.dumps(observation, ensure_ascii=False)
+        except Exception:
+            content = str(observation)
+    else:
+        content = observation
+    return FunctionMessage(
+        name=agent_action.tool,
+        content=content,
+    )
+
+
+def format_to_openai_functions(
+    intermediate_steps: Sequence[Tuple[AgentAction, str]],
+) -> List[BaseMessage]:
+    """Format intermediate steps.
+    Args:
+        intermediate_steps: Steps the LLM has taken to date, along with observations
+    Returns:
+        list of messages to send to the LLM for the next prediction
+    """
+    messages = []
+
+    for agent_action, observation in intermediate_steps:
+        messages.extend(_convert_agent_action_to_messages(agent_action, observation))
+
+    return messages

libs/langchain/langchain/agents/format_scratchpad/xml.py

@@ -0,0 +1,15 @@
+from typing import List, Tuple
+
+from langchain.schema.agent import AgentAction
+
+
+def format_xml(
+    intermediate_steps: List[Tuple[AgentAction, str]],
+) -> str:
+    log = ""
+    for action, observation in intermediate_steps:
+        log += (
+            f"<tool>{action.tool}</tool><tool_input>{action.tool_input}"
+            f"</tool_input><observation>{observation}</observation>"
+        )
+    return log

libs/langchain/langchain/agents/openai_functions_agent/agent_token_buffer_memory.py

@@ -1,7 +1,9 @@
 """Memory used to save agent output AND intermediate steps."""
 from typing import Any, Dict, List
 
-from langchain.agents.openai_functions_agent.base import _format_intermediate_steps
+from langchain.agents.format_scratchpad.openai_functions import (
+    format_to_openai_functions,
+)
 from langchain.memory.chat_memory import BaseChatMemory
 from langchain.schema.language_model import BaseLanguageModel
 from langchain.schema.messages import BaseMessage, get_buffer_string
@@ -50,7 +52,7 @@ class AgentTokenBufferMemory(BaseChatMemory):
         """Save context from this conversation to buffer. Pruned."""
         input_str, output_str = self._get_input_output(inputs, outputs)
         self.chat_memory.add_user_message(input_str)
-        steps = _format_intermediate_steps(outputs[self.intermediate_steps_key])
+        steps = format_to_openai_functions(outputs[self.intermediate_steps_key])
         for msg in steps:
             self.chat_memory.add_message(msg)
         self.chat_memory.add_ai_message(output_str)

libs/langchain/langchain/agents/openai_functions_agent/base.py

@@ -1,10 +1,13 @@
 """Module implements an agent that uses OpenAI's APIs function enabled API."""
-import json
-from dataclasses import dataclass
-from json import JSONDecodeError
 from typing import Any, List, Optional, Sequence, Tuple, Union
 
 from langchain.agents import BaseSingleActionAgent
+from langchain.agents.format_scratchpad.openai_functions import (
+    format_to_openai_functions,
+)
+from langchain.agents.output_parsers.openai_functions import (
+    OpenAIFunctionsAgentOutputParser,
+)
 from langchain.callbacks.base import BaseCallbackManager
 from langchain.callbacks.manager import Callbacks
 from langchain.chat_models.openai import ChatOpenAI
@@ -19,124 +22,14 @@ from langchain.schema import (
     AgentAction,
     AgentFinish,
     BasePromptTemplate,
-    OutputParserException,
 )
 from langchain.schema.language_model import BaseLanguageModel
 from langchain.schema.messages import (
-    AIMessage,
     BaseMessage,
-    FunctionMessage,
     SystemMessage,
 )
-from langchain.tools import BaseTool
-from langchain.tools.convert_to_openai import format_tool_to_openai_function
-
-
-@dataclass
-class _FunctionsAgentAction(AgentAction):
-    message_log: List[BaseMessage]
-
-
-def _convert_agent_action_to_messages(
-    agent_action: AgentAction, observation: str
-) -> List[BaseMessage]:
-    """Convert an agent action to a message.
-
-    This code is used to reconstruct the original AI message from the agent action.
-
-    Args:
-        agent_action: Agent action to convert.
-
-    Returns:
-        AIMessage that corresponds to the original tool invocation.
-    """
-    if isinstance(agent_action, _FunctionsAgentAction):
-        return agent_action.message_log + [
-            _create_function_message(agent_action, observation)
-        ]
-    else:
-        return [AIMessage(content=agent_action.log)]
-
-
-def _create_function_message(
-    agent_action: AgentAction, observation: str
-) -> FunctionMessage:
-    """Convert agent action and observation into a function message.
-    Args:
-        agent_action: the tool invocation request from the agent
-        observation: the result of the tool invocation
-    Returns:
-        FunctionMessage that corresponds to the original tool invocation
-    """
-    if not isinstance(observation, str):
-        try:
-            content = json.dumps(observation, ensure_ascii=False)
-        except Exception:
-            content = str(observation)
-    else:
-        content = observation
-    return FunctionMessage(
-        name=agent_action.tool,
-        content=content,
-    )
-
-
-def _format_intermediate_steps(
-    intermediate_steps: List[Tuple[AgentAction, str]],
-) -> List[BaseMessage]:
-    """Format intermediate steps.
-    Args:
-        intermediate_steps: Steps the LLM has taken to date, along with observations
-    Returns:
-        list of messages to send to the LLM for the next prediction
-    """
-    messages = []
-
-    for intermediate_step in intermediate_steps:
-        agent_action, observation = intermediate_step
-        messages.extend(_convert_agent_action_to_messages(agent_action, observation))
-
-    return messages
-
-
-def _parse_ai_message(message: BaseMessage) -> Union[AgentAction, AgentFinish]:
-    """Parse an AI message."""
-    if not isinstance(message, AIMessage):
-        raise TypeError(f"Expected an AI message got {type(message)}")
-
-    function_call = message.additional_kwargs.get("function_call", {})
-
-    if function_call:
-        function_name = function_call["name"]
-        try:
-            _tool_input = json.loads(function_call["arguments"])
-        except JSONDecodeError:
-            raise OutputParserException(
-                f"Could not parse tool input: {function_call} because "
-                f"the `arguments` is not valid JSON."
-            )
-
-        # HACK HACK HACK:
-        # The code that encodes tool input into Open AI uses a special variable
-        # name called `__arg1` to handle old style tools that do not expose a
-        # schema and expect a single string argument as an input.
-        # We unpack the argument here if it exists.
-        # Open AI does not support passing in a JSON array as an argument.
-        if "__arg1" in _tool_input:
-            tool_input = _tool_input["__arg1"]
-        else:
-            tool_input = _tool_input
-
-        content_msg = f"responded: {message.content}\n" if message.content else "\n"
-
-        return _FunctionsAgentAction(
-            tool=function_name,
-            tool_input=tool_input,
-            log=f"\nInvoking: `{function_name}` with `{tool_input}`\n{content_msg}\n",
-            message_log=[message],
-        )
-
-    return AgentFinish(return_values={"output": message.content}, log=message.content)
+from langchain.tools.base import BaseTool
+from langchain.tools.render import format_tool_to_openai_function
 
 
 class OpenAIFunctionsAgent(BaseSingleActionAgent):
@@ -200,7 +93,7 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         Returns:
             Action specifying what tool to use.
         """
-        agent_scratchpad = _format_intermediate_steps(intermediate_steps)
+        agent_scratchpad = format_to_openai_functions(intermediate_steps)
         selected_inputs = {
             k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
         }
@@ -218,7 +111,9 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
                 messages,
                 callbacks=callbacks,
             )
-        agent_decision = _parse_ai_message(predicted_message)
+        agent_decision = OpenAIFunctionsAgentOutputParser._parse_ai_message(
+            predicted_message
+        )
         return agent_decision
 
     async def aplan(
@@ -237,7 +132,7 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         Returns:
             Action specifying what tool to use.
         """
-        agent_scratchpad = _format_intermediate_steps(intermediate_steps)
+        agent_scratchpad = format_to_openai_functions(intermediate_steps)
         selected_inputs = {
             k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
         }
@@ -247,7 +142,9 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         predicted_message = await self.llm.apredict_messages(
             messages, functions=self.functions, callbacks=callbacks
         )
-        agent_decision = _parse_ai_message(predicted_message)
+        agent_decision = OpenAIFunctionsAgentOutputParser._parse_ai_message(
+            predicted_message
+        )
         return agent_decision
 
     def return_stopped_response(

libs/langchain/langchain/agents/openai_functions_multi_agent/base.py

@@ -1,10 +1,12 @@
 """Module implements an agent that uses OpenAI's APIs function enabled API."""
 import json
-from dataclasses import dataclass
 from json import JSONDecodeError
 from typing import Any, List, Optional, Sequence, Tuple, Union
 
 from langchain.agents import BaseMultiActionAgent
+from langchain.agents.format_scratchpad.openai_functions import (
+    format_to_openai_functions,
+)
 from langchain.callbacks.base import BaseCallbackManager
 from langchain.callbacks.manager import Callbacks
 from langchain.chat_models.openai import ChatOpenAI
@@ -21,81 +23,17 @@ from langchain.schema import (
     BasePromptTemplate,
     OutputParserException,
 )
+from langchain.schema.agent import AgentActionMessageLog
 from langchain.schema.language_model import BaseLanguageModel
 from langchain.schema.messages import (
     AIMessage,
     BaseMessage,
-    FunctionMessage,
     SystemMessage,
 )
 from langchain.tools import BaseTool
 
-
-@dataclass
-class _FunctionsAgentAction(AgentAction):
-    message_log: List[BaseMessage]
-
-
-def _convert_agent_action_to_messages(
-    agent_action: AgentAction, observation: str
-) -> List[BaseMessage]:
-    """Convert an agent action to a message.
-
-    This code is used to reconstruct the original AI message from the agent action.
-
-    Args:
-        agent_action: Agent action to convert.
-
-    Returns:
-        AIMessage that corresponds to the original tool invocation.
-    """
-    if isinstance(agent_action, _FunctionsAgentAction):
-        return agent_action.message_log + [
-            _create_function_message(agent_action, observation)
-        ]
-    else:
-        return [AIMessage(content=agent_action.log)]
-
-
-def _create_function_message(
-    agent_action: AgentAction, observation: str
-) -> FunctionMessage:
-    """Convert agent action and observation into a function message.
-    Args:
-        agent_action: the tool invocation request from the agent
-        observation: the result of the tool invocation
-    Returns:
-        FunctionMessage that corresponds to the original tool invocation
-    """
-    if not isinstance(observation, str):
-        try:
-            content = json.dumps(observation, ensure_ascii=False)
-        except Exception:
-            content = str(observation)
-    else:
-        content = observation
-    return FunctionMessage(
-        name=agent_action.tool,
-        content=content,
-    )
-
-
-def _format_intermediate_steps(
-    intermediate_steps: List[Tuple[AgentAction, str]],
-) -> List[BaseMessage]:
-    """Format intermediate steps.
-    Args:
-        intermediate_steps: Steps the LLM has taken to date, along with observations
-    Returns:
-        list of messages to send to the LLM for the next prediction
-    """
-    messages = []
-
-    for intermediate_step in intermediate_steps:
-        agent_action, observation = intermediate_step
-        messages.extend(_convert_agent_action_to_messages(agent_action, observation))
-
-    return messages
+# For backwards compatibility
+_FunctionsAgentAction = AgentActionMessageLog
 
 
 def _parse_ai_message(message: BaseMessage) -> Union[List[AgentAction], AgentFinish]:
@@ -259,7 +197,7 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         Returns:
             Action specifying what tool to use.
         """
-        agent_scratchpad = _format_intermediate_steps(intermediate_steps)
+        agent_scratchpad = format_to_openai_functions(intermediate_steps)
         selected_inputs = {
             k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
         }
@@ -288,7 +226,7 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         Returns:
             Action specifying what tool to use.
         """
-        agent_scratchpad = _format_intermediate_steps(intermediate_steps)
+        agent_scratchpad = format_to_openai_functions(intermediate_steps)
         selected_inputs = {
             k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
         }

libs/langchain/langchain/agents/output_parsers/__init__.py

@@ -0,0 +1,32 @@
+"""Parsing utils to go from string to AgentAction or Agent Finish.
+
+AgentAction means that an action should be taken.
+This contains the name of the tool to use, the input to pass to that tool,
+and a `log` variable (which contains a log of the agent's thinking).
+
+AgentFinish means that a response should be given.
+This contains a `return_values` dictionary. This usually contains a
+single `output` key, but can be extended to contain more.
+This also contains a `log` variable (which contains a log of the agent's thinking).
+"""
+from langchain.agents.output_parsers.json import JSONAgentOutputParser
+from langchain.agents.output_parsers.openai_functions import (
+    OpenAIFunctionsAgentOutputParser,
+)
+from langchain.agents.output_parsers.react_json_single_input import (
+    ReActJsonSingleInputOutputParser,
+)
+from langchain.agents.output_parsers.react_single_input import (
+    ReActSingleInputOutputParser,
+)
+from langchain.agents.output_parsers.self_ask import SelfAskOutputParser
+from langchain.agents.output_parsers.xml import XMLAgentOutputParser
+
+__all__ = [
+    "ReActSingleInputOutputParser",
+    "SelfAskOutputParser",
+    "ReActJsonSingleInputOutputParser",
+    "OpenAIFunctionsAgentOutputParser",
+    "XMLAgentOutputParser",
+    "JSONAgentOutputParser",
+]

libs/langchain/langchain/agents/output_parsers/json.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import logging
+from typing import Union
+
+from langchain.agents.agent import AgentOutputParser
+from langchain.output_parsers.json import parse_json_markdown
+from langchain.schema import AgentAction, AgentFinish, OutputParserException
+
+logger = logging.getLogger(__name__)
+
+
+class JSONAgentOutputParser(AgentOutputParser):
+    """Parses tool invocations and final answers in XML format.
+
+    Expects output to be in one of two formats.
+
+    If the output signals that an action should be taken,
+    should be in the below format. This will result in an AgentAction
+    being returned.
+
+    ```
+    {
+      "action": "search",
+      "action_input": "2+2"
+    }
+    ```
+
+    If the output signals that a final answer should be given,
+    should be in the below format. This will result in an AgentFinish
+    being returned.
+
+    ```
+    {
+      "action": "Final Answer",
+      "action_input": "4"
+    }
+    ```
+    """
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        try:
+            response = parse_json_markdown(text)
+            if isinstance(response, list):
+                # gpt turbo frequently ignores the directive to emit a single action
+                logger.warning("Got multiple action responses: %s", response)
+                response = response[0]
+            if response["action"] == "Final Answer":
+                return AgentFinish({"output": response["action_input"]}, text)
+            else:
+                return AgentAction(
+                    response["action"], response.get("action_input", {}), text
+                )
+        except Exception as e:
+            raise OutputParserException(f"Could not parse LLM output: {text}") from e
+
+    @property
+    def _type(self) -> str:
+        return "json-agent"

libs/langchain/langchain/agents/output_parsers/openai_functions.py

@@ -0,0 +1,84 @@
+import json
+from json import JSONDecodeError
+from typing import List, Union
+
+from langchain.agents.agent import AgentOutputParser
+from langchain.schema import (
+    AgentAction,
+    AgentFinish,
+    OutputParserException,
+)
+from langchain.schema.agent import AgentActionMessageLog
+from langchain.schema.messages import (
+    AIMessage,
+    BaseMessage,
+)
+from langchain.schema.output import ChatGeneration, Generation
+
+
+class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
+    """Parses a message into agent action/finish.
+
+    Is meant to be used with OpenAI models, as it relies on the specific
+    function_call parameter from OpenAI to convey what tools to use.
+
+    If a function_call parameter is passed, then that is used to get
+    the tool and tool input.
+
+    If one is not passed, then the AIMessage is assumed to be the final output.
+    """
+
+    @property
+    def _type(self) -> str:
+        return "openai-functions-agent"
+
+    @staticmethod
+    def _parse_ai_message(message: BaseMessage) -> Union[AgentAction, AgentFinish]:
+        """Parse an AI message."""
+        if not isinstance(message, AIMessage):
+            raise TypeError(f"Expected an AI message got {type(message)}")
+
+        function_call = message.additional_kwargs.get("function_call", {})
+
+        if function_call:
+            function_name = function_call["name"]
+            try:
+                _tool_input = json.loads(function_call["arguments"])
+            except JSONDecodeError:
+                raise OutputParserException(
+                    f"Could not parse tool input: {function_call} because "
+                    f"the `arguments` is not valid JSON."
+                )
+
+            # HACK HACK HACK:
+            # The code that encodes tool input into Open AI uses a special variable
+            # name called `__arg1` to handle old style tools that do not expose a
+            # schema and expect a single string argument as an input.
+            # We unpack the argument here if it exists.
+            # Open AI does not support passing in a JSON array as an argument.
+            if "__arg1" in _tool_input:
+                tool_input = _tool_input["__arg1"]
+            else:
+                tool_input = _tool_input
+
+            content_msg = f"responded: {message.content}\n" if message.content else "\n"
+            log = f"\nInvoking: `{function_name}` with `{tool_input}`\n{content_msg}\n"
+            return AgentActionMessageLog(
+                tool=function_name,
+                tool_input=tool_input,
+                log=log,
+                message_log=[message],
+            )
+
+        return AgentFinish(
+            return_values={"output": message.content}, log=message.content
+        )
+
+    def parse_result(self, result: List[Generation]) -> Union[AgentAction, AgentFinish]:
+        if not isinstance(result[0], ChatGeneration):
+            raise ValueError("This output parser only works on ChatGeneration output")
+        message = result[0].message
+        return self._parse_ai_message(message)
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        raise ValueError("Can only parse messages")

libs/langchain/langchain/agents/output_parsers/react_json_single_input.py

@@ -0,0 +1,76 @@
+import json
+import re
+from typing import Union
+
+from langchain.agents.agent import AgentOutputParser
+from langchain.agents.chat.prompt import FORMAT_INSTRUCTIONS
+from langchain.schema import AgentAction, AgentFinish, OutputParserException
+
+FINAL_ANSWER_ACTION = "Final Answer:"
+
+
+class ReActJsonSingleInputOutputParser(AgentOutputParser):
+    """Parses ReAct-style LLM calls that have a single tool input in json format.
+
+    Expects output to be in one of two formats.
+
+    If the output signals that an action should be taken,
+    should be in the below format. This will result in an AgentAction
+    being returned.
+
+    ```
+    Thought: agent thought here
+    Action:
+    ```
+    {
+        "action": "search",
+        "action_input": "what is the temperature in SF"
+    }
+    ```
+    ```
+
+    If the output signals that a final answer should be given,
+    should be in the below format. This will result in an AgentFinish
+    being returned.
+
+    ```
+    Thought: agent thought here
+    Final Answer: The temperature is 100 degrees
+    ```
+
+    """
+
+    pattern = re.compile(r"^.*?`{3}(?:json)?\n(.*?)`{3}.*?$", re.DOTALL)
+    """Regex pattern to parse the output."""
+
+    def get_format_instructions(self) -> str:
+        return FORMAT_INSTRUCTIONS
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        includes_answer = FINAL_ANSWER_ACTION in text
+        try:
+            found = self.pattern.search(text)
+            if not found:
+                # Fast fail to parse Final Answer.
+                raise ValueError("action not found")
+            action = found.group(1)
+            response = json.loads(action.strip())
+            includes_action = "action" in response
+            if includes_answer and includes_action:
+                raise OutputParserException(
+                    "Parsing LLM output produced a final answer "
+                    f"and a parse-able action: {text}"
+                )
+            return AgentAction(
+                response["action"], response.get("action_input", {}), text
+            )
+
+        except Exception:
+            if not includes_answer:
+                raise OutputParserException(f"Could not parse LLM output: {text}")
+            output = text.split(FINAL_ANSWER_ACTION)[-1].strip()
+            return AgentFinish({"output": output}, text)
+
+    @property
+    def _type(self) -> str:
+        return "react-json-single-input"

libs/langchain/langchain/agents/output_parsers/react_single_input.py

@@ -0,0 +1,93 @@
+import re
+from typing import Union
+
+from langchain.agents.agent import AgentOutputParser
+from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
+from langchain.schema import AgentAction, AgentFinish, OutputParserException
+
+FINAL_ANSWER_ACTION = "Final Answer:"
+MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = (
+    "Invalid Format: Missing 'Action:' after 'Thought:"
+)
+MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = (
+    "Invalid Format: Missing 'Action Input:' after 'Action:'"
+)
+FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = (
+    "Parsing LLM output produced both a final answer and a parse-able action:"
+)
+
+
+class ReActSingleInputOutputParser(AgentOutputParser):
+    """Parses ReAct-style LLM calls that have a single tool input.
+
+    Expects output to be in one of two formats.
+
+    If the output signals that an action should be taken,
+    should be in the below format. This will result in an AgentAction
+    being returned.
+
+    ```
+    Thought: agent thought here
+    Action: search
+    Action Input: what is the temperature in SF?
+    ```
+
+    If the output signals that a final answer should be given,
+    should be in the below format. This will result in an AgentFinish
+    being returned.
+
+    ```
+    Thought: agent thought here
+    Final Answer: The temperature is 100 degrees
+    ```
+
+    """
+
+    def get_format_instructions(self) -> str:
+        return FORMAT_INSTRUCTIONS
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        includes_answer = FINAL_ANSWER_ACTION in text
+        regex = (
+            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        )
+        action_match = re.search(regex, text, re.DOTALL)
+        if action_match:
+            if includes_answer:
+                raise OutputParserException(
+                    f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
+                )
+            action = action_match.group(1).strip()
+            action_input = action_match.group(2)
+            tool_input = action_input.strip(" ")
+            tool_input = tool_input.strip('"')
+
+            return AgentAction(action, tool_input, text)
+
+        elif includes_answer:
+            return AgentFinish(
+                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()}, text
+            )
+
+        if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            raise OutputParserException(
+                f"Could not parse LLM output: `{text}`",
+                observation=MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
+                llm_output=text,
+                send_to_llm=True,
+            )
+        elif not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        ):
+            raise OutputParserException(
+                f"Could not parse LLM output: `{text}`",
+                observation=MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
+                llm_output=text,
+                send_to_llm=True,
+            )
+        else:
+            raise OutputParserException(f"Could not parse LLM output: `{text}`")
+
+    @property
+    def _type(self) -> str:
+        return "react-single-input"

libs/langchain/langchain/agents/output_parsers/self_ask.py

@@ -0,0 +1,47 @@
+from typing import Sequence, Union
+
+from langchain.agents.agent import AgentOutputParser
+from langchain.schema import AgentAction, AgentFinish, OutputParserException
+
+
+class SelfAskOutputParser(AgentOutputParser):
+    """Parses self-ask style LLM calls.
+
+    Expects output to be in one of two formats.
+
+    If the output signals that an action should be taken,
+    should be in the below format. This will result in an AgentAction
+    being returned.
+
+    ```
+    Thoughts go here...
+    Follow up: what is the temperature in SF?
+    ```
+
+    If the output signals that a final answer should be given,
+    should be in the below format. This will result in an AgentFinish
+    being returned.
+
+    ```
+    Thoughts go here...
+    So the final answer is: The temperature is 100 degrees
+    ```
+
+    """
+
+    followups: Sequence[str] = ("Follow up:", "Followup:")
+    finish_string: str = "So the final answer is: "
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        last_line = text.split("\n")[-1]
+        if not any([follow in last_line for follow in self.followups]):
+            if self.finish_string not in last_line:
+                raise OutputParserException(f"Could not parse output: {text}")
+            return AgentFinish({"output": last_line[len(self.finish_string) :]}, text)
+
+        after_colon = text.split(":")[-1].strip()
+        return AgentAction("Intermediate Answer", after_colon, text)
+
+    @property
+    def _type(self) -> str:
+        return "self_ask"

libs/langchain/langchain/agents/output_parsers/xml.py

@@ -0,0 +1,51 @@
+from typing import Union
+
+from langchain.agents import AgentOutputParser
+from langchain.schema import AgentAction, AgentFinish
+
+
+class XMLAgentOutputParser(AgentOutputParser):
+    """Parses tool invocations and final answers in XML format.
+
+    Expects output to be in one of two formats.
+
+    If the output signals that an action should be taken,
+    should be in the below format. This will result in an AgentAction
+    being returned.
+
+    ```
+    <tool>search</tool>
+    <tool_input>what is 2 + 2</tool_input>
+    ```
+
+    If the output signals that a final answer should be given,
+    should be in the below format. This will result in an AgentFinish
+    being returned.
+
+    ```
+    <final_answer>Foo</final_answer>
+    ```
+    """
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        if "</tool>" in text:
+            tool, tool_input = text.split("</tool>")
+            _tool = tool.split("<tool>")[1]
+            _tool_input = tool_input.split("<tool_input>")[1]
+            if "</tool_input>" in _tool_input:
+                _tool_input = _tool_input.split("</tool_input>")[0]
+            return AgentAction(tool=_tool, tool_input=_tool_input, log=text)
+        elif "<final_answer>" in text:
+            _, answer = text.split("<final_answer>")
+            if "</final_answer>" in answer:
+                answer = answer.split("</final_answer>")[0]
+            return AgentFinish(return_values={"output": answer}, log=text)
+        else:
+            raise ValueError
+
+    def get_format_instructions(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def _type(self) -> str:
+        return "xml-agent"

libs/langchain/langchain/agents/self_ask_with_search/output_parser.py

@@ -1,25 +1,4 @@
-from typing import Sequence, Union
+from langchain.agents.output_parsers.self_ask import SelfAskOutputParser
 
-from langchain.agents.agent import AgentOutputParser
-from langchain.schema import AgentAction, AgentFinish, OutputParserException
-
-
-class SelfAskOutputParser(AgentOutputParser):
-    """Output parser for the self-ask agent."""
-
-    followups: Sequence[str] = ("Follow up:", "Followup:")
-    finish_string: str = "So the final answer is: "
-
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        last_line = text.split("\n")[-1]
-        if not any([follow in last_line for follow in self.followups]):
-            if self.finish_string not in last_line:
-                raise OutputParserException(f"Could not parse output: {text}")
-            return AgentFinish({"output": last_line[len(self.finish_string) :]}, text)
-
-        after_colon = text.split(":")[-1].strip()
-        return AgentAction("Intermediate Answer", after_colon, text)
-
-    @property
-    def _type(self) -> str:
-        return "self_ask"
+# For backwards compatibility
+__all__ = ["SelfAskOutputParser"]

libs/langchain/langchain/agents/xml/base.py

@@ -1,6 +1,7 @@
 from typing import Any, List, Tuple, Union
 
-from langchain.agents.agent import AgentOutputParser, BaseSingleActionAgent
+from langchain.agents.agent import BaseSingleActionAgent
+from langchain.agents.output_parsers.xml import XMLAgentOutputParser
 from langchain.agents.xml.prompt import agent_instructions
 from langchain.callbacks.base import Callbacks
 from langchain.chains.llm import LLMChain
@@ -9,29 +10,6 @@ from langchain.schema import AgentAction, AgentFinish
 from langchain.tools.base import BaseTool
 
 
-class XMLAgentOutputParser(AgentOutputParser):
-    """Output parser for XMLAgent."""
-
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        if "</tool>" in text:
-            tool, tool_input = text.split("</tool>")
-            _tool = tool.split("<tool>")[1]
-            _tool_input = tool_input.split("<tool_input>")[1]
-            return AgentAction(tool=_tool, tool_input=_tool_input, log=text)
-        elif "<final_answer>" in text:
-            _, answer = text.split("<final_answer>")
-            return AgentFinish(return_values={"output": answer}, log=text)
-        else:
-            raise ValueError
-
-    def get_format_instructions(self) -> str:
-        raise NotImplementedError
-
-    @property
-    def _type(self) -> str:
-        return "xml-agent"
-
-
 class XMLAgent(BaseSingleActionAgent):
     """Agent that uses XML tags.
 

libs/langchain/langchain/callbacks/base.py

@@ -1,7 +1,7 @@
 """Base callback handler that can be used to handle callbacks in langchain."""
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, TypeVar, Union
 from uuid import UUID
 
 from tenacity import RetryCallState
@@ -502,6 +502,9 @@ class AsyncCallbackHandler(BaseCallbackHandler):
         """Run on retriever error."""
 
 
+T = TypeVar("T", bound="BaseCallbackManager")
+
+
 class BaseCallbackManager(CallbackManagerMixin):
     """Base callback manager that handles callbacks from LangChain."""
 
@@ -527,6 +530,18 @@ class BaseCallbackManager(CallbackManagerMixin):
         self.metadata = metadata or {}
         self.inheritable_metadata = inheritable_metadata or {}
 
+    def copy(self: T) -> T:
+        """Copy the callback manager."""
+        return self.__class__(
+            handlers=self.handlers,
+            inheritable_handlers=self.inheritable_handlers,
+            parent_run_id=self.parent_run_id,
+            tags=self.tags,
+            inheritable_tags=self.inheritable_tags,
+            metadata=self.metadata,
+            inheritable_metadata=self.inheritable_metadata,
+        )
+
     @property
     def is_async(self) -> bool:
         """Whether the callback manager is async."""

libs/langchain/langchain/callbacks/tracers/base.py

@@ -58,6 +58,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
             else:
                 logger.debug(f"Parent run with UUID {run.parent_run_id} not found.")
         self.run_map[str(run.id)] = run
+        self._on_run_create(run)
 
     def _end_trace(self, run: Run) -> None:
         """End a trace for a run."""
@@ -74,6 +75,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
             ):
                 parent_run.child_execution_order = run.child_execution_order
         self.run_map.pop(str(run.id))
+        self._on_run_update(run)
 
     def _get_execution_order(self, parent_run_id: Optional[str] = None) -> int:
         """Get the execution order for a run."""
@@ -100,8 +102,9 @@ class BaseTracer(BaseCallbackHandler, ABC):
         tags: Optional[List[str]] = None,
         parent_run_id: Optional[UUID] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        name: Optional[str] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Start a trace for an LLM run."""
         parent_run_id_ = str(parent_run_id) if parent_run_id else None
         execution_order = self._get_execution_order(parent_run_id_)
@@ -120,9 +123,11 @@ class BaseTracer(BaseCallbackHandler, ABC):
             child_execution_order=execution_order,
             run_type="llm",
             tags=tags or [],
+            name=name,
         )
         self._start_trace(llm_run)
         self._on_llm_start(llm_run)
+        return llm_run
 
     def on_llm_new_token(
         self,
@@ -132,7 +137,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Run on new LLM token. Only available when streaming is enabled."""
         if not run_id:
             raise TracerException("No run_id provided for on_llm_new_token callback.")
@@ -151,6 +156,8 @@ class BaseTracer(BaseCallbackHandler, ABC):
                 "kwargs": event_kwargs,
             },
         )
+        self._on_llm_new_token(llm_run, token, chunk)
+        return llm_run
 
     def on_retry(
         self,
@@ -158,7 +165,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         *,
         run_id: UUID,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         if not run_id:
             raise TracerException("No run_id provided for on_retry callback.")
         run_id_ = str(run_id)
@@ -186,8 +193,9 @@ class BaseTracer(BaseCallbackHandler, ABC):
                 "kwargs": retry_d,
             },
         )
+        return llm_run
 
-    def on_llm_end(self, response: LLMResult, *, run_id: UUID, **kwargs: Any) -> None:
+    def on_llm_end(self, response: LLMResult, *, run_id: UUID, **kwargs: Any) -> Run:
         """End a trace for an LLM run."""
         if not run_id:
             raise TracerException("No run_id provided for on_llm_end callback.")
@@ -208,6 +216,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         llm_run.events.append({"name": "end", "time": llm_run.end_time})
         self._end_trace(llm_run)
         self._on_llm_end(llm_run)
+        return llm_run
 
     def on_llm_error(
         self,
@@ -215,7 +224,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         *,
         run_id: UUID,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Handle an error for an LLM run."""
         if not run_id:
             raise TracerException("No run_id provided for on_llm_error callback.")
@@ -229,6 +238,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         llm_run.events.append({"name": "error", "time": llm_run.end_time})
         self._end_trace(llm_run)
         self._on_chain_error(llm_run)
+        return llm_run
 
     def on_chain_start(
         self,
@@ -242,7 +252,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         run_type: Optional[str] = None,
         name: Optional[str] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Start a trace for a chain run."""
         parent_run_id_ = str(parent_run_id) if parent_run_id else None
         execution_order = self._get_execution_order(parent_run_id_)
@@ -266,6 +276,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         )
         self._start_trace(chain_run)
         self._on_chain_start(chain_run)
+        return chain_run
 
     def on_chain_end(
         self,
@@ -274,7 +285,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         run_id: UUID,
         inputs: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """End a trace for a chain run."""
         if not run_id:
             raise TracerException("No run_id provided for on_chain_end callback.")
@@ -291,6 +302,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
             chain_run.inputs = inputs if isinstance(inputs, dict) else {"input": inputs}
         self._end_trace(chain_run)
         self._on_chain_end(chain_run)
+        return chain_run
 
     def on_chain_error(
         self,
@@ -299,7 +311,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         inputs: Optional[Dict[str, Any]] = None,
         run_id: UUID,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Handle an error for a chain run."""
         if not run_id:
             raise TracerException("No run_id provided for on_chain_error callback.")
@@ -314,6 +326,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
             chain_run.inputs = inputs if isinstance(inputs, dict) else {"input": inputs}
         self._end_trace(chain_run)
         self._on_chain_error(chain_run)
+        return chain_run
 
     def on_tool_start(
         self,
@@ -324,8 +337,9 @@ class BaseTracer(BaseCallbackHandler, ABC):
         tags: Optional[List[str]] = None,
         parent_run_id: Optional[UUID] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        name: Optional[str] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Start a trace for a tool run."""
         parent_run_id_ = str(parent_run_id) if parent_run_id else None
         execution_order = self._get_execution_order(parent_run_id_)
@@ -345,11 +359,13 @@ class BaseTracer(BaseCallbackHandler, ABC):
             child_runs=[],
             run_type="tool",
             tags=tags or [],
+            name=name,
         )
         self._start_trace(tool_run)
         self._on_tool_start(tool_run)
+        return tool_run
 
-    def on_tool_end(self, output: str, *, run_id: UUID, **kwargs: Any) -> None:
+    def on_tool_end(self, output: str, *, run_id: UUID, **kwargs: Any) -> Run:
         """End a trace for a tool run."""
         if not run_id:
             raise TracerException("No run_id provided for on_tool_end callback.")
@@ -362,6 +378,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         tool_run.events.append({"name": "end", "time": tool_run.end_time})
         self._end_trace(tool_run)
         self._on_tool_end(tool_run)
+        return tool_run
 
     def on_tool_error(
         self,
@@ -369,7 +386,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         *,
         run_id: UUID,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Handle an error for a tool run."""
         if not run_id:
             raise TracerException("No run_id provided for on_tool_error callback.")
@@ -382,6 +399,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         tool_run.events.append({"name": "error", "time": tool_run.end_time})
         self._end_trace(tool_run)
         self._on_tool_error(tool_run)
+        return tool_run
 
     def on_retriever_start(
         self,
@@ -392,8 +410,9 @@ class BaseTracer(BaseCallbackHandler, ABC):
         parent_run_id: Optional[UUID] = None,
         tags: Optional[List[str]] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        name: Optional[str] = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Run when Retriever starts running."""
         parent_run_id_ = str(parent_run_id) if parent_run_id else None
         execution_order = self._get_execution_order(parent_run_id_)
@@ -402,7 +421,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
             kwargs.update({"metadata": metadata})
         retrieval_run = Run(
             id=run_id,
-            name="Retriever",
+            name=name or "Retriever",
             parent_run_id=parent_run_id,
             serialized=serialized,
             inputs={"query": query},
@@ -417,6 +436,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         )
         self._start_trace(retrieval_run)
         self._on_retriever_start(retrieval_run)
+        return retrieval_run
 
     def on_retriever_error(
         self,
@@ -424,7 +444,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         *,
         run_id: UUID,
         **kwargs: Any,
-    ) -> None:
+    ) -> Run:
         """Run when Retriever errors."""
         if not run_id:
             raise TracerException("No run_id provided for on_retriever_error callback.")
@@ -437,10 +457,11 @@ class BaseTracer(BaseCallbackHandler, ABC):
         retrieval_run.events.append({"name": "error", "time": retrieval_run.end_time})
         self._end_trace(retrieval_run)
         self._on_retriever_error(retrieval_run)
+        return retrieval_run
 
     def on_retriever_end(
         self, documents: Sequence[Document], *, run_id: UUID, **kwargs: Any
-    ) -> None:
+    ) -> Run:
         """Run when Retriever ends running."""
         if not run_id:
             raise TracerException("No run_id provided for on_retriever_end callback.")
@@ -452,6 +473,7 @@ class BaseTracer(BaseCallbackHandler, ABC):
         retrieval_run.events.append({"name": "end", "time": retrieval_run.end_time})
         self._end_trace(retrieval_run)
         self._on_retriever_end(retrieval_run)
+        return retrieval_run
 
     def __deepcopy__(self, memo: dict) -> BaseTracer:
         """Deepcopy the tracer."""
@@ -461,9 +483,23 @@ class BaseTracer(BaseCallbackHandler, ABC):
         """Copy the tracer."""
         return self
 
+    def _on_run_create(self, run: Run) -> None:
+        """Process a run upon creation."""
+
+    def _on_run_update(self, run: Run) -> None:
+        """Process a run upon update."""
+
     def _on_llm_start(self, run: Run) -> None:
         """Process the LLM Run upon start."""
 
+    def _on_llm_new_token(
+        self,
+        run: Run,
+        token: str,
+        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]],
+    ) -> None:
+        """Process new LLM token."""
+
     def _on_llm_end(self, run: Run) -> None:
         """Process the LLM Run."""
 

libs/langchain/langchain/callbacks/tracers/langchain.py

@@ -98,6 +98,7 @@ class LangChainTracer(BaseTracer):
         tags: Optional[List[str]] = None,
         parent_run_id: Optional[UUID] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        name: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
         """Start a trace for an LLM run."""
@@ -118,6 +119,7 @@ class LangChainTracer(BaseTracer):
             child_execution_order=execution_order,
             run_type="llm",
             tags=tags,
+            name=name,
         )
         self._start_trace(chat_model_run)
         self._on_chat_model_start(chat_model_run)

libs/langchain/langchain/callbacks/tracers/log_stream.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import math
+import threading
+from typing import (
+    Any,
+    AsyncIterator,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    TypedDict,
+    Union,
+)
+from uuid import UUID
+
+import jsonpatch
+from anyio import create_memory_object_stream
+
+from langchain.callbacks.tracers.base import BaseTracer
+from langchain.callbacks.tracers.schemas import Run
+from langchain.schema.output import ChatGenerationChunk, GenerationChunk
+
+
+class LogEntry(TypedDict):
+    id: str
+    """ID of the sub-run."""
+    name: str
+    """Name of the object being run."""
+    type: str
+    """Type of the object being run, eg. prompt, chain, llm, etc."""
+    tags: List[str]
+    """List of tags for the run."""
+    metadata: Dict[str, Any]
+    """Key-value pairs of metadata for the run."""
+    start_time: str
+    """ISO-8601 timestamp of when the run started."""
+
+    streamed_output_str: List[str]
+    """List of LLM tokens streamed by this run, if applicable."""
+    final_output: Optional[Any]
+    """Final output of this run.
+    Only available after the run has finished successfully."""
+    end_time: Optional[str]
+    """ISO-8601 timestamp of when the run ended.
+    Only available after the run has finished."""
+
+
+class RunState(TypedDict):
+    id: str
+    """ID of the run."""
+    streamed_output: List[Any]
+    """List of output chunks streamed by Runnable.stream()"""
+    final_output: Optional[Any]
+    """Final output of the run, usually the result of aggregating streamed_output.
+    Only available after the run has finished successfully."""
+
+    logs: list[LogEntry]
+    """List of sub-runs contained in this run, if any, in the order they were started.
+    If filters were supplied, this list will contain only the runs that matched the 
+    filters."""
+
+
+class RunLogPatch:
+    ops: List[Dict[str, Any]]
+    """List of jsonpatch operations, which describe how to create the run state
+    from an empty dict. This is the minimal representation of the log, designed to
+    be serialized as JSON and sent over the wire to reconstruct the log on the other
+    side. Reconstruction of the state can be done with any jsonpatch-compliant library,
+    see https://jsonpatch.com for more information."""
+
+    def __init__(self, *ops: Dict[str, Any]) -> None:
+        self.ops = list(ops)
+
+    def __add__(self, other: Union[RunLogPatch, Any]) -> RunLogPatch:
+        if type(other) == RunLogPatch:
+            ops = self.ops + other.ops
+            state = jsonpatch.apply_patch(None, ops)
+            return RunLog(*ops, state=state)
+
+        raise TypeError(
+            f"unsupported operand type(s) for +: '{type(self)}' and '{type(other)}'"
+        )
+
+    def __repr__(self) -> str:
+        from pprint import pformat
+
+        return f"RunLogPatch(ops={pformat(self.ops)})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, RunLogPatch) and self.ops == other.ops
+
+
+class RunLog(RunLogPatch):
+    state: RunState
+    """Current state of the log, obtained from applying all ops in sequence."""
+
+    def __init__(self, *ops: Dict[str, Any], state: RunState) -> None:
+        super().__init__(*ops)
+        self.state = state
+
+    def __add__(self, other: Union[RunLogPatch, Any]) -> RunLogPatch:
+        if type(other) == RunLogPatch:
+            ops = self.ops + other.ops
+            state = jsonpatch.apply_patch(self.state, other.ops)
+            return RunLog(*ops, state=state)
+
+        raise TypeError(
+            f"unsupported operand type(s) for +: '{type(self)}' and '{type(other)}'"
+        )
+
+    def __repr__(self) -> str:
+        from pprint import pformat
+
+        return f"RunLog(state={pformat(self.state)})"
+
+
+class LogStreamCallbackHandler(BaseTracer):
+    def __init__(
+        self,
+        *,
+        auto_close: bool = True,
+        include_names: Optional[Sequence[str]] = None,
+        include_types: Optional[Sequence[str]] = None,
+        include_tags: Optional[Sequence[str]] = None,
+        exclude_names: Optional[Sequence[str]] = None,
+        exclude_types: Optional[Sequence[str]] = None,
+        exclude_tags: Optional[Sequence[str]] = None,
+    ) -> None:
+        super().__init__()
+
+        self.auto_close = auto_close
+        self.include_names = include_names
+        self.include_types = include_types
+        self.include_tags = include_tags
+        self.exclude_names = exclude_names
+        self.exclude_types = exclude_types
+        self.exclude_tags = exclude_tags
+
+        send_stream, receive_stream = create_memory_object_stream(
+            math.inf, item_type=RunLogPatch
+        )
+        self.lock = threading.Lock()
+        self.send_stream = send_stream
+        self.receive_stream = receive_stream
+        self._index_map: Dict[UUID, int] = {}
+
+    def __aiter__(self) -> AsyncIterator[RunLogPatch]:
+        return self.receive_stream.__aiter__()
+
+    def include_run(self, run: Run) -> bool:
+        if run.parent_run_id is None:
+            return False
+
+        run_tags = run.tags or []
+
+        if (
+            self.include_names is None
+            and self.include_types is None
+            and self.include_tags is None
+        ):
+            include = True
+        else:
+            include = False
+
+        if self.include_names is not None:
+            include = include or run.name in self.include_names
+        if self.include_types is not None:
+            include = include or run.run_type in self.include_types
+        if self.include_tags is not None:
+            include = include or any(tag in self.include_tags for tag in run_tags)
+
+        if self.exclude_names is not None:
+            include = include and run.name not in self.exclude_names
+        if self.exclude_types is not None:
+            include = include and run.run_type not in self.exclude_types
+        if self.exclude_tags is not None:
+            include = include and all(tag not in self.exclude_tags for tag in run_tags)
+
+        return include
+
+    def _persist_run(self, run: Run) -> None:
+        # This is a legacy method only called once for an entire run tree
+        # therefore not useful here
+        pass
+
+    def _on_run_create(self, run: Run) -> None:
+        """Start a run."""
+        if run.parent_run_id is None:
+            self.send_stream.send_nowait(
+                RunLogPatch(
+                    {
+                        "op": "replace",
+                        "path": "",
+                        "value": RunState(
+                            id=run.id,
+                            streamed_output=[],
+                            final_output=None,
+                            logs=[],
+                        ),
+                    }
+                )
+            )
+
+        if not self.include_run(run):
+            return
+
+        # Determine previous index, increment by 1
+        with self.lock:
+            self._index_map[run.id] = max(self._index_map.values(), default=-1) + 1
+
+        # Add the run to the stream
+        self.send_stream.send_nowait(
+            RunLogPatch(
+                {
+                    "op": "add",
+                    "path": f"/logs/{self._index_map[run.id]}",
+                    "value": LogEntry(
+                        id=str(run.id),
+                        name=run.name,
+                        type=run.run_type,
+                        tags=run.tags or [],
+                        metadata=run.extra.get("metadata", {}),
+                        start_time=run.start_time.isoformat(timespec="milliseconds"),
+                        streamed_output_str=[],
+                        final_output=None,
+                        end_time=None,
+                    ),
+                }
+            )
+        )
+
+    def _on_run_update(self, run: Run) -> None:
+        """Finish a run."""
+        try:
+            index = self._index_map.get(run.id)
+
+            if index is None:
+                return
+
+            self.send_stream.send_nowait(
+                RunLogPatch(
+                    {
+                        "op": "add",
+                        "path": f"/logs/{index}/final_output",
+                        "value": run.outputs,
+                    },
+                    {
+                        "op": "add",
+                        "path": f"/logs/{index}/end_time",
+                        "value": run.end_time.isoformat(timespec="milliseconds"),
+                    },
+                )
+            )
+        finally:
+            if run.parent_run_id is None:
+                self.send_stream.send_nowait(
+                    RunLogPatch(
+                        {
+                            "op": "replace",
+                            "path": "/final_output",
+                            "value": run.outputs,
+                        }
+                    )
+                )
+                if self.auto_close:
+                    self.send_stream.close()
+
+    def _on_llm_new_token(
+        self,
+        run: Run,
+        token: str,
+        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]],
+    ) -> None:
+        """Process new LLM token."""
+        index = self._index_map.get(run.id)
+
+        if index is None:
+            return
+
+        self.send_stream.send_nowait(
+            RunLogPatch(
+                {
+                    "op": "add",
+                    "path": f"/logs/{index}/streamed_output_str/-",
+                    "value": token,
+                }
+            )
+        )

libs/langchain/langchain/chains/loading.py

@@ -358,10 +358,16 @@ def _load_qa_with_sources_chain(config: dict, **kwargs: Any) -> QAWithSourcesCha
 
 
 def _load_sql_database_chain(config: dict, **kwargs: Any) -> Any:
+    from langchain_experimental.sql import SQLDatabaseChain
+
     if "database" in kwargs:
         database = kwargs.pop("database")
     else:
         raise ValueError("`database` must be present.")
+    if "llm_chain" in config:
+        llm_chain_config = config.pop("llm_chain")
+        chain = load_chain_from_config(llm_chain_config)
+        return SQLDatabaseChain(llm_chain=chain, database=database, **config)
     if "llm" in config:
         llm_config = config.pop("llm")
         llm = load_llm_from_config(llm_config)
@@ -374,7 +380,6 @@ def _load_sql_database_chain(config: dict, **kwargs: Any) -> Any:
         prompt = load_prompt_from_config(prompt_config)
     else:
         prompt = None
-    from langchain_experimental.sql import SQLDatabaseChain
 
     return SQLDatabaseChain.from_llm(llm, database, prompt=prompt, **config)
 

libs/langchain/langchain/chains/question_answering/refine_prompts.py

@@ -33,7 +33,7 @@ refine_template = (
     "If the context isn't useful, return the original answer."
 )
 CHAT_REFINE_PROMPT = ChatPromptTemplate.from_messages(
-    [("human", "{question}"), ("ai", "{existing_answer}"), ("human", "refine_template")]
+    [("human", "{question}"), ("ai", "{existing_answer}"), ("human", refine_template)]
 )
 REFINE_PROMPT_SELECTOR = ConditionalPromptSelector(
     default_prompt=DEFAULT_REFINE_PROMPT,

libs/langchain/langchain/chat_models/__init__.py

@@ -26,9 +26,11 @@ from langchain.chat_models.ernie import ErnieBotChat
 from langchain.chat_models.fake import FakeListChatModel
 from langchain.chat_models.google_palm import ChatGooglePalm
 from langchain.chat_models.human import HumanInputChatModel
+from langchain.chat_models.javelin_ai_gateway import ChatJavelinAIGateway
 from langchain.chat_models.jinachat import JinaChat
 from langchain.chat_models.konko import ChatKonko
 from langchain.chat_models.litellm import ChatLiteLLM
+from langchain.chat_models.minimax import MiniMaxChat
 from langchain.chat_models.mlflow_ai_gateway import ChatMLflowAIGateway
 from langchain.chat_models.ollama import ChatOllama
 from langchain.chat_models.openai import ChatOpenAI
@@ -48,9 +50,11 @@ __all__ = [
     "ChatVertexAI",
     "JinaChat",
     "HumanInputChatModel",
+    "MiniMaxChat",
     "ChatAnyscale",
     "ChatLiteLLM",
     "ErnieBotChat",
+    "ChatJavelinAIGateway",
     "ChatKonko",
     "QianfanChatEndpoint",
 ]

libs/langchain/langchain/chat_models/anthropic.py

@@ -4,7 +4,11 @@ from langchain.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain.chat_models.base import BaseChatModel
+from langchain.chat_models.base import (
+    BaseChatModel,
+    _agenerate_from_stream,
+    _generate_from_stream,
+)
 from langchain.llms.anthropic import _AnthropicCommon
 from langchain.schema.messages import (
     AIMessage,
@@ -162,22 +166,22 @@ class ChatAnthropic(BaseChatModel, _AnthropicCommon):
         **kwargs: Any,
     ) -> ChatResult:
         if self.streaming:
-            completion = ""
-            for chunk in self._stream(messages, stop, run_manager, **kwargs):
-                completion += chunk.text
-        else:
-            prompt = self._convert_messages_to_prompt(
-                messages,
+            stream_iter = self._stream(
+                messages, stop=stop, run_manager=run_manager, **kwargs
             )
-            params: Dict[str, Any] = {
-                "prompt": prompt,
-                **self._default_params,
-                **kwargs,
-            }
-            if stop:
-                params["stop_sequences"] = stop
-            response = self.client.completions.create(**params)
-            completion = response.completion
+            return _generate_from_stream(stream_iter)
+        prompt = self._convert_messages_to_prompt(
+            messages,
+        )
+        params: Dict[str, Any] = {
+            "prompt": prompt,
+            **self._default_params,
+            **kwargs,
+        }
+        if stop:
+            params["stop_sequences"] = stop
+        response = self.client.completions.create(**params)
+        completion = response.completion
         message = AIMessage(content=completion)
         return ChatResult(generations=[ChatGeneration(message=message)])
 
@@ -189,22 +193,22 @@ class ChatAnthropic(BaseChatModel, _AnthropicCommon):
         **kwargs: Any,
     ) -> ChatResult:
         if self.streaming:
-            completion = ""
-            async for chunk in self._astream(messages, stop, run_manager, **kwargs):
-                completion += chunk.text
-        else:
-            prompt = self._convert_messages_to_prompt(
-                messages,
+            stream_iter = self._astream(
+                messages, stop=stop, run_manager=run_manager, **kwargs
             )
-            params: Dict[str, Any] = {
-                "prompt": prompt,
-                **self._default_params,
-                **kwargs,
-            }
-            if stop:
-                params["stop_sequences"] = stop
-            response = await self.async_client.completions.create(**params)
-            completion = response.completion
+            return await _agenerate_from_stream(stream_iter)
+        prompt = self._convert_messages_to_prompt(
+            messages,
+        )
+        params: Dict[str, Any] = {
+            "prompt": prompt,
+            **self._default_params,
+            **kwargs,
+        }
+        if stop:
+            params["stop_sequences"] = stop
+        response = await self.async_client.completions.create(**params)
+        completion = response.completion
         message = AIMessage(content=completion)
         return ChatResult(generations=[ChatGeneration(message=message)])
 

libs/langchain/langchain/chat_models/baidu_qianfan_endpoint.py

@@ -26,6 +26,7 @@ from langchain.schema.messages import (
     ChatMessage,
     FunctionMessage,
     HumanMessage,
+    SystemMessage,
 )
 from langchain.schema.output import ChatGenerationChunk
 from langchain.utils import get_from_dict_or_env
@@ -80,7 +81,7 @@ class QianfanChatEndpoint(BaseChatModel):
 
             from langchain.chat_models import QianfanChatEndpoint
             qianfan_chat = QianfanChatEndpoint(model="ERNIE-Bot",
-                endpoint="your_endpoint", ak="your_ak", sk="your_sk")
+                endpoint="your_endpoint", qianfan_ak="your_ak", qianfan_sk="your_sk")
     """
 
     model_kwargs: Dict[str, Any] = Field(default_factory=dict)
@@ -174,9 +175,35 @@ class QianfanChatEndpoint(BaseChatModel):
         self,
         messages: List[BaseMessage],
         **kwargs: Any,
-    ) -> dict:
+    ) -> Dict[str, Any]:
+        """
+        Converts a list of messages into a dictionary containing the message content
+        and default parameters.
+
+        Args:
+            messages (List[BaseMessage]): The list of messages.
+            **kwargs (Any): Optional arguments to add additional parameters to the
+            resulting dictionary.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the message content and default
+            parameters.
+
+        """
+        messages_dict: Dict[str, Any] = {
+            "messages": [
+                convert_message_to_dict(m)
+                for m in messages
+                if not isinstance(m, SystemMessage)
+            ]
+        }
+        for i in [i for i, m in enumerate(messages) if isinstance(m, SystemMessage)]:
+            if "system" not in messages_dict:
+                messages_dict["system"] = ""
+            messages_dict["system"] += messages[i].content + "\n"
+
         return {
-            **{"messages": [convert_message_to_dict(m) for m in messages]},
+            **messages_dict,
             **self._default_params,
             **kwargs,
         }
@@ -206,7 +233,7 @@ class QianfanChatEndpoint(BaseChatModel):
             lc_msg = AIMessage(content=completion, additional_kwargs={})
             gen = ChatGeneration(
                 message=lc_msg,
-                generation_info=dict(finish_reason="finished"),
+                generation_info=dict(finish_reason="stop"),
             )
             return ChatResult(
                 generations=[gen],
@@ -217,7 +244,7 @@ class QianfanChatEndpoint(BaseChatModel):
         lc_msg = AIMessage(content=response_payload["result"], additional_kwargs={})
         gen = ChatGeneration(
             message=lc_msg,
-            generation_info=dict(finish_reason="finished"),
+            generation_info=dict(finish_reason="stop"),
         )
         token_usage = response_payload.get("usage", {})
         llm_output = {"token_usage": token_usage, "model_name": self.model}
@@ -232,12 +259,14 @@ class QianfanChatEndpoint(BaseChatModel):
     ) -> ChatResult:
         if self.streaming:
             completion = ""
+            token_usage = {}
             async for chunk in self._astream(messages, stop, run_manager, **kwargs):
                 completion += chunk.text
+
             lc_msg = AIMessage(content=completion, additional_kwargs={})
             gen = ChatGeneration(
                 message=lc_msg,
-                generation_info=dict(finish_reason="finished"),
+                generation_info=dict(finish_reason="stop"),
             )
             return ChatResult(
                 generations=[gen],
@@ -249,7 +278,7 @@ class QianfanChatEndpoint(BaseChatModel):
         generations = []
         gen = ChatGeneration(
             message=lc_msg,
-            generation_info=dict(finish_reason="finished"),
+            generation_info=dict(finish_reason="stop"),
         )
         generations.append(gen)
         token_usage = response_payload.get("usage", {})
@@ -269,11 +298,10 @@ class QianfanChatEndpoint(BaseChatModel):
                 chunk = ChatGenerationChunk(
                     text=res["result"],
                     message=_convert_resp_to_message_chunk(res),
-                    generation_info={"finish_reason": "finished"},
                 )
                 yield chunk
                 if run_manager:
-                    run_manager.on_llm_new_token(chunk.text)
+                    run_manager.on_llm_new_token(chunk.text, chunk=chunk)
 
     async def _astream(
         self,
@@ -286,8 +314,9 @@ class QianfanChatEndpoint(BaseChatModel):
         async for res in await self.client.ado(**params):
             if res:
                 chunk = ChatGenerationChunk(
-                    text=res["result"], message=_convert_resp_to_message_chunk(res)
+                    text=res["result"],
+                    message=_convert_resp_to_message_chunk(res),
                 )
                 yield chunk
                 if run_manager:
-                    await run_manager.on_llm_new_token(chunk.text)
+                    await run_manager.on_llm_new_token(chunk.text, chunk=chunk)

libs/langchain/langchain/chat_models/base.py

@@ -49,6 +49,30 @@ def _get_verbosity() -> bool:
     return langchain.verbose
 
 
+def _generate_from_stream(stream: Iterator[ChatGenerationChunk]) -> ChatResult:
+    generation: Optional[ChatGenerationChunk] = None
+    for chunk in stream:
+        if generation is None:
+            generation = chunk
+        else:
+            generation += chunk
+    assert generation is not None
+    return ChatResult(generations=[generation])
+
+
+async def _agenerate_from_stream(
+    stream: AsyncIterator[ChatGenerationChunk],
+) -> ChatResult:
+    generation: Optional[ChatGenerationChunk] = None
+    async for chunk in stream:
+        if generation is None:
+            generation = chunk
+        else:
+            generation += chunk
+    assert generation is not None
+    return ChatResult(generations=[generation])
+
+
 class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
     """Base class for Chat models."""
 
@@ -115,6 +139,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
                     callbacks=config.get("callbacks"),
                     tags=config.get("tags"),
                     metadata=config.get("metadata"),
+                    run_name=config.get("run_name"),
                     **kwargs,
                 ).generations[0][0],
             ).message,
@@ -141,6 +166,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
             callbacks=config.get("callbacks"),
             tags=config.get("tags"),
             metadata=config.get("metadata"),
+            run_name=config.get("run_name"),
             **kwargs,
         )
         return cast(
@@ -173,7 +199,11 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
                 self.metadata,
             )
             (run_manager,) = callback_manager.on_chat_model_start(
-                dumpd(self), [messages], invocation_params=params, options=options
+                dumpd(self),
+                [messages],
+                invocation_params=params,
+                options=options,
+                name=config.get("run_name"),
             )
             try:
                 generation: Optional[ChatGenerationChunk] = None
@@ -220,7 +250,11 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
                 self.metadata,
             )
             (run_manager,) = await callback_manager.on_chat_model_start(
-                dumpd(self), [messages], invocation_params=params, options=options
+                dumpd(self),
+                [messages],
+                invocation_params=params,
+                options=options,
+                name=config.get("run_name"),
             )
             try:
                 generation: Optional[ChatGenerationChunk] = None
@@ -274,6 +308,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
         *,
         tags: Optional[List[str]] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        run_name: Optional[str] = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Top Level call"""
@@ -290,7 +325,11 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
             self.metadata,
         )
         run_managers = callback_manager.on_chat_model_start(
-            dumpd(self), messages, invocation_params=params, options=options
+            dumpd(self),
+            messages,
+            invocation_params=params,
+            options=options,
+            name=run_name,
         )
         results = []
         for i, m in enumerate(messages):
@@ -330,6 +369,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
         *,
         tags: Optional[List[str]] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        run_name: Optional[str] = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Top Level call"""
@@ -347,7 +387,11 @@ class BaseChatModel(BaseLanguageModel[BaseMessageChunk], ABC):
         )
 
         run_managers = await callback_manager.on_chat_model_start(
-            dumpd(self), messages, invocation_params=params, options=options
+            dumpd(self),
+            messages,
+            invocation_params=params,
+            options=options,
+            name=run_name,
         )
 
         results = await asyncio.gather(

libs/langchain/langchain/chat_models/bedrock.py

@@ -1,14 +1,13 @@
-from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
+from typing import Any, Dict, Iterator, List, Optional
 
 from langchain.callbacks.manager import (
-    AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
 from langchain.chat_models.anthropic import convert_messages_to_prompt_anthropic
 from langchain.chat_models.base import BaseChatModel
 from langchain.llms.bedrock import BedrockBase
 from langchain.pydantic_v1 import Extra
-from langchain.schema.messages import AIMessage, BaseMessage
+from langchain.schema.messages import AIMessage, AIMessageChunk, BaseMessage
 from langchain.schema.output import ChatGeneration, ChatGenerationChunk, ChatResult
 
 
@@ -48,20 +47,16 @@ class BedrockChat(BaseChatModel, BedrockBase):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
-        raise NotImplementedError(
-            """Bedrock doesn't support stream requests at the moment."""
+        provider = self._get_provider()
+        prompt = ChatPromptAdapter.convert_messages_to_prompt(
+            provider=provider, messages=messages
         )
 
-    def _astream(
-        self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> AsyncIterator[ChatGenerationChunk]:
-        raise NotImplementedError(
-            """Bedrock doesn't support async requests at the moment."""
-        )
+        for chunk in self._prepare_input_and_invoke_stream(
+            prompt=prompt, stop=stop, run_manager=run_manager, **kwargs
+        ):
+            delta = chunk.text
+            yield ChatGenerationChunk(message=AIMessageChunk(content=delta))
 
     def _generate(
         self,
@@ -70,29 +65,24 @@ class BedrockChat(BaseChatModel, BedrockBase):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> ChatResult:
-        provider = self._get_provider()
-        prompt = ChatPromptAdapter.convert_messages_to_prompt(
-            provider=provider, messages=messages
-        )
+        completion = ""
 
-        params: Dict[str, Any] = {**kwargs}
-        if stop:
-            params["stop_sequences"] = stop
+        if self.streaming:
+            for chunk in self._stream(messages, stop, run_manager, **kwargs):
+                completion += chunk.text
+        else:
+            provider = self._get_provider()
+            prompt = ChatPromptAdapter.convert_messages_to_prompt(
+                provider=provider, messages=messages
+            )
 
-        completion = self._prepare_input_and_invoke(
-            prompt=prompt, stop=stop, run_manager=run_manager, **params
-        )
+            params: Dict[str, Any] = {**kwargs}
+            if stop:
+                params["stop_sequences"] = stop
+
+            completion = self._prepare_input_and_invoke(
+                prompt=prompt, stop=stop, run_manager=run_manager, **params
+            )
 
         message = AIMessage(content=completion)
         return ChatResult(generations=[ChatGeneration(message=message)])
-
-    async def _agenerate(
-        self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> ChatResult:
-        raise NotImplementedError(
-            """Bedrock doesn't support async stream requests at the moment."""
-        )

libs/langchain/langchain/chat_models/javelin_ai_gateway.py

@@ -0,0 +1,223 @@
+import logging
+from typing import Any, Dict, List, Mapping, Optional
+
+from langchain.callbacks.manager import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain.chat_models.base import BaseChatModel
+from langchain.pydantic_v1 import BaseModel, Extra
+from langchain.schema import (
+    ChatGeneration,
+    ChatResult,
+)
+from langchain.schema.messages import (
+    AIMessage,
+    BaseMessage,
+    ChatMessage,
+    FunctionMessage,
+    HumanMessage,
+    SystemMessage,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# Ignoring type because below is valid pydantic code
+# Unexpected keyword argument "extra" for "__init_subclass__" of "object"  [call-arg]
+class ChatParams(BaseModel, extra=Extra.allow):  # type: ignore[call-arg]
+    """Parameters for the `Javelin AI Gateway` LLM."""
+
+    temperature: float = 0.0
+    stop: Optional[List[str]] = None
+    max_tokens: Optional[int] = None
+
+
+class ChatJavelinAIGateway(BaseChatModel):
+    """`Javelin AI Gateway` chat models API.
+
+    To use, you should have the ``javelin_sdk`` python package installed.
+    For more information, see https://docs.getjavelin.io
+
+    Example:
+        .. code-block:: python
+
+            from langchain.chat_models import ChatJavelinAIGateway
+
+            chat = ChatJavelinAIGateway(
+                gateway_uri="<javelin-ai-gateway-uri>",
+                route="<javelin-ai-gateway-chat-route>",
+                params={
+                    "temperature": 0.1
+                }
+            )
+    """
+
+    route: str
+    """The route to use for the Javelin AI Gateway API."""
+
+    gateway_uri: Optional[str] = None
+    """The URI for the Javelin AI Gateway API."""
+
+    params: Optional[ChatParams] = None
+    """Parameters for the Javelin AI Gateway LLM."""
+
+    client: Any
+    """javelin client."""
+
+    javelin_api_key: Optional[str] = None
+    """The API key for the Javelin AI Gateway."""
+
+    def __init__(self, **kwargs: Any):
+        try:
+            from javelin_sdk import (
+                JavelinClient,
+                UnauthorizedError,
+            )
+        except ImportError:
+            raise ImportError(
+                "Could not import javelin_sdk python package. "
+                "Please install it with `pip install javelin_sdk`."
+            )
+
+        super().__init__(**kwargs)
+        if self.gateway_uri:
+            try:
+                self.client = JavelinClient(
+                    base_url=self.gateway_uri, api_key=self.javelin_api_key
+                )
+            except UnauthorizedError as e:
+                raise ValueError("Javelin: Incorrect API Key.") from e
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        params: Dict[str, Any] = {
+            "gateway_uri": self.gateway_uri,
+            "javelin_api_key": self.javelin_api_key,
+            "route": self.route,
+            **(self.params.dict() if self.params else {}),
+        }
+        return params
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        message_dicts = [
+            ChatJavelinAIGateway._convert_message_to_dict(message)
+            for message in messages
+        ]
+        data: Dict[str, Any] = {
+            "messages": message_dicts,
+            **(self.params.dict() if self.params else {}),
+        }
+
+        resp = self.client.query_route(self.route, query_body=data)
+
+        return ChatJavelinAIGateway._create_chat_result(resp.dict())
+
+    async def _agenerate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        message_dicts = [
+            ChatJavelinAIGateway._convert_message_to_dict(message)
+            for message in messages
+        ]
+        data: Dict[str, Any] = {
+            "messages": message_dicts,
+            **(self.params.dict() if self.params else {}),
+        }
+
+        resp = await self.client.aquery_route(self.route, query_body=data)
+
+        return ChatJavelinAIGateway._create_chat_result(resp.dict())
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        return self._default_params
+
+    def _get_invocation_params(
+        self, stop: Optional[List[str]] = None, **kwargs: Any
+    ) -> Dict[str, Any]:
+        """Get the parameters used to invoke the model FOR THE CALLBACKS."""
+        return {
+            **self._default_params,
+            **super()._get_invocation_params(stop=stop, **kwargs),
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of chat model."""
+        return "javelin-ai-gateway-chat"
+
+    @staticmethod
+    def _convert_dict_to_message(_dict: Mapping[str, Any]) -> BaseMessage:
+        role = _dict["role"]
+        content = _dict["content"]
+        if role == "user":
+            return HumanMessage(content=content)
+        elif role == "assistant":
+            return AIMessage(content=content)
+        elif role == "system":
+            return SystemMessage(content=content)
+        else:
+            return ChatMessage(content=content, role=role)
+
+    @staticmethod
+    def _raise_functions_not_supported() -> None:
+        raise ValueError(
+            "Function messages are not supported by the Javelin AI Gateway. Please"
+            " create a feature request at https://docs.getjavelin.io"
+        )
+
+    @staticmethod
+    def _convert_message_to_dict(message: BaseMessage) -> dict:
+        if isinstance(message, ChatMessage):
+            message_dict = {"role": message.role, "content": message.content}
+        elif 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, FunctionMessage):
+            raise ValueError(
+                "Function messages are not supported by the Javelin AI Gateway. Please"
+                " create a feature request at https://docs.getjavelin.io"
+            )
+        else:
+            raise ValueError(f"Got unknown message type: {message}")
+
+        if "function_call" in message.additional_kwargs:
+            ChatJavelinAIGateway._raise_functions_not_supported()
+        if message.additional_kwargs:
+            logger.warning(
+                "Additional message arguments are unsupported by Javelin AI Gateway "
+                " and will be ignored: %s",
+                message.additional_kwargs,
+            )
+        return message_dict
+
+    @staticmethod
+    def _create_chat_result(response: Mapping[str, Any]) -> ChatResult:
+        generations = []
+        for candidate in response["llm_response"]["choices"]:
+            message = ChatJavelinAIGateway._convert_dict_to_message(
+                candidate["message"]
+            )
+            message_metadata = candidate.get("metadata", {})
+            gen = ChatGeneration(
+                message=message,
+                generation_info=dict(message_metadata),
+            )
+            generations.append(gen)
+
+        response_metadata = response.get("metadata", {})
+        return ChatResult(generations=generations, llm_output=response_metadata)

libs/langchain/langchain/chat_models/jinachat.py

@@ -27,7 +27,11 @@ from langchain.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain.chat_models.base import BaseChatModel
+from langchain.chat_models.base import (
+    BaseChatModel,
+    _agenerate_from_stream,
+    _generate_from_stream,
+)
 from langchain.pydantic_v1 import Field, root_validator
 from langchain.schema import (
     AIMessage,
@@ -319,16 +323,10 @@ class JinaChat(BaseChatModel):
         **kwargs: Any,
     ) -> ChatResult:
         if self.streaming:
-            generation: Optional[ChatGenerationChunk] = None
-            for chunk in self._stream(
+            stream_iter = self._stream(
                 messages=messages, stop=stop, run_manager=run_manager, **kwargs
-            ):
-                if generation is None:
-                    generation = chunk
-                else:
-                    generation += chunk
-            assert generation is not None
-            return ChatResult(generations=[generation])
+            )
+            return _generate_from_stream(stream_iter)
 
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}
@@ -384,16 +382,10 @@ class JinaChat(BaseChatModel):
         **kwargs: Any,
     ) -> ChatResult:
         if self.streaming:
-            generation: Optional[ChatGenerationChunk] = None
-            async for chunk in self._astream(
+            stream_iter = self._astream(
                 messages=messages, stop=stop, run_manager=run_manager, **kwargs
-            ):
-                if generation is None:
-                    generation = chunk
-                else:
-                    generation += chunk
-            assert generation is not None
-            return ChatResult(generations=[generation])
+            )
+            return await _agenerate_from_stream(stream_iter)
 
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}

libs/langchain/langchain/chat_models/konko.py

@@ -21,6 +21,7 @@ from langchain.adapters.openai import convert_dict_to_message, convert_message_t
 from langchain.callbacks.manager import (
     CallbackManagerForLLMRun,
 )
+from langchain.chat_models.base import _generate_from_stream
 from langchain.chat_models.openai import ChatOpenAI, _convert_delta_to_message_chunk
 from langchain.pydantic_v1 import Field, root_validator
 from langchain.schema import ChatGeneration, ChatResult
@@ -224,16 +225,10 @@ class ChatKonko(ChatOpenAI):
     ) -> ChatResult:
         should_stream = stream if stream is not None else self.streaming
         if should_stream:
-            generation: Optional[ChatGenerationChunk] = None
-            for chunk in self._stream(
-                messages=messages, stop=stop, run_manager=run_manager, **kwargs
-            ):
-                if generation is None:
-                    generation = chunk
-                else:
-                    generation += chunk
-            assert generation is not None
-            return ChatResult(generations=[generation])
+            stream_iter = self._stream(
+                messages, stop=stop, run_manager=run_manager, **kwargs
+            )
+            return _generate_from_stream(stream_iter)
 
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}

libs/langchain/langchain/chat_models/litellm.py

@@ -19,7 +19,11 @@ from langchain.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain.chat_models.base import BaseChatModel
+from langchain.chat_models.base import (
+    BaseChatModel,
+    _agenerate_from_stream,
+    _generate_from_stream,
+)
 from langchain.llms.base import create_base_retry_decorator
 from langchain.pydantic_v1 import Field, root_validator
 from langchain.schema import (
@@ -320,16 +324,10 @@ class ChatLiteLLM(BaseChatModel):
     ) -> ChatResult:
         should_stream = stream if stream is not None else self.streaming
         if should_stream:
-            generation: Optional[ChatGenerationChunk] = None
-            for chunk in self._stream(
-                messages=messages, stop=stop, run_manager=run_manager, **kwargs
-            ):
-                if generation is None:
-                    generation = chunk
-                else:
-                    generation += chunk
-            assert generation is not None
-            return ChatResult(generations=[generation])
+            stream_iter = self._stream(
+                messages, stop=stop, run_manager=run_manager, **kwargs
+            )
+            return _generate_from_stream(stream_iter)
 
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}
@@ -421,16 +419,10 @@ class ChatLiteLLM(BaseChatModel):
     ) -> ChatResult:
         should_stream = stream if stream is not None else self.streaming
         if should_stream:
-            generation: Optional[ChatGenerationChunk] = None
-            async for chunk in self._astream(
+            stream_iter = self._astream(
                 messages=messages, stop=stop, run_manager=run_manager, **kwargs
-            ):
-                if generation is None:
-                    generation = chunk
-                else:
-                    generation += chunk
-            assert generation is not None
-            return ChatResult(generations=[generation])
+            )
+            return await _agenerate_from_stream(stream_iter)
 
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}

libs/langchain/langchain/chat_models/minimax.py

@@ -0,0 +1,93 @@
+"""Wrapper around Minimax chat models."""
+import logging
+from typing import Any, Dict, List, Optional
+
+from langchain.callbacks.manager import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain.chat_models.base import BaseChatModel
+from langchain.llms.minimax import MinimaxCommon
+from langchain.llms.utils import enforce_stop_tokens
+from langchain.schema import (
+    AIMessage,
+    BaseMessage,
+    ChatResult,
+    HumanMessage,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_message(msg_type: str, text: str) -> Dict:
+    return {"sender_type": msg_type, "text": text}
+
+
+def _parse_chat_history(history: List[BaseMessage]) -> List:
+    """Parse a sequence of messages into history."""
+    chat_history = []
+    for message in history:
+        if isinstance(message, HumanMessage):
+            chat_history.append(_parse_message("USER", message.content))
+        if isinstance(message, AIMessage):
+            chat_history.append(_parse_message("BOT", message.content))
+    return chat_history
+
+
+class MiniMaxChat(MinimaxCommon, BaseChatModel):
+    """Wrapper around Minimax large language models.
+
+    To use, you should have the environment variable ``MINIMAX_GROUP_ID`` and
+    ``MINIMAX_API_KEY`` set with your API token, or pass it as a named parameter to
+    the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain.chat_models import MiniMaxChat
+            llm = MiniMaxChat(model_name="abab5-chat")
+
+    """
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Generate next turn in the conversation.
+        Args:
+            messages: The history of the conversation as a list of messages. Code chat
+                does not support context.
+            stop: The list of stop words (optional).
+            run_manager: The CallbackManager for LLM run, it's not used at the moment.
+
+        Returns:
+            The ChatResult that contains outputs generated by the model.
+
+        Raises:
+            ValueError: if the last message in the list is not from human.
+        """
+        if not messages:
+            raise ValueError(
+                "You should provide at least one message to start the chat!"
+            )
+        history = _parse_chat_history(messages)
+        payload = self._default_params
+        payload["messages"] = history
+        text = self._client.post(payload)
+
+        # This is required since the stop are not enforced by the model parameters
+        return text if stop is None else enforce_stop_tokens(text, stop)
+
+    async def _agenerate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        raise NotImplementedError(
+            """Minimax AI doesn't support async requests at the moment."""
+        )

libs/langchain/langchain/chat_models/openai.py

@@ -22,7 +22,11 @@ from langchain.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain.chat_models.base import BaseChatModel
+from langchain.chat_models.base import (
+    BaseChatModel,
+    _agenerate_from_stream,
+    _generate_from_stream,
+)
 from langchain.llms.base import create_base_retry_decorator
 from langchain.pydantic_v1 import Field, root_validator
 from langchain.schema import ChatGeneration, ChatResult
@@ -330,17 +334,10 @@ class ChatOpenAI(BaseChatModel):
     ) -> ChatResult:
         should_stream = stream if stream is not None else self.streaming
         if should_stream:
-            generation: Optional[ChatGenerationChunk] = None
-            for chunk in self._stream(
-                messages=messages, stop=stop, run_manager=run_manager, **kwargs
-            ):
-                if generation is None:
-                    generation = chunk
-                else:
-                    generation += chunk
-            assert generation is not None
-            return ChatResult(generations=[generation])
-
+            stream_iter = self._stream(
+                messages, stop=stop, run_manager=run_manager, **kwargs
+            )
+            return _generate_from_stream(stream_iter)
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}
         response = self.completion_with_retry(
@@ -411,16 +408,10 @@ class ChatOpenAI(BaseChatModel):
     ) -> ChatResult:
         should_stream = stream if stream is not None else self.streaming
         if should_stream:
-            generation: Optional[ChatGenerationChunk] = None
-            async for chunk in self._astream(
-                messages=messages, stop=stop, run_manager=run_manager, **kwargs
-            ):
-                if generation is None:
-                    generation = chunk
-                else:
-                    generation += chunk
-            assert generation is not None
-            return ChatResult(generations=[generation])
+            stream_iter = self._astream(
+                messages, stop=stop, run_manager=run_manager, **kwargs
+            )
+            return await _agenerate_from_stream(stream_iter)
 
         message_dicts, params = self._create_message_dicts(messages, stop)
         params = {**params, **kwargs}