langchain_aws.chat_models.bedrock_converse
.ChatBedrockConverse¶
注意 (Note)
ChatBedrockConverse 实现了标准的 Runnable 接口
。 🏃
Runnable 接口
在可运行对象上还有其他可用方法,例如 with_types
, with_retry
, assign
, bind
, get_graph
等。
- class langchain_aws.chat_models.bedrock_converse.ChatBedrockConverse[source]¶
基类:
BaseChatModel
基于 Bedrock converse API 构建的 Bedrock 聊天模型集成。
一旦 Bedrock converse API 具有与旧版 Bedrock API 同等的功能,此实现最终将取代现有的 ChatBedrock 实现。 具体来说,converse API 尚不支持自定义 Bedrock 模型。
- 设置 (Setup)
要使用 Amazon Bedrock,请确保您已完成此处描述的所有步骤: https://docs.aws.amazon.com/bedrock/latest/userguide/setting-up.html
完成上述操作后,安装 LangChain 集成
pip install -U langchain-aws
- 主要初始化参数 — 完成参数 (Key init args — completion params)
- model: str
要使用的 BedrockConverse 模型名称。
- temperature: float
采样温度。
- max_tokens: Optional[int]
要生成的最大 token 数。
- 主要初始化参数 — 客户端参数 (Key init args — client params)
- region_name: Optional[str]
要使用的 AWS 区域,例如 ‘us-west-2’。
- base_url: Optional[str]
要使用的 Bedrock 端点。 如果您不想默认使用 us-east-1 端点,则需要此参数。
- credentials_profile_name: Optional[str]
~/.aws/credentials 或 ~/.aws/config 文件中配置文件的名称。
请参阅参数部分中受支持的初始化参数及其描述的完整列表。
- 实例化 (Instantiate)
from langchain_aws import ChatBedrockConverse llm = ChatBedrockConverse( model="anthropic.claude-3-sonnet-20240229-v1:0", temperature=0, max_tokens=None, # other params... )
- 调用 (Invoke)
messages = [ ("system", "You are a helpful translator. Translate the user sentence to French."), ("human", "I love programming."), ] llm.invoke(messages)
AIMessage(content=[{'type': 'text', 'text': "J'aime la programmation."}], response_metadata={'ResponseMetadata': {'RequestId': '9ef1e313-a4c1-4f79-b631-171f658d3c0e', 'HTTPStatusCode': 200, 'HTTPHeaders': {'date': 'Sat, 15 Jun 2024 01:19:24 GMT', 'content-type': 'application/json', 'content-length': '205', 'connection': 'keep-alive', 'x-amzn-requestid': '9ef1e313-a4c1-4f79-b631-171f658d3c0e'}, 'RetryAttempts': 0}, 'stopReason': 'end_turn', 'metrics': {'latencyMs': 609}}, id='run-754e152b-2b41-4784-9538-d40d71a5c3bc-0', usage_metadata={'input_tokens': 25, 'output_tokens': 11, 'total_tokens': 36})
- 流式处理 (Stream)
for chunk in llm.stream(messages): print(chunk)
AIMessageChunk(content=[], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'type': 'text', 'text': 'J', 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'text': "'", 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'text': 'a', 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'text': 'ime', 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'text': ' la', 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'text': ' programm', 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'text': 'ation', 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'text': '.', 'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[{'index': 0}], id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[], response_metadata={'stopReason': 'end_turn'}, id='run-da3c2606-4792-440a-ac66-72e0d1f6d117') AIMessageChunk(content=[], response_metadata={'metrics': {'latencyMs': 581}}, id='run-da3c2606-4792-440a-ac66-72e0d1f6d117', usage_metadata={'input_tokens': 25, 'output_tokens': 11, 'total_tokens': 36})
stream = llm.stream(messages) full = next(stream) for chunk in stream: full += chunk full
AIMessageChunk(content=[{'type': 'text', 'text': "J'aime la programmation.", 'index': 0}], response_metadata={'stopReason': 'end_turn', 'metrics': {'latencyMs': 554}}, id='run-56a5a5e0-de86-412b-9835-624652dc3539', usage_metadata={'input_tokens': 25, 'output_tokens': 11, 'total_tokens': 36})
- 工具调用 (Tool calling)
from langchain_core.pydantic_v1 import BaseModel, Field class GetWeather(BaseModel): '''Get the current weather in a given location''' location: str = Field(..., description="The city and state, e.g. San Francisco, CA") class GetPopulation(BaseModel): '''Get the current population in a given location''' location: str = Field(..., description="The city and state, e.g. San Francisco, CA") llm_with_tools = llm.bind_tools([GetWeather, GetPopulation]) ai_msg = llm_with_tools.invoke("Which city is hotter today and which is bigger: LA or NY?") ai_msg.tool_calls
[{'name': 'GetWeather', 'args': {'location': 'Los Angeles, CA'}, 'id': 'tooluse_Mspi2igUTQygp-xbX6XGVw'}, {'name': 'GetWeather', 'args': {'location': 'New York, NY'}, 'id': 'tooluse_tOPHiDhvR2m0xF5_5tyqWg'}, {'name': 'GetPopulation', 'args': {'location': 'Los Angeles, CA'}, 'id': 'tooluse__gcY_klbSC-GqB-bF_pxNg'}, {'name': 'GetPopulation', 'args': {'location': 'New York, NY'}, 'id': 'tooluse_-1HSoGX0TQCSaIg7cdFy8Q'}]
有关更多信息,请参阅
ChatBedrockConverse.bind_tools()
方法。- 结构化输出 (Structured output)
from typing import Optional from langchain_core.pydantic_v1 import BaseModel, Field class Joke(BaseModel): '''Joke to tell user.''' setup: str = Field(description="The setup of the joke") punchline: str = Field(description="The punchline to the joke") rating: Optional[int] = Field(description="How funny the joke is, from 1 to 10") structured_llm = llm.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats")
Joke(setup='What do you call a cat that gets all dressed up?', punchline='A purrfessional!', rating=7)
有关更多信息,请参阅
ChatBedrockConverse.with_structured_output()
。- 图像输入 (Image input)
import base64 import httpx from langchain_core.messages import HumanMessage image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" image_data = base64.b64encode(httpx.get(image_url).content).decode("utf-8") message = HumanMessage( content=[ {"type": "text", "text": "describe the weather in this image"}, { "type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": image_data}, }, ], ) ai_msg = llm.invoke([message]) ai_msg.content
[{'type': 'text', 'text': 'The image depicts a sunny day with a partly cloudy sky. The sky is a brilliant blue color with scattered white clouds drifting across. The lighting and cloud patterns suggest pleasant, mild weather conditions. The scene shows an open grassy field or meadow, indicating warm temperatures conducive for vegetation growth. Overall, the weather portrayed in this scenic outdoor image appears to be sunny with some clouds, likely representing a nice, comfortable day.'}]
- Token 使用量 (Token usage)
ai_msg = llm.invoke(messages) ai_msg.usage_metadata
{'input_tokens': 25, 'output_tokens': 11, 'total_tokens': 36}
- 响应元数据 (Response metadata)
ai_msg = llm.invoke(messages) ai_msg.response_metadata
{'ResponseMetadata': {'RequestId': '776a2a26-5946-45ae-859e-82dc5f12017c', 'HTTPStatusCode': 200, 'HTTPHeaders': {'date': 'Mon, 17 Jun 2024 01:37:05 GMT', 'content-type': 'application/json', 'content-length': '206', 'connection': 'keep-alive', 'x-amzn-requestid': '776a2a26-5946-45ae-859e-82dc5f12017c'}, 'RetryAttempts': 0}, 'stopReason': 'end_turn', 'metrics': {'latencyMs': 1290}}
- param additional_model_request_fields: Optional[Dict[str, Any]] = None¶
模型支持的其他推理参数。
Converse 在 inferenceConfig 字段中支持的基本推理参数集之外的参数。
- param additional_model_response_field_paths: Optional[List[str]] = None¶
要在响应中返回的其他模型参数字段路径。
Converse 将请求的字段作为 JSON 指针对象在 additionalModelResponseFields 字段中返回。 以下是 additionalModelResponseFieldPaths 的示例 JSON。
- param cache: Union[BaseCache, bool, None] = None¶
是否缓存响应。
如果为 true,将使用全局缓存。
如果为 false,将不使用缓存
如果为 None,如果已设置全局缓存,则将使用全局缓存,否则不使用缓存。
如果是 BaseCache 的实例,将使用提供的缓存。
当前模型的流式处理方法不支持缓存。
- param callback_manager: Optional[BaseCallbackManager] = None¶
[已弃用] 要添加到运行跟踪的回调管理器。
- param callbacks: Callbacks = None¶
要添加到运行跟踪的回调。
- param config: Any = None¶
可选的 botocore.config.Config 实例,用于传递给客户端。
- param credentials_profile_name: Optional[str] = None¶
~/.aws/credentials 或 ~/.aws/config 文件中配置文件的名称。
配置文件应指定访问密钥或角色信息。 如果未指定,将使用默认凭证配置文件,或者,如果在 EC2 实例上,则将使用来自 IMDS 的凭证。 请参阅: https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
- param custom_get_token_ids: Optional[Callable[[str], List[int]]] = None¶
用于计算 token 的可选编码器。
- param endpoint_url: Optional[str] = None (别名 'base_url')¶
如果您不想默认使用 us-east-1 端点,则需要此参数
- param guardrail_config: Optional[Dict[str, Any]] = None (别名 'guardrails')¶
您想在请求中使用的防护栏的配置信息。
- param max_tokens: Optional[int] = None¶
要生成的最多的 token 数。
- param metadata: Optional[Dict[str, Any]] = None¶
要添加到运行跟踪的元数据。
- param model_id: str [必需] (别名 'model')¶
要调用的模型的 ID。
例如,
"anthropic.claude-3-sonnet-20240229-v1:0"
。 这等效于 list-foundation-models API 中的 modelID 属性。 对于自定义模型和预置模型,需要 ARN 值。 有关所有受支持的内置模型的列表,请参阅 https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html#model-ids-arns。
- param provider: str = ''¶
模型提供商,例如 amazon、cohere、ai21 等。
如果未提供,则从 model_id 的第一部分提取提供商,例如 ‘amazon.titan-text-express-v1’ 中的 ‘amazon’。 对于模型 ID 中没有提供商的模型 ID(如与 ARN 关联的自定义模型和预置模型),应提供此值。
- param rate_limiter: Optional[BaseRateLimiter] = None¶
可选的速率限制器,用于限制请求数量。
- param region_name: Optional[str] = None¶
AWS 区域,例如 us-west-2。
如果此处未提供,则回退到 AWS_DEFAULT_REGION 环境变量或 ~/.aws/config 中指定的区域。
- param stop_sequences: Optional[List[str]] = None (别名 'stop')¶
如果出现任何这些子字符串,则停止生成。
- param tags: Optional[List[str]] = None¶
要添加到运行跟踪的标签。
- param temperature: Optional[float] = None¶
采样温度。 必须为 0 到 1。
- param top_p: Optional[float] = None¶
用于下一个 token 的最有可能候选者的百分比。
必须为 0 到 1。
例如,如果您为 topP 选择值 0.8,则模型将从序列中下一个可能出现的 token 的概率分布的前 80% 中进行选择。
- param verbose: bool [可选]¶
是否打印响应文本。
- __call__(messages: List[BaseMessage], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, **kwargs: Any) BaseMessage ¶
Deprecated since version langchain-core==0.1.7: 请改用
invoke
。- 参数 (Parameters)
messages (List[BaseMessage]) –
stop (Optional[List[str]]) –
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) –
kwargs (Any) –
- 返回类型 (Return type)
- 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。
- 参数 (Parameters)
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 的其他关键字参数。
- 返回 (Returns)
来自 Runnable 的输出列表。
- 返回类型 (Return type)
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 于输入列表,并在完成时生成结果。
- 参数 (Parameters)
inputs (Sequence[Input]) – Runnable 的输入列表。
config (可选[Union[RunnableConfig, Sequence[RunnableConfig]]]) – 调用 Runnable 时使用的配置。该配置支持标准键,例如用于追踪目的的 ‘tags’、‘metadata’,用于控制并行处理量的 ‘max_concurrency’,以及其他键。请参阅 RunnableConfig 以获取更多详细信息。默认为 None。默认为 None。
return_exceptions (bool) – 是否返回异常而不是引发异常。 默认为 False。
kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。
- Yields
输入索引和来自 Runnable 的输出的元组。
- 返回类型 (Return type)
AsyncIterator[Tuple[int, Union[Output, Exception]]]
- async agenerate(messages: List[List[BaseMessage]], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional:[List[str]] = None, metadata: Optional:[Dict[str, Any]] = None, run_name: Optional:[str] = None, run_id: Optional:[UUID] = None, **kwargs: Any) LLMResult ¶
异步地将一系列提示传递给模型并返回生成结果。
此方法应利用批量调用,以便用于公开批量 API 的模型。
- 当您想要
利用批量调用,
需要从模型获得比仅仅是最佳生成值更多的输出,
- 正在构建与底层语言模型无关的链时,请使用此方法
类型(例如,纯文本补全模型与聊天模型)。
- 参数 (Parameters)
messages (List[List[BaseMessage]]) – 消息列表的列表。
stop (Optional[List[str]]) – 生成时使用的停止词。模型输出在首次出现任何这些子字符串时被截断。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能,例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。这些通常传递给模型提供商 API 调用。
tags (Optional[List[str]]) –
metadata (Optional[Dict[str, Any]]) –
run_name (Optional[str]) –
run_id (Optional[UUID]) –
**kwargs –
- 返回 (Returns)
- 一个 LLMResult,其中包含每个输入的候选 Generation 列表
提示和附加的模型提供商特定的输出。
- 返回类型 (Return type)
- async agenerate_prompt(prompts: List[PromptValue], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, **kwargs: Any) LLMResult ¶
异步地传递一系列提示并返回模型生成结果。
此方法应利用批量调用,以便用于公开批量 API 的模型。
- 当您想要
利用批量调用,
需要从模型获得比仅仅是最佳生成值更多的输出,
- 正在构建与底层语言模型无关的链时,请使用此方法
类型(例如,纯文本补全模型与聊天模型)。
- 参数 (Parameters)
prompts (List[PromptValue]) – PromptValue 列表。PromptValue 是一个可以转换为匹配任何语言模型格式的对象(纯文本生成模型的字符串和聊天模型的 BaseMessages)。
stop (Optional[List[str]]) – 生成时使用的停止词。模型输出在首次出现任何这些子字符串时被截断。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能,例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。这些通常传递给模型提供商 API 调用。
- 返回 (Returns)
- 一个 LLMResult,其中包含每个输入的候选 Generation 列表
提示和附加的模型提供商特定的输出。
- 返回类型 (Return type)
- async ainvoke(input: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) BaseMessage ¶
ainvoke 的默认实现,从线程调用 invoke。
即使 Runnable 没有实现 invoke 的原生异步版本,默认实现也允许使用异步代码。
如果子类可以异步运行,则应覆盖此方法。
- 参数 (Parameters)
input (LanguageModelInput) –
config (Optional[RunnableConfig]) –
stop (Optional[List[str]]) –
kwargs (Any) –
- 返回类型 (Return type)
- async apredict(text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any) str ¶
Deprecated since version langchain-core==0.1.7: 请使用
ainvoke
代替。- 参数 (Parameters)
text (str) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –
- 返回类型 (Return type)
str
- async apredict_messages(messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None, **kwargs: Any) BaseMessage ¶
Deprecated since version langchain-core==0.1.7: 请使用
ainvoke
代替。- 参数 (Parameters)
messages (List[BaseMessage]) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –
- 返回类型 (Return type)
- 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
以仅指定必需的参数及其类型。- 参数 (Parameters)
args_schema (Optional[Type[BaseModel]]) – 工具的模式。默认为 None。
name (Optional[str]) – 工具的名称。默认为 None。
description (Optional[str]) – 工具的描述。默认为 None。
arg_types (Optional[Dict[str, Type]]) – 参数名称到类型的字典。默认为 None。
- 返回 (Returns)
一个 BaseTool 实例。
- 返回类型 (Return type)
类型化字典输入
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: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) AsyncIterator[BaseMessageChunk] ¶
astream 的默认实现,它调用 ainvoke。如果子类支持流式输出,则应覆盖此方法。
- 参数 (Parameters)
input (LanguageModelInput) – Runnable 的输入。
config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。
kwargs (Any) – 要传递给 Runnable 的其他关键字参数。
stop (Optional[List[str]]) –
- Yields
Runnable 的输出。
- 返回类型 (Return type)
AsyncIterator[BaseMessageChunk]
- 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。the Runnable that emitted the event. A child Runnable that gets invoked as part of the execution of a parent Runnable is assigned its own unique 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, …])
除了标准事件之外,用户还可以调度自定义事件(请参阅下面的示例)。
自定义事件将仅在使用 v2 版本的 API 中显示!
自定义事件具有以下格式
Attribute
Type
Description
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"]})
Example
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)
- 参数 (Parameters)
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。
- 返回类型 (Return type)
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。
- 参数 (Parameters)
inputs (List[Input]) –
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) –
return_exceptions (bool) –
kwargs (Optional[Any]) –
- 返回类型 (Return type)
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,并在完成时产生结果。
- 参数 (Parameters)
inputs (Sequence[Input]) –
config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) –
return_exceptions (bool) –
kwargs (Optional[Any]) –
- 返回类型 (Return type)
Iterator[Tuple[int, Union[Output, Exception]]]
- bind_tools(tools: Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]], *, tool_choice: Optional[Union[dict, str, Literal['auto', 'any']]] = None, **kwargs: Any) Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]], BaseMessage] [source]¶
- 参数 (Parameters)
tools (Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]]) –
tool_choice (Optional[Union[dict, str, Literal['auto', 'any']]]) –
kwargs (Any) –
- 返回类型 (Return type)
Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], BaseMessage]
- call_as_llm(message: str, stop: Optional[List[str]] = None, **kwargs: Any) str ¶
Deprecated since version langchain-core==0.1.7: 请改用
invoke
。- 参数 (Parameters)
message (str) –
stop (Optional[List[str]]) –
kwargs (Any) –
- 返回类型 (Return type)
str
- 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 的备选项。
- 参数 (Parameters)
which (ConfigurableField) – 将用于选择备选项的 ConfigurableField 实例。
default_key (str) – 如果未选择备选项,则使用的默认键。默认为“default”。
prefix_keys (bool) – 是否为键添加 ConfigurableField id 前缀。默认为 False。
**kwargs (Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) – 键到 Runnable 实例或返回 Runnable 实例的可调用对象的字典。
- 返回 (Returns)
配置了备选项的新 Runnable。
- 返回类型 (Return type)
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 字段。
- 参数 (Parameters)
**kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – 要配置的 ConfigurableField 实例的字典。
- 返回 (Returns)
配置了字段的新 Runnable。
- 返回类型 (Return type)
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 )
- generate(messages: List[List[BaseMessage]], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, run_id: Optional[UUID] = None, **kwargs: Any) LLMResult ¶
将一系列提示传递给模型并返回模型生成结果。
此方法应利用批量调用,以便用于公开批量 API 的模型。
- 当您想要
利用批量调用,
需要从模型获得比仅仅是最佳生成值更多的输出,
- 正在构建与底层语言模型无关的链时,请使用此方法
类型(例如,纯文本补全模型与聊天模型)。
- 参数 (Parameters)
messages (List[List[BaseMessage]]) – 消息列表的列表。
stop (Optional[List[str]]) – 生成时使用的停止词。模型输出在首次出现任何这些子字符串时被截断。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能,例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。这些通常传递给模型提供商 API 调用。
tags (Optional[List[str]]) –
metadata (Optional[Dict[str, Any]]) –
run_name (Optional[str]) –
run_id (Optional[UUID]) –
**kwargs –
- 返回 (Returns)
- 一个 LLMResult,其中包含每个输入的候选 Generation 列表
提示和附加的模型提供商特定的输出。
- 返回类型 (Return type)
- generate_prompt(prompts: List[PromptValue], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, **kwargs: Any) LLMResult ¶
将一系列提示传递给模型并返回模型生成结果。
此方法应利用批量调用,以便用于公开批量 API 的模型。
- 当您想要
利用批量调用,
需要从模型获得比仅仅是最佳生成值更多的输出,
- 正在构建与底层语言模型无关的链时,请使用此方法
类型(例如,纯文本补全模型与聊天模型)。
- 参数 (Parameters)
prompts (List[PromptValue]) – PromptValue 列表。PromptValue 是一个可以转换为匹配任何语言模型格式的对象(纯文本生成模型的字符串和聊天模型的 BaseMessages)。
stop (Optional[List[str]]) – 生成时使用的停止词。模型输出在首次出现任何这些子字符串时被截断。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能,例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。这些通常传递给模型提供商 API 调用。
- 返回 (Returns)
- 一个 LLMResult,其中包含每个输入的候选 Generation 列表
提示和附加的模型提供商特定的输出。
- 返回类型 (Return type)
- get_num_tokens(text: str) int ¶
获取文本中存在的 token 数量。
用于检查输入是否适合模型的上下文窗口。
- 参数 (Parameters)
text (str) – 要标记化的字符串输入。
- 返回 (Returns)
文本中 token 的整数数量。
- 返回类型 (Return type)
int
- get_num_tokens_from_messages(messages: List[BaseMessage]) int ¶
获取消息中的 token 数量。
用于检查输入是否适合模型的上下文窗口。
- 参数 (Parameters)
messages (List[BaseMessage]) – 要标记化的消息输入。
- 返回 (Returns)
消息中 token 数量的总和。
- 返回类型 (Return type)
int
- get_token_ids(text: str) List[int] ¶
返回文本中 token 的有序 ID。
- 参数 (Parameters)
text (str) – 要标记化的字符串输入。
- 返回 (Returns)
- 与文本中的 token 相对应的 ID 列表,按它们在文本中出现的顺序排列。
在文本中。
- 返回类型 (Return type)
List[int]
- invoke(input: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) BaseMessage ¶
将单个输入转换为输出。重写以实现。
- 参数 (Parameters)
input (LanguageModelInput) – Runnable 的输入。
config (Optional[RunnableConfig]) – 调用 Runnable 时使用的配置。该配置支持标准键,如用于跟踪目的的“tags”、“metadata”,用于控制并行执行量的“max_concurrency”以及其他键。有关更多详细信息,请参阅 RunnableConfig。
stop (Optional[List[str]]) –
kwargs (Any) –
- 返回 (Returns)
Runnable 的输出。
- 返回类型 (Return type)
- predict(text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any) str ¶
Deprecated since version langchain-core==0.1.7: 请改用
invoke
。- 参数 (Parameters)
text (str) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –
- 返回类型 (Return type)
str
- predict_messages(messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None, **kwargs: Any) BaseMessage ¶
Deprecated since version langchain-core==0.1.7: 请改用
invoke
。- 参数 (Parameters)
messages (List[BaseMessage]) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –
- 返回类型 (Return type)
- stream(input: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) Iterator[BaseMessageChunk] ¶
stream
的默认实现,它会调用invoke
。如果子类支持流式输出,则应重写此方法。- 参数 (Parameters)
input (LanguageModelInput) – Runnable 的输入。
config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。
kwargs (Any) – 要传递给 Runnable 的其他关键字参数。
stop (Optional[List[str]]) –
- Yields
Runnable 的输出。
- 返回类型 (Return type)
Iterator[BaseMessageChunk]
- to_json() Union[SerializedConstructor, SerializedNotImplemented] ¶
将 Runnable 序列化为 JSON 格式。
- 返回 (Returns)
Runnable 的 JSON 可序列化表示形式。
- 返回类型 (Return type)
- with_structured_output(schema: Union[Dict, Type[BaseModel]], *, include_raw: bool = False, **kwargs: Any) Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], Union[Dict, BaseModel]] [source]¶
模型包装器,用于返回根据给定模式格式化的输出。
- 参数 (Parameters)
schema (Union[Dict, Type[BaseModel]]) –
- 输出模式。可以作为以下形式传入
OpenAI 函数/工具模式,
JSON 模式,
TypedDict 类 (在 0.2.26 版本中添加了支持),
或 Pydantic 类。
如果
schema
是一个 Pydantic 类,则模型输出将是该类的 Pydantic 实例,并且模型生成的字段将由 Pydantic 类进行验证。否则,模型输出将是一个 dict 且不会被验证。有关如何在指定 Pydantic 或 TypedDict 类时正确指定模式字段的类型和描述的更多信息,请参阅langchain_core.utils.function_calling.convert_to_openai_tool()
。在 0.2.26 版本中变更: 添加了对 TypedDict 类的支持。
include_raw (bool) – 如果为 False,则仅返回解析后的结构化输出。如果在模型输出解析期间发生错误,将引发该错误。如果为 True,则将返回原始模型响应 (BaseMessage) 和解析后的模型响应。如果在输出解析期间发生错误,也会捕获该错误并返回。最终输出始终是一个包含 “raw”、“parsed” 和 “parsing_error” 键的 dict。
kwargs (Any) –
- 返回 (Returns)
一个 Runnable,它接受与
langchain_core.language_models.chat.BaseChatModel
相同的输入。如果
include_raw
为 False 且schema
是一个 Pydantic 类,则 Runnable 输出schema
的一个实例 (即,一个 Pydantic 对象)。否则,如果
include_raw
为 False,则 Runnable 输出一个 dict。- 如果
include_raw
为 True,则 Runnable 输出一个包含以下键的 dict "raw"
: BaseMessage"parsed"
: 如果存在解析错误则为 None,否则类型取决于上面描述的schema
。"parsing_error"
: Optional[BaseException]
- 如果
- 返回类型 (Return type)
Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], Union[Dict, BaseModel]]
- 示例:Pydantic 模式 (include_raw=False)
from langchain_core.pydantic_v1 import BaseModel class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str llm = ChatModel(model="model-name", temperature=0) structured_llm = llm.with_structured_output(AnswerWithJustification) structured_llm.invoke("What weighs more a pound of bricks or a pound of feathers") # -> AnswerWithJustification( # answer='They weigh the same', # justification='Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.' # )
- 示例:Pydantic 模式 (include_raw=True)
from langchain_core.pydantic_v1 import BaseModel class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str llm = ChatModel(model="model-name", temperature=0) structured_llm = llm.with_structured_output(AnswerWithJustification, include_raw=True) structured_llm.invoke("What weighs more a pound of bricks or a pound of feathers") # -> { # 'raw': AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_Ao02pnFYXD6GN1yzc0uXPsvF', 'function': {'arguments': '{"answer":"They weigh the same.","justification":"Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ."}', 'name': 'AnswerWithJustification'}, 'type': 'function'}]}), # 'parsed': AnswerWithJustification(answer='They weigh the same.', justification='Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.'), # 'parsing_error': None # }
- 示例:Dict 模式 (include_raw=False)
from langchain_core.pydantic_v1 import BaseModel from langchain_core.utils.function_calling import convert_to_openai_tool class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str dict_schema = convert_to_openai_tool(AnswerWithJustification) llm = ChatModel(model="model-name", temperature=0) structured_llm = llm.with_structured_output(dict_schema) structured_llm.invoke("What weighs more a pound of bricks or a pound of feathers") # -> { # 'answer': 'They weigh the same', # 'justification': 'Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume and density of the two substances differ.' # }