langchain.chains.qa_with_sources.retrieval.RetrievalQAWithSourcesChain

注意

RetrievalQAWithSourcesChain 实现了标准的 Runnable 接口。 🏃

Runnable 接口 还有其他在 runnables 上可用的方法，例如 with_types, with_retry, assign, bind, get_graph, 以及更多。

class langchain.chains.qa_with_sources.retrieval.RetrievalQAWithSourcesChain

基类: BaseQAWithSourcesChain

基于索引的带来源的问题解答。

param callback_manager: Optional[BaseCallbackManager] = None

[已弃用] 请使用 callbacks 代替。

param callbacks: Callbacks = None

回调处理程序（或回调管理器）的可选列表。默认为 None。回调处理程序在链式调用的生命周期中被调用，从 on_chain_start 开始，到 on_chain_end 或 on_chain_error 结束。每个自定义链可以选择性地调用额外的回调方法，完整详情请参阅回调文档。

param combine_documents_chain: BaseCombineDocumentsChain [必需]

用于组合文档的链。

param max_tokens_limit: int = 3375

根据令牌限制从存储返回的文档，仅对 StuffDocumentChain 强制执行，并且如果 reduce_k_below_max_tokens 设置为 true

param memory: Optional[BaseMemory] = None

可选的内存对象。默认为 None。内存是一个类，在每个链的开始和结束时被调用。在开始时，内存加载变量并在链中传递它们。在结束时，它保存任何返回的变量。有许多不同类型的内存 - 请参阅内存文档以获取完整目录。

param metadata: Optional[Dict[str, Any]] = None

与链关联的可选元数据。默认为 None。此元数据将与对此链的每次调用关联，并作为参数传递给 callbacks 中定义的处理程序。您可以使用这些元数据来标识链的特定实例及其用例。

param reduce_k_below_max_tokens: bool = False

根据令牌限制减少从存储返回的结果数量

param retriever: BaseRetriever [必需]

要连接的索引。

param return_source_documents: bool = False

返回源文档。

param tags: Optional[List[str]] = None

与链关联的可选标签列表。默认为 None。这些标签将与对此链的每次调用关联，并作为参数传递给 callbacks 中定义的处理程序。您可以使用这些标签来标识链的特定实例及其用例。

param verbose: bool [可选]

是否以 verbose 模式运行。在 verbose 模式下，一些中间日志将被打印到控制台。默认为全局 verbose 值，可通过 langchain.globals.get_verbose() 访问。

__call__(inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, include_run_info: bool = False) → Dict[str, Any]

Deprecated since version langchain==0.1.0: 请使用 invoke 代替。

执行链。

参数

• inputs (Union[Dict[str, Any], Any]) – 输入字典，或者如果链只期望一个参数，则为单个输入。应包含 Chain.input_keys 中指定的所有输入，但链的内存将设置的输入除外。

• return_only_outputs (bool) – 是否仅在响应中返回输出。如果为 True，则仅返回由此链生成的新键。如果为 False，则返回输入键和由此链生成的新键。默认为 False。

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 用于此链运行的回调。这些回调将添加到在构建期间传递给链的回调之外调用，但只有这些运行时回调将传播到对其他对象的调用。

• tags (Optional[List[str]]) – 要传递给所有回调的字符串标签列表。这些标签将添加到在构建期间传递给链的标签之外传递，但只有这些运行时标签将传播到对其他对象的调用。

• metadata (Optional[Dict[str, Any]]) – 与链关联的可选元数据。默认为 None

• include_run_info (bool) – 是否在响应中包含运行信息。默认为 False。

• run_name (Optional[str]) –

返回值

命名输出的字典。应包含

Chain.output_keys 中指定的所有输出.

返回类型

Dict[str, Any]

async abatch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]

默认实现使用 asyncio.gather 并行运行 ainvoke。

batch 的默认实现非常适合 IO 绑定的 runnables。

如果子类可以更有效地进行批处理，则应覆盖此方法；例如，如果底层 Runnable 使用支持批处理模式的 API。

参数

• inputs (List[Input]) – Runnable 的输入列表。

• config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) – 调用 Runnable 时要使用的配置。该配置支持标准键，如用于跟踪目的的“tags”、“metadata”，用于控制并行执行多少工作的“max_concurrency”以及其他键。有关更多详细信息，请参阅 RunnableConfig。默认为 None。

• return_exceptions (bool) – 是否返回异常而不是引发异常。默认为 False。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

返回值

来自 Runnable 的输出列表。

返回类型

List[Output]

async abatch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → AsyncIterator[Tuple[int, Union[Output, Exception]]]

在一系列输入上并行运行 ainvoke，并在结果完成时产生结果。

参数

• inputs (Sequence[Input]) – Runnable 的输入列表。

• config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) – 调用 Runnable 时要使用的配置。该配置支持标准键，如用于跟踪目的的“tags”、“metadata”，用于控制并行执行多少工作的“max_concurrency”以及其他键。有关更多详细信息，请参阅 RunnableConfig。默认为 None。默认为 None。

• return_exceptions (bool) – 是否返回异常而不是引发异常。默认为 False。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

Yields

输入索引和来自 Runnable 的输出的元组。

返回类型

AsyncIterator[Tuple[int, Union[Output, Exception]]]

async acall(inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, include_run_info: bool = False) → Dict[str, Any]

Deprecated since version langchain==0.1.0: 请使用 ainvoke 代替。

异步执行链。

参数

• inputs (Union[Dict[str, Any], Any]) – 输入字典，或者如果链只期望一个参数，则为单个输入。应包含 Chain.input_keys 中指定的所有输入，但链的内存将设置的输入除外。

• return_only_outputs (bool) – 是否仅在响应中返回输出。如果为 True，则仅返回由此链生成的新键。如果为 False，则返回输入键和由此链生成的新键。默认为 False。

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 用于此链运行的回调。这些回调将添加到在构建期间传递给链的回调之外调用，但只有这些运行时回调将传播到对其他对象的调用。

• tags (Optional[List[str]]) – 要传递给所有回调的字符串标签列表。这些标签将添加到在构建期间传递给链的标签之外传递，但只有这些运行时标签将传播到对其他对象的调用。

• metadata (Optional[Dict[str, Any]]) – 与链关联的可选元数据。默认为 None

• include_run_info (bool) – 是否在响应中包含运行信息。默认为 False。

• run_name (Optional[str]) –

返回值

命名输出的字典。应包含

Chain.output_keys 中指定的所有输出.

返回类型

Dict[str, Any]

async ainvoke(input: Dict[str, Any], config: Optional[RunnableConfig] = None, **kwargs: Any) → Dict[str, Any]

ainvoke 的默认实现，从线程中调用 invoke。

即使 Runnable 没有实现 invoke 的原生异步版本，默认实现也允许使用异步代码。

如果子类可以异步运行，则应重写此方法。

参数

• input (Dict[str, Any]) –

• config (Optional[RunnableConfig]) –

• kwargs (Any) –

返回类型

Dict[str, Any]

apply(input_list: List[Dict[str, Any]], callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None) → List[Dict, str]]

版本 langchain==0.1.0 中已弃用: 使用 batch 代替。

在列表中的所有输入上调用链。

参数

• input_list (List[Dict[str, Any]]) –

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) –

返回类型

List[Dict[str, str]]

async aprep_inputs(inputs: Union[Dict[str, Any], Any]) → Dict[str, str]

准备链输入，包括从内存中添加输入。

参数

inputs (Union[Dict[str, Any], Any]) – 原始输入的字典，或者如果链只期望一个参数，则为单个输入。应包含 Chain.input_keys 中指定的所有输入，但链的内存将设置的输入除外。

返回值

所有输入的字典，包括链的内存添加的输入。

返回类型

Dict[str, str]

async aprep_outputs(inputs: Dict[str, str], outputs: Dict[str, str], return_only_outputs: bool = False) → Dict[str, str]

验证和准备链输出，并将有关此运行的信息保存到内存中。

参数

• inputs (Dict[str, str]) – 链输入的字典，包括链内存添加的任何输入。

• outputs (Dict[str, str]) – 初始链输出的字典。

• return_only_outputs (bool) – 是否仅返回链输出。如果为 False，则输入也会添加到最终输出中。

返回值

最终链输出的字典。

返回类型

Dict[str, str]

async arun(*args: Any, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → Any

Deprecated since version langchain==0.1.0: 请使用 ainvoke 代替。

执行链的便捷方法。

此方法与 Chain.__call__ 之间的主要区别在于，此方法期望将输入直接作为位置参数或关键字参数传入，而 Chain.__call__ 期望单个输入字典包含所有输入

参数

• *args (Any) – 如果链期望单个输入，则可以将其作为唯一的位置参数传入。

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 用于此链运行的回调。这些回调将添加到在构建期间传递给链的回调之外调用，但只有这些运行时回调将传播到对其他对象的调用。

• tags (Optional[List[str]]) – 要传递给所有回调的字符串标签列表。这些标签将添加到在构建期间传递给链的标签之外传递，但只有这些运行时标签将传播到对其他对象的调用。

• **kwargs (Any) – 如果链期望多个输入，则可以将它们直接作为关键字参数传入。

• metadata (Optional[Dict[str, Any]]) –

• **kwargs –

返回值

链输出。

返回类型

Any

示例

# Suppose we have a single-input chain that takes a 'question' string:
await chain.arun("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."

# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
await chain.arun(question=question, context=context)
# -> "The temperature in Boise is..."

as_tool(args_schema: Optional[Type[BaseModel]] = None, *, name: Optional[str] = None, description: Optional[str] = None, arg_types: Optional[Dict[str, Type]] = None) → BaseTool

Beta

此 API 处于 Beta 阶段，将来可能会发生变化。

从 Runnable 创建 BaseTool。

as_tool 将从 Runnable 实例化具有名称、描述和 args_schema 的 BaseTool。在可能的情况下，模式从 runnable.get_input_schema 推断。或者（例如，如果 Runnable 接受 dict 作为输入，并且未键入特定的 dict 键），则可以使用 args_schema 直接指定模式。您还可以传递 arg_types 以仅指定必需的参数及其类型。

参数

• args_schema (Optional[Type[BaseModel]]) – 工具的模式。默认为 None。

• name (Optional[str]) – 工具的名称。默认为 None。

• description (Optional[str]) – 工具的描述。默认为 None。

• arg_types (Optional[Dict[str, Type]]) – 参数名称到类型的字典。默认为 None。

返回值

BaseTool 实例。

返回类型

BaseTool

类型化字典输入

from typing import List
from typing_extensions import TypedDict
from langchain_core.runnables import RunnableLambda

class Args(TypedDict):
    a: int
    b: List[int]

def f(x: Args) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool()
as_tool.invoke({"a": 3, "b": [1, 2]})

dict 输入，通过 args_schema 指定模式

from typing import Any, Dict, List
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

class FSchema(BaseModel):
    """Apply a function to an integer and list of integers."""

    a: int = Field(..., description="Integer")
    b: List[int] = Field(..., description="List of ints")

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(FSchema)
as_tool.invoke({"a": 3, "b": [1, 2]})

dict 输入，通过 arg_types 指定模式

from typing import Any, Dict, List
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(arg_types={"a": int, "b": List[int]})
as_tool.invoke({"a": 3, "b": [1, 2]})

字符串输入

from langchain_core.runnables import RunnableLambda

def f(x: str) -> str:
    return x + "a"

def g(x: str) -> str:
    return x + "z"

runnable = RunnableLambda(f) | g
as_tool = runnable.as_tool()
as_tool.invoke("b")

0.2.14 版本新增。

async astream(input: Input, config: Optional[RunnableConfig] = None, **kwargs: Optional[Any]) → AsyncIterator[Output]

astream 的默认实现，它调用 ainvoke。如果子类支持流式输出，则应重写此方法。

参数

• input (Input) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

Yields

Runnable 的输出。

返回类型

AsyncIterator[Output]

astream_events(input: Any, config: Optional[RunnableConfig] = None, *, version: Literal['v1', 'v2'], 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, **kwargs: Any) → AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]

Beta

此 API 处于 Beta 阶段，将来可能会发生变化。

生成事件流。

用于创建 StreamEvents 的迭代器，该迭代器提供有关 Runnable 进度的实时信息，包括来自中间结果的 StreamEvents。

StreamEvent 是一个具有以下模式的字典

• event: str - 事件名称的格式为：

  格式：on_[runnable_type]_(start|stream|end)。

• name: str - 生成事件的 Runnable 的名称。

• run_id: str - 与给定 Runnable 执行关联的随机生成的 ID，该 Runnable 发出事件。作为父 Runnable 执行一部分调用的子 Runnable 将被分配其自己的唯一 ID。

  Runnable 发出事件。作为父 Runnable 执行一部分调用的子 Runnable 将被分配其自己的唯一 ID。

• parent_ids: List[str] - 生成事件的父 runnables 的 ID。根 Runnable 将具有空列表。父 ID 的顺序是从根到直接父级。仅适用于 API 的 v2 版本。API 的 v1 版本将返回一个空列表。

  generated the event. The root Runnable will have an empty list. The order of the parent IDs is from the root to the immediate parent. Only available for v2 version of the API. The v1 version of the API will return an empty list.

• tags: Optional[List[str]] - 生成事件的 Runnable 的标签。

  the event.

• metadata: Optional[Dict[str, Any]] - Runnable 的元数据

  that generated the event.

• data: Dict[str, Any]

下面是一个表格，说明了各种链可能发出的一些事件。为了简洁起见，元数据字段已从表格中省略。链定义已包含在表格之后。

注意 此参考表适用于模式的 V2 版本。

event	name	chunk	input	output
on_chat_model_start	[模型名称]		{“messages”: [[SystemMessage, HumanMessage]]}
on_chat_model_stream	[模型名称]	AIMessageChunk(content=”hello”)
on_chat_model_end	[模型名称]		{“messages”: [[SystemMessage, HumanMessage]]}	AIMessageChunk(content=”hello world”)
on_llm_start	[模型名称]		{‘input’: ‘hello’}
on_llm_stream	[模型名称]	‘Hello’
on_llm_end	[模型名称]		‘Hello human!’
on_chain_start	format_docs
on_chain_stream	format_docs	“hello world!, goodbye world!”
on_chain_end	format_docs		[Document(…)]	“hello world!, goodbye world!”
on_tool_start	some_tool		{“x”: 1, “y”: “2”}
on_tool_end	some_tool			{“x”: 1, “y”: “2”}
on_retriever_start	[检索器名称]		{“query”: “hello”}
on_retriever_end	[检索器名称]		{“query”: “hello”}	[Document(…), ..]
on_prompt_start	[模板名称]		{“question”: “hello”}
on_prompt_end	[模板名称]		{“question”: “hello”}	ChatPromptValue(messages: [SystemMessage, …])

除了标准事件外，用户还可以调度自定义事件（请参阅下面的示例）。

自定义事件将仅在 API 的 v2 版本中显示！

自定义事件具有以下格式

属性	类型	描述
name	str	用户定义的事件名称。
data	Any	与事件关联的数据。这可以是任何内容，但我们建议使其 JSON 可序列化。

以下是与上面显示的标准事件关联的声明

format_docs:

def format_docs(docs: List[Document]) -> str:
    '''Format the docs.'''
    return ", ".join([doc.page_content for doc in docs])

format_docs = RunnableLambda(format_docs)

some_tool:

@tool
def some_tool(x: int, y: str) -> dict:
    '''Some_tool.'''
    return {"x": x, "y": y}

prompt:

template = ChatPromptTemplate.from_messages(
    [("system", "You are Cat Agent 007"), ("human", "{question}")]
).with_config({"run_name": "my_template", "tags": ["my_template"]})

示例

from langchain_core.runnables import RunnableLambda

async def reverse(s: str) -> str:
    return s[::-1]

chain = RunnableLambda(func=reverse)

events = [
    event async for event in chain.astream_events("hello", version="v2")
]

# will produce the following events (run_id, and parent_ids
# has been omitted for brevity):
[
    {
        "data": {"input": "hello"},
        "event": "on_chain_start",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
    {
        "data": {"chunk": "olleh"},
        "event": "on_chain_stream",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
    {
        "data": {"output": "olleh"},
        "event": "on_chain_end",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
]

示例：调度自定义事件

from langchain_core.callbacks.manager import (
    adispatch_custom_event,
)
from langchain_core.runnables import RunnableLambda, RunnableConfig
import asyncio


async def slow_thing(some_input: str, config: RunnableConfig) -> str:
    """Do something that takes a long time."""
    await asyncio.sleep(1) # Placeholder for some slow operation
    await adispatch_custom_event(
        "progress_event",
        {"message": "Finished step 1 of 3"},
        config=config # Must be included for python < 3.10
    )
    await asyncio.sleep(1) # Placeholder for some slow operation
    await adispatch_custom_event(
        "progress_event",
        {"message": "Finished step 2 of 3"},
        config=config # Must be included for python < 3.10
    )
    await asyncio.sleep(1) # Placeholder for some slow operation
    return "Done"

slow_thing = RunnableLambda(slow_thing)

async for event in slow_thing.astream_events("some_input", version="v2"):
    print(event)

参数

• input (Any) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 用于 Runnable 的配置。

• version (Literal['v1', 'v2']) – 要使用的模式版本，可以是 v2 或 v1。用户应使用 v2。v1 用于向后兼容，将在 0.4.0 中弃用。在 API 稳定之前，不会分配默认值。自定义事件将仅在 v2 中显示。

• include_names (Optional[Sequence[str]]) – 仅包括来自具有匹配名称的 runnables 的事件。

• include_types (Optional[Sequence[str]]) – 仅包括来自具有匹配类型的 runnables 的事件。

• include_tags (Optional[Sequence[str]]) – 仅包括来自具有匹配标签的 runnables 的事件。

• exclude_names (Optional[Sequence[str]]) – 排除来自具有匹配名称的 runnables 的事件。

• exclude_types (Optional[Sequence[str]]) – 排除来自具有匹配类型的 runnables 的事件。

• exclude_tags (Optional[Sequence[str]]) – 排除来自具有匹配标签的 runnables 的事件。

• kwargs (Any) – 要传递给 Runnable 的其他关键字参数。这些参数将传递给 astream_log，因为此 astream_events 的实现是构建在 astream_log 之上的。

Yields

StreamEvents 的异步流。

Raises

NotImplementedError – 如果版本不是 v1 或 v2。

返回类型

AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]

batch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]

默认实现使用线程池执行器并行运行 invoke。

batch 的默认实现非常适合 IO 绑定的 runnables。

如果子类可以更有效地进行批处理，则应覆盖此方法；例如，如果底层 Runnable 使用支持批处理模式的 API。

参数

• inputs (List[Input]) –

• config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) –

• return_exceptions (bool) –

• kwargs (Optional[Any]) –

返回类型

List[Output]

batch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → Iterator[Tuple[int, Union[Output, Exception]]]

并行在一系列输入上运行 invoke，并在结果完成时产生结果。

参数

• inputs (Sequence[Input]) –

• config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) –

• return_exceptions (bool) –

• kwargs (Optional[Any]) –

返回类型

Iterator[Tuple[int, Union[Output, Exception]]]

configurable_alternatives(which: ConfigurableField, *, default_key: str = 'default', prefix_keys: bool = False, **kwargs: Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) → RunnableSerializable[Input, Output]

为可在运行时设置的 Runnables 配置备选项。

参数

• which (ConfigurableField) – 将用于选择备选项的 ConfigurableField 实例。

• default_key (str) – 如果未选择备选项，则使用的默认键。默认为 “default”。

• prefix_keys (bool) – 是否用 ConfigurableField id 作为键的前缀。默认为 False。

• **kwargs (Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) – 键到 Runnable 实例或返回 Runnable 实例的可调用对象的字典。

返回值

配置了备选项的新 Runnable。

返回类型

RunnableSerializable[Input, Output]

from langchain_anthropic import ChatAnthropic
from langchain_core.runnables.utils import ConfigurableField
from langchain_openai import ChatOpenAI

model = ChatAnthropic(
    model_name="claude-3-sonnet-20240229"
).configurable_alternatives(
    ConfigurableField(id="llm"),
    default_key="anthropic",
    openai=ChatOpenAI()
)

# uses the default model ChatAnthropic
print(model.invoke("which organization created you?").content)

# uses ChatOpenAI
print(
    model.with_config(
        configurable={"llm": "openai"}
    ).invoke("which organization created you?").content
)

configurable_fields(**kwargs: Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) → RunnableSerializable[Input, Output]

在运行时配置特定的 Runnable 字段。

参数

**kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – 要配置的 ConfigurableField 实例的字典。

返回值

配置了字段的新 Runnable。

返回类型

RunnableSerializable[Input, Output]

from langchain_core.runnables import ConfigurableField
from langchain_openai import ChatOpenAI

model = ChatOpenAI(max_tokens=20).configurable_fields(
    max_tokens=ConfigurableField(
        id="output_token_number",
        name="Max tokens in the output",
        description="The maximum number of tokens in the output",
    )
)

# max_tokens = 20
print(
    "max_tokens_20: ",
    model.invoke("tell me something about chess").content
)

# max_tokens = 200
print("max_tokens_200: ", model.with_config(
    configurable={"output_token_number": 200}
    ).invoke("tell me something about chess").content
)

classmethod from_chain_type(llm: BaseLanguageModel, chain_type: str = 'stuff', chain_type_kwargs: Optional[dict] = None, **kwargs: Any) → BaseQAWithSourcesChain

从链类型加载链。

参数

• llm (BaseLanguageModel) –

• chain_type (str) –

• chain_type_kwargs (Optional[dict]) –

• kwargs (Any) –

返回类型

BaseQAWithSourcesChain

classmethod from_llm(llm: BaseLanguageModel, document_prompt: BasePromptTemplate = PromptTemplate(input_variables=['page_content', 'source'], template='Content: {page_content}\nSource: {source}'), question_prompt: BasePromptTemplate = PromptTemplate(input_variables=['context', 'question'], template='Use the following portion of a long document to see if any of the text is relevant to answer the question. \nReturn any relevant text verbatim.\n{context}\nQuestion: {question}\nRelevant text, if any:'), combine_prompt: BasePromptTemplate = PromptTemplate(input_variables=['question', 'summaries'], template='Given the following extracted parts of a long document and a question, create a final answer with references ("SOURCES"). \nIf you don\'t know the answer, just say that you don\'t know. Don\'t try to make up an answer.\nALWAYS return a "SOURCES" part in your answer.\n\nQUESTION: Which state/country\'s law governs the interpretation of the contract?\n=========\nContent: This Agreement is governed by English law and the parties submit to the exclusive jurisdiction of the English courts in  relation to any dispute (contractual or non-contractual) concerning this Agreement save that either party may apply to any court for an  injunction or other relief to protect its Intellectual Property Rights.\nSource: 28-pl\nContent: No Waiver. Failure or delay in exercising any right or remedy under this Agreement shall not constitute a waiver of such (or any other)  right or remedy.\n\n11.7 Severability. The invalidity, illegality or unenforceability of any term (or part of a term) of this Agreement shall not affect the continuation  in force of the remainder of the term (if any) and this Agreement.\n\n11.8 No Agency. Except as expressly stated otherwise, nothing in this Agreement shall create an agency, partnership or joint venture of any  kind between the parties.\n\n11.9 No Third-Party Beneficiaries.\nSource: 30-pl\nContent: (b) if Google believes, in good faith, that the Distributor has violated or caused Google to violate any Anti-Bribery Laws (as  defined in Clause 8.5) or that such a violation is reasonably likely to occur,\nSource: 4-pl\n=========\nFINAL ANSWER: This Agreement is governed by English law.\nSOURCES: 28-pl\n\nQUESTION: What did the president say about Michael Jackson?\n=========\nContent: Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \n\nLast year COVID-19 kept us apart. This year we are finally together again. \n\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n\nWith a duty to one another to the American people to the Constitution. \n\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \n\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n\nHe met the Ukrainian people. \n\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. \n\nGroups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland.\nSource: 0-pl\nContent: And we won’t stop. \n\nWe have lost so much to COVID-19. Time with one another. And worst of all, so much loss of life. \n\nLet’s use this moment to reset. Let’s stop looking at COVID-19 as a partisan dividing line and see it for what it is: A God-awful disease.  \n\nLet’s stop seeing each other as enemies, and start seeing each other for who we really are: Fellow Americans.  \n\nWe can’t change how divided we’ve been. But we can change how we move forward—on COVID-19 and other issues we must face together. \n\nI recently visited the New York City Police Department days after the funerals of Officer Wilbert Mora and his partner, Officer Jason Rivera. \n\nThey were responding to a 9-1-1 call when a man shot and killed them with a stolen gun. \n\nOfficer Mora was 27 years old. \n\nOfficer Rivera was 22. \n\nBoth Dominican Americans who’d grown up on the same streets they later chose to patrol as police officers. \n\nI spoke with their families and told them that we are forever in debt for their sacrifice, and we will carry on their mission to restore the trust and safety every community deserves.\nSource: 24-pl\nContent: And a proud Ukrainian people, who have known 30 years  of independence, have repeatedly shown that they will not tolerate anyone who tries to take their country backwards.  \n\nTo all Americans, I will be honest with you, as I’ve always promised. A Russian dictator, invading a foreign country, has costs around the world. \n\nAnd I’m taking robust action to make sure the pain of our sanctions  is targeted at Russia’s economy. And I will use every tool at our disposal to protect American businesses and consumers. \n\nTonight, I can announce that the United States has worked with 30 other countries to release 60 Million barrels of oil from reserves around the world.  \n\nAmerica will lead that effort, releasing 30 Million barrels from our own Strategic Petroleum Reserve. And we stand ready to do more if necessary, unified with our allies.  \n\nThese steps will help blunt gas prices here at home. And I know the news about what’s happening can seem alarming. \n\nBut I want you to know that we are going to be okay.\nSource: 5-pl\nContent: More support for patients and families. \n\nTo get there, I call on Congress to fund ARPA-H, the Advanced Research Projects Agency for Health. \n\nIt’s based on DARPA—the Defense Department project that led to the Internet, GPS, and so much more.  \n\nARPA-H will have a singular purpose—to drive breakthroughs in cancer, Alzheimer’s, diabetes, and more. \n\nA unity agenda for the nation. \n\nWe can do this. \n\nMy fellow Americans—tonight , we have gathered in a sacred space—the citadel of our democracy. \n\nIn this Capitol, generation after generation, Americans have debated great questions amid great strife, and have done great things. \n\nWe have fought for freedom, expanded liberty, defeated totalitarianism and terror. \n\nAnd built the strongest, freest, and most prosperous nation the world has ever known. \n\nNow is the hour. \n\nOur moment of responsibility. \n\nOur test of resolve and conscience, of history itself. \n\nIt is in this moment that our character is formed. Our purpose is found. Our future is forged. \n\nWell I know this nation.\nSource: 34-pl\n=========\nFINAL ANSWER: The president did not mention Michael Jackson.\nSOURCES:\n\nQUESTION: {question}\n=========\n{summaries}\n=========\nFINAL ANSWER:'), **kwargs: Any) → BaseQAWithSourcesChain

使用 LLM 构建链。

参数

• llm (BaseLanguageModel) –

• document_prompt (BasePromptTemplate) –

• question_prompt (BasePromptTemplate) –

• combine_prompt (BasePromptTemplate) –

• kwargs (Any) –

返回类型

BaseQAWithSourcesChain

invoke(input: Dict[str, Any], config: Optional[RunnableConfig] = None, **kwargs: Any) → Dict[str, Any]

将单个输入转换为输出。覆盖以实现。

参数

• input (Dict[str, Any]) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 调用 Runnable 时使用的配置。此配置支持标准键，例如用于追踪目的的 ‘tags’、‘metadata’，用于控制并行执行量的 ‘max_concurrency’，以及其他键。请参阅 RunnableConfig 以获取更多详细信息。

• kwargs (Any) –

返回值

Runnable 的输出。

返回类型

Dict[str, Any]

prep_inputs(inputs: Union[Dict, Any], Any]) → Dict[str, str]

准备链输入，包括从内存中添加输入。

参数

inputs (Union[Dict[str, Any], Any]) – 原始输入的字典，或者如果链只期望一个参数，则为单个输入。应包含 Chain.input_keys 中指定的所有输入，但链的内存将设置的输入除外。

返回值

所有输入的字典，包括链的内存添加的输入。

返回类型

Dict[str, str]

prep_outputs(inputs: Dict[str, str], outputs: Dict[str, str], return_only_outputs: bool = False) → Dict[str, str]

验证和准备链输出，并将有关此运行的信息保存到内存中。

参数

• inputs (Dict[str, str]) – 链输入的字典，包括链内存添加的任何输入。

• outputs (Dict[str, str]) – 初始链输出的字典。

• return_only_outputs (bool) – 是否仅返回链输出。如果为 False，则输入也会添加到最终输出中。

返回值

最终链输出的字典。

返回类型

Dict[str, str]

run(*args: Any, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → Any

Deprecated since version langchain==0.1.0: 请使用 invoke 代替。

执行链的便捷方法。

此方法与 Chain.__call__ 之间的主要区别在于，此方法期望将输入直接作为位置参数或关键字参数传入，而 Chain.__call__ 期望单个输入字典包含所有输入

参数

• *args (Any) – 如果链期望单个输入，则可以将其作为唯一的位置参数传入。

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 用于此链运行的回调。这些回调将添加到在构建期间传递给链的回调之外调用，但只有这些运行时回调将传播到对其他对象的调用。

• tags (Optional[List[str]]) – 要传递给所有回调的字符串标签列表。这些标签将添加到在构建期间传递给链的标签之外传递，但只有这些运行时标签将传播到对其他对象的调用。

• **kwargs (Any) – 如果链期望多个输入，则可以将它们直接作为关键字参数传入。

• metadata (Optional[Dict[str, Any]]) –

• **kwargs –

返回值

链输出。

返回类型

Any

示例

# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."

# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."

save(file_path: Union[Path, str]) → None

保存链。

期望实现 Chain._chain_type 属性，并且内存为空。

无。

参数

file_path (Union[Path, str]) – 保存链的文件路径。

返回类型

无

示例

chain.save(file_path="path/chain.yaml")

stream(input: Input, config: Optional[RunnableConfig] = None, **kwargs: Optional[Any]) → Iterator[Output]

stream 的默认实现，它调用 invoke。如果子类支持流式输出，则应覆盖此方法。

参数

• input (Input) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

Yields

Runnable 的输出。

返回类型

Iterator[Output]

to_json() → Union[SerializedConstructor, SerializedNotImplemented]

将 Runnable 序列化为 JSON。

返回值

Runnable 的 JSON 可序列化表示。

返回类型

Union[SerializedConstructor, SerializedNotImplemented]

RetrievalQAWithSourcesChain 的使用示例

• Jaguar 向量数据库

• Marqo

• Neo4j 向量索引

• Psychic

• Weaviate

• Yellowbrick