`langchain_community.retrievers.kendra`.AmazonKendraRetriever¶

注意

AmazonKendraRetriever 实现了标准的 Runnable Interface。 🏃

Runnable Interface 具有在可运行对象上可用的其他方法，例如 with_types、 with_retry、 assign、 bind、 get_graph 等。

class langchain_community.retrievers.kendra.AmazonKendraRetriever[源代码]¶

基类： BaseRetriever

Amazon Kendra Index 检索器。

参数

index_id – Kendra 索引 ID
region_name – AWS 区域，例如 us-west-2。回退到 AWS_DEFAULT_REGION 环境变量或 ~/.aws/config 中指定的区域。
credentials_profile_name – ~/.aws/credentials 或 ~/.aws/config 文件中的配置文件名称，其中指定了访问密钥或角色信息。如果未指定，将使用默认凭证配置文件；如果在 EC2 实例上，则将使用来自 IMDS 的凭证。
top_k – 返回的结果数量
attribute_filter – 基于元数据的其他结果过滤。请参阅： https://docs.aws.amazon.com/kendra/latest/APIReference
document_relevance_override_configurations – 覆盖在索引级别设置的字段/属性的相关性调整配置。请参阅： https://docs.aws.amazon.com/kendra/latest/APIReference
page_content_formatter – 生成文档的 page_content，允许访问所有结果项属性。默认情况下，它使用项的标题和摘录。
client – Kendra 的 boto3 客户端
user_context – 提供有关用户上下文的信息。请参阅： https://docs.aws.amazon.com/kendra/latest/APIReference

示例

retriever = AmazonKendraRetriever(
    index_id="c0806df7-e76b-4bce-9b5c-d5582f6b1a03"
)

param attribute_filter: Optional[Dict] = None¶

param client: Any = None¶

param credentials_profile_name: Optional[str] = None¶

param document_relevance_override_configurations: Optional[List[Dict]] = None¶

param index_id: str [必需]¶

param metadata: Optional[Dict[str, Any]] = None¶: 与检索器关联的可选元数据。默认为 None。此元数据将与每次对此检索器的调用关联，并作为参数传递给 callbacks 中处理程序定义。您可以使用这些来识别检索器的特定实例及其用例，例如。

param min_score_confidence: Optional[float] = None¶

约束

最小值 = 0.0
最大值 = 1.0

param page_content_formatter: Callable[[ResultItem], str] = <function combined_text>¶

param region_name: Optional[str] = None¶

param tags: Optional[List[str]] = None¶: 与检索器关联的可选标签列表。默认为 None。这些标签将与每次对此检索器的调用关联，并作为参数传递给 callbacks 中定义处理程序。您可以使用这些来识别检索器的特定实例及其用例，例如。

param top_k: int = 3¶

param user_context: Optional[Dict] = None¶

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 绑定的可运行对象。

如果子类可以更有效地进行批量处理，则应覆盖此方法；例如，如果底层的 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 的其他关键字参数。

产生

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

返回类型

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

async aget_relevant_documents(query: str, *, callbacks: Callbacks = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, **kwargs: Any) → List[Document]¶

Deprecated since version langchain-core==0.1.46: 使用 ainvoke 代替。

异步获取与查询相关的文档。

用户应倾向于使用 .ainvoke 或 .abatch 而不是直接使用 aget_relevant_documents。

参数

query (str) – 用于查找相关文档的字符串。
callbacks (Callbacks) – 回调管理器或回调列表。
tags (Optional[List[str]]) – 与检索器关联的可选标签列表。这些标签将与每次对此检索器的调用关联，并作为参数传递给 callbacks 中定义处理程序。默认为 None。
metadata (Optional[Dict[str, Any]]) – 与检索器关联的可选元数据。此元数据将与每次对此检索器的调用关联，并作为参数传递给 callbacks 中定义处理程序。默认为 None。
run_name (Optional[str]) – 运行的可选名称。默认为 None。
kwargs (Any) – 传递给检索器的其他参数。

返回

相关文档列表。

返回类型

List[Document]

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

异步调用检索器以获取相关文档。

异步检索器调用的主要入口点。

参数

input (str) – 查询字符串。
config (Optional[RunnableConfig]) – 检索器的配置。默认为 None。
kwargs (Any) – 传递给检索器的其他参数。

返回

相关文档列表。

返回类型

List[Document]

示例

await retriever.ainvoke("query")

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 将字典作为输入，并且未键入特定的字典键），可以使用 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 的其他关键字参数。

产生

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 - 事件名称的格式为：
format: on_[runnable_type]_(start|stream|end).
name: str - 生成事件的 Runnable 的名称。
run_id: str - 与给定 Runnable 执行关联的随机生成的 ID，该 Runnable 发出事件。作为父 Runnable 执行一部分被调用的子 Runnable 会被分配其自己唯一的 ID。
Runnable 执行，该 Runnable 发出事件。作为父 Runnable 执行一部分被调用的子 Runnable 会被分配其自己唯一的 ID。
parent_ids: List[str] - 生成事件的父 runnable 的 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, …])

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

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

自定义事件具有以下格式

属性	类型	描述
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]]) – 仅包括来自具有匹配名称的 runnable 的事件。
include_types (Optional[Sequence[str]]) – 仅包括来自具有匹配类型的 runnable 的事件。
include_tags (Optional[Sequence[str]]) – 仅包括来自具有匹配标签的 runnable 的事件。
exclude_names (Optional[Sequence[str]]) – 排除来自具有匹配名称的 runnable 的事件。
exclude_types (Optional[Sequence[str]]) – 排除来自具有匹配类型的 runnable 的事件。
exclude_tags (Optional[Sequence[str]]) – 排除来自具有匹配标签的 runnable 的事件。
kwargs (Any) – 传递给 Runnable 的其他关键字参数。这些参数将传递给 astream_log，因为 astream_events 的此实现构建于 astream_log 之上。

产生

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 绑定的可运行对象。

如果子类可以更有效地进行批量处理，则应覆盖此方法；例如，如果底层的 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
)

get_relevant_documents(query: str, *, callbacks: Callbacks = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, **kwargs: Any) → List[Document]¶

Deprecated since version langchain-core==0.1.46: 自 langchain-core==0.1.46 版本起已弃用: 请使用 invoke 代替。

检索与查询相关的文档。

用户应倾向于使用 .invoke 或 .batch 而不是直接使用 get_relevant_documents。

参数

query (str) – 用于查找相关文档的字符串。
callbacks (Callbacks) – 回调管理器或回调列表。默认为 None。
tags (Optional[List[str]]) – 与检索器关联的可选标签列表。这些标签将与每次对此检索器的调用关联，并作为参数传递给 callbacks 中定义处理程序。默认为 None。
metadata (Optional[Dict[str, Any]]) – 与检索器关联的可选元数据。此元数据将与每次对此检索器的调用关联，并作为参数传递给 callbacks 中定义处理程序。默认为 None。
run_name (Optional[str]) – 运行的可选名称。默认为 None。
kwargs (Any) – 传递给检索器的其他参数。

返回

相关文档列表。

返回类型

List[Document]

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

调用检索器以获取相关文档。

同步检索器调用的主要入口点。

参数

input (str) – 查询字符串。
config (Optional[RunnableConfig]) – 检索器的配置。默认为 None。
kwargs (Any) – 传递给检索器的其他参数。

返回

相关文档列表。

返回类型

List[Document]

示例

retriever.invoke("query")

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

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

参数

input (Input) – Runnable 的输入。
config (Optional[RunnableConfig]) – 要用于 Runnable 的配置。默认为 None。
kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

产生

Runnable 的输出。

返回类型

Iterator[Output]

to_json() → Union[SerializedConstructor, SerializedNotImplemented]¶

将 Runnable 序列化为 JSON。

返回: Runnable 的 JSON 可序列化表示形式。
返回类型: Union[SerializedConstructor, SerializedNotImplemented]

使用 AmazonKendraRetriever 的示例¶

Amazon Kendra

langchain_community.retrievers.kendra.AmazonKendraRetriever¶

使用 AmazonKendraRetriever 的示例¶

`langchain_community.retrievers.kendra`.AmazonKendraRetriever¶