langchain_core.language_models.base
.BaseLanguageModel¶
Note
BaseLanguageModel 实现了标准的 Runnable 接口
。 🏃
Runnable 接口
具有在 runnables 上可用的其他方法,例如 with_types
、 with_retry
、 assign
、 bind
、 get_graph
等。
- class langchain_core.language_models.base.BaseLanguageModel[source]¶
Bases:
RunnableSerializable
[Union
[PromptValue
,str
,Sequence
[Union
[BaseMessage
,List
[str
],Tuple
[str
,str
],str
,Dict
[str
,Any
]]]],LanguageModelOutputVar
],ABC
用于与语言模型交互的抽象基类。
所有语言模型包装器都继承自 BaseLanguageModel。
- param cache: Union[BaseCache, bool, None] = None¶
是否缓存响应。
如果为 true,将使用全局缓存。
如果为 false,将不使用缓存
如果为 None,如果已设置全局缓存,则使用全局缓存,否则不使用缓存。
如果是 BaseCache 的实例,将使用提供的缓存。
模型流式处理方法目前不支持缓存。
- param callbacks: Callbacks = None¶
要添加到运行轨迹的回调。
- param custom_get_token_ids: Optional[Callable[[str], List[int]]] = None¶
用于计算令牌的可选编码器。
- param metadata: Optional[Dict[str, Any]] = None¶
要添加到运行轨迹的元数据。
- param tags: Optional[List[str]] = None¶
要添加到运行轨迹的标签。
- param verbose: bool [Optional]¶
是否打印响应文本。
- async abatch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) List[Output] ¶
默认实现使用 asyncio.gather 并行运行 ainvoke。
批处理的默认实现适用于 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]]]
- abstract async agenerate_prompt(prompts: List[PromptValue], stop: Optional[List[str]] = None, callbacks: Callbacks = None, **kwargs: Any) LLMResult [source]¶
异步传递提示序列并返回模型生成结果。
此方法应利用模型的批量调用,这些模型公开了批量 API。
- 当您想要
利用批量调用,
需要从模型获得比仅仅是顶部生成值更多的输出,
- 正在构建对底层语言模型不可知的链
类型(例如,纯文本完成模型与聊天模型)。
- 参数
prompts (List[PromptValue]) – PromptValue 列表。 PromptValue 是一个可以转换为匹配任何语言模型格式的对象(纯文本生成模型的字符串和聊天模型的 BaseMessages)。
stop (Optional[List[str]]) – 生成时要使用的停止词。 模型输出在第一次出现任何这些子字符串时被截断。
callbacks (Callbacks) – 要传递的回调。 用于在整个生成过程中执行其他功能,例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。 这些通常传递给模型提供程序 API 调用。
- 返回
- 一个 LLMResult,其中包含每个输入
提示的候选 Generations 列表和其他特定于模型提供程序的输出。
- 返回类型
- async ainvoke(input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any) Output ¶
ainvoke 的默认实现,从线程调用 invoke。
即使 Runnable 没有实现 invoke 的本机异步版本,默认实现也允许使用异步代码。
如果子类可以异步运行,则应覆盖此方法。
- 参数
input (Input) –
config (Optional[RunnableConfig]) –
kwargs (Any) –
- 返回类型
Output
- abstract async apredict(text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any) str [source]¶
Deprecated since version langchain-core==0.1.7: 请改用
ainvoke
。异步传递字符串到模型并返回字符串。
- 在调用纯文本生成模型且仅需要顶部
候选生成时使用此方法。
- 参数
text (str) – 要传递给模型的字符串输入。
stop (Optional[Sequence[str]]) – 生成时要使用的停止词。 模型输出在第一次出现任何这些子字符串时被截断。
**kwargs (Any) – 任意附加关键字参数。 这些通常传递给模型提供程序 API 调用。
- 返回
作为字符串的顶部模型预测。
- 返回类型
str
- abstract async apredict_messages(messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None, **kwargs: Any) BaseMessage [source]¶
Deprecated since version langchain-core==0.1.7: 请改用
ainvoke
。异步传递消息到模型并返回消息。
- 在调用聊天模型且仅需要顶部
候选生成时使用此方法。
- 参数
messages (List[BaseMessage]) – 与单个模型输入对应的聊天消息序列。
stop (Optional[Sequence[str]]) – 生成时要使用的停止词。 模型输出在第一次出现任何这些子字符串时被截断。
**kwargs (Any) – 任意附加关键字参数。 这些通常传递给模型提供程序 API 调用。
- 返回
作为消息的顶部模型预测。
- 返回类型
- 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 实例。
- 返回类型
Typed dict input
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
input,通过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
input,通过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]})
String input
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,StreamEvents 提供关于 Runnable 进度的实时信息,包括来自中间结果的 StreamEvents。
StreamEvent 是一个具有以下模式的字典
event
: str - 事件名称的格式为:format: on_[runnable_type]_(start|stream|end)。
name
: str - 生成事件的 Runnable 的名称。run_id
: str - 随机生成的 ID,与 Runnable 的给定执行相关联,该 Runnable 发出了事件。作为父 Runnable 执行的一部分而被调用的子 Runnable 将被分配其自己唯一的 ID。
parent_ids
: List[str] - 生成事件的父 runnables 的 ID 列表。根 Runnable 将具有一个空列表。父 ID 的顺序是从根到直接父级。仅适用于 API 的 v2 版本。API 的 v1 版本将返回一个空列表。
tags
: Optional[List[str]] - 生成事件的 Runnable 的标签。事件的标签。
metadata
: Optional[Dict[str, Any]] - Runnable 的元数据,该 Runnable 生成了事件。
data
: Dict[str, Any]
下表说明了各种链可能发出的一些事件。为了简洁起见,元数据字段已从表中省略。链定义已包含在表格之后。
注意 此参考表适用于模式的 V2 版本。
事件
名称
块
输入
输出
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 版本中显示!
自定义事件具有以下格式
属性
类型
描述
名称
str
事件的用户定义名称。
数据
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}
提示:
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。
批处理的默认实现适用于 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 )
- abstract generate_prompt(prompts: List[PromptValue], stop: Optional[List[str]] = None, callbacks: Callbacks = None, **kwargs: Any) LLMResult [source]¶
将一系列提示传递给模型并返回模型生成结果。
此方法应利用模型的批量调用,这些模型公开了批量 API。
- 当您想要
利用批量调用,
需要从模型获得比仅仅是顶部生成值更多的输出,
- 正在构建对底层语言模型不可知的链
类型(例如,纯文本完成模型与聊天模型)。
- 参数
prompts (List[PromptValue]) – PromptValue 列表。 PromptValue 是一个可以转换为匹配任何语言模型格式的对象(纯文本生成模型的字符串和聊天模型的 BaseMessages)。
stop (Optional[List[str]]) – 生成时要使用的停止词。 模型输出在第一次出现任何这些子字符串时被截断。
callbacks (Callbacks) – 要传递的回调。 用于在整个生成过程中执行其他功能,例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。 这些通常传递给模型提供程序 API 调用。
- 返回
- 一个 LLMResult,其中包含每个输入
提示的候选 Generations 列表和其他特定于模型提供程序的输出。
- 返回类型
- get_num_tokens(text: str) int [source]¶
获取文本中存在的 tokens 数量。
用于检查输入是否适合模型的上下文窗口。
- 参数
text (str) – 要标记化的字符串输入。
- 返回
文本中 tokens 的整数数量。
- 返回类型
int
- get_num_tokens_from_messages(messages: List[BaseMessage]) int [source]¶
获取消息中的 tokens 数量。
用于检查输入是否适合模型的上下文窗口。
- 参数
messages (List[BaseMessage]) – 要标记化的消息输入。
- 返回
跨消息的 tokens 数量的总和。
- 返回类型
int
- get_token_ids(text: str) List[int] [source]¶
返回文本中 tokens 的有序 ID。
- 参数
text (str) – 要标记化的字符串输入。
- 返回
- 与文本中的 tokens 相对应的 ID 列表,按它们在文本中出现的顺序排列。
在文本中。
- 返回类型
List[int]
- abstract invoke(input: Input, config: Optional[RunnableConfig] = None) Output ¶
将单个输入转换为输出。覆盖以实现。
- 参数
input (Input) – Runnable 的输入。
config (Optional[RunnableConfig]) – 调用 Runnable 时要使用的配置。该配置支持标准键,如用于跟踪目的的“tags”、“metadata”,用于控制并行执行多少工作的“max_concurrency”以及其他键。请参阅 RunnableConfig 以了解更多详细信息。
- 返回
Runnable 的输出。
- 返回类型
Output
- abstract predict(text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any) str [source]¶
Deprecated since version langchain-core==0.1.7: 使用
invoke
代替。将单个字符串输入传递给模型并返回一个字符串。
- 当传入原始文本时使用此方法。如果要传入特定
类型的聊天消息,请使用 predict_messages。
- 参数
text (str) – 要传递给模型的字符串输入。
stop (Optional[Sequence[str]]) – 生成时要使用的停止词。 模型输出在第一次出现任何这些子字符串时被截断。
**kwargs (Any) – 任意附加关键字参数。 这些通常传递给模型提供程序 API 调用。
- 返回
作为字符串的顶部模型预测。
- 返回类型
str
- abstract predict_messages(messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None, **kwargs: Any) BaseMessage [source]¶
Deprecated since version langchain-core==0.1.7: 使用
invoke
代替。将消息序列传递给模型并返回一条消息。
- 当传入聊天消息时使用此方法。如果要传入原始文本,
请使用 predict。
- 参数
messages (List[BaseMessage]) – 与单个模型输入对应的聊天消息序列。
stop (Optional[Sequence[str]]) – 生成时要使用的停止词。 模型输出在第一次出现任何这些子字符串时被截断。
**kwargs (Any) – 任意附加关键字参数。 这些通常传递给模型提供程序 API 调用。
- 返回
作为消息的顶部模型预测。
- 返回类型
- 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 可序列化表示形式。
- 返回类型
- with_structured_output(schema: Union[Dict, Type[BaseModel]], **kwargs: Any) Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], Union[Dict, BaseModel]] [source]¶
此类中未实现。
- 参数
schema (Union[Dict, Type[BaseModel]]) –
kwargs (Any) –
- 返回类型
Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], Union[Dict, BaseModel]]