`langchain_core.language_models.fake_chat_models`.ParrotFakeChatModel¶

注意

ParrotFakeChatModel 实现了标准的 Runnable Interface。 🏃

该 Runnable Interface 还有一些在 runnable 上可用的额外方法，例如 with_types, with_retry, assign, bind, get_graph 等等。

class langchain_core.language_models.fake_chat_models.ParrotFakeChatModel[源代码]¶

基类： BaseChatModel

通用的虚假聊天模型，可以用来测试聊天模型接口。

聊天模型应该可以在同步和异步测试中使用

参数 cache: Union[BaseCache, bool, None] = None¶

是否缓存响应。

如果为 true，将使用全局缓存。
如果为 false，将不使用缓存
如果为 None，如果已设置全局缓存，则使用全局缓存，否则不使用缓存。
如果是 BaseCache 的实例，将使用提供的缓存。

当前不支持缓存用于模型的流式方法。

参数 callback_manager: Optional[BaseCallbackManager] = None¶: [已弃用] 添加到运行跟踪的回调管理器。

参数 callbacks: Callbacks = None¶: 添加到运行跟踪的回调。

参数 custom_get_token_ids: Optional[Callable[[str], List[int]]] = None¶: 用于计算令牌的可选编码器。

参数 metadata: Optional[Dict[str, Any]] = None¶: 添加到运行跟踪的元数据。

参数 rate_limiter: Optional[BaseRateLimiter] = None¶: 用于限制请求数量的可选速率限制器。

参数 tags: Optional[List[str]] = None¶: 添加到运行跟踪的标签。

参数 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 代替。

参数

messages (List[BaseMessage]) –
stop (Optional[List[str]]) –
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) –
kwargs (Any) –

返回类型

BaseMessage

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。

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

当您想要

利用批量调用，
需要比仅生成的顶级值更多的模型输出，
正在构建对底层语言模型不可知的链时，请使用此方法
类型（例如，纯文本完成模型与聊天模型）。

参数

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 –

返回值

一个 LLMResult，其中包含每个输入提示的候选生成列表以及其他模型提供商特定的输出。: prompt 和其他模型提供商特定的输出。

返回类型

LLMResult

async agenerate_prompt(prompts: List[PromptValue], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, **kwargs: Any) → LLMResult¶

异步传递一系列提示并返回模型生成结果。

此方法应利用模型的批量调用来公开批量 API。

当您想要

利用批量调用，
需要比仅生成的顶级值更多的模型输出，
正在构建对底层语言模型不可知的链时，请使用此方法
类型（例如，纯文本完成模型与聊天模型）。

参数

prompts (List[PromptValue]) – PromptValue 列表。 PromptValue 是一个可以被转换以匹配任何语言模型格式的对象（对于纯文本生成模型是字符串，对于聊天模型是 BaseMessages）。
stop (Optional[List[str]]) – 生成时要使用的停止词。模型输出在第一次出现任何这些子字符串时被截断。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能，例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。这些通常传递给模型提供商 API 调用。

返回值

一个 LLMResult，其中包含每个输入提示的候选生成列表以及其他模型提供商特定的输出。: prompt 和其他模型提供商特定的输出。

返回类型

LLMResult

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

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

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

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

参数

input (LanguageModelInput) –
config (Optional[RunnableConfig]) –
stop (Optional[List[str]]) –
kwargs (Any) –

返回类型

BaseMessage

async apredict(text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any) → str¶

Deprecated since version langchain-core==0.1.7: 自 langchain-core==0.1.7 版本起已弃用：请改用 ainvoke 。

参数

text (str) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –

返回类型

str

async apredict_messages(messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None, **kwargs: Any) → BaseMessage¶

Deprecated since version langchain-core==0.1.7: 自 langchain-core==0.1.7 版本起已弃用：请改用 ainvoke 。

参数

messages (List[BaseMessage]) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –

返回类型

BaseMessage

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

类型化的 dict 输入

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。如果子类支持流式输出，则应重写此方法。

参数

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

Yields

Runnable 的输出。

返回类型

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 - 随机生成的 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	[model name]		{“messages”: [[SystemMessage, HumanMessage]]}
on_chat_model_stream	[model name]	AIMessageChunk(content=”hello”)
on_chat_model_end	[model name]		{“messages”: [[SystemMessage, HumanMessage]]}	AIMessageChunk(content=”hello world”)
on_llm_start	[model name]		{‘input’: ‘hello’}
on_llm_stream	[model name]	‘Hello’
on_llm_end	[model name]		‘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	[retriever name]		{“query”: “hello”}
on_retriever_end	[retriever name]		{“query”: “hello”}	[Document(…), ..]
on_prompt_start	[template_name]		{“question”: “hello”}
on_prompt_end	[template_name]		{“question”: “hello”}	ChatPromptValue(messages: [SystemMessage, …])

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

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

自定义事件具有以下格式

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)

参数

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 绑定的 runnable。

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

bind_tools(tools: Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]], **kwargs: Any) → Runnable[LanguageModelInput, BaseMessage]¶

参数

tools (Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]]) – tools (工具) (Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]]) –
kwargs (Any) –

返回类型

Runnable[LanguageModelInput, BaseMessage] 可运行对象[LanguageModelInput, BaseMessage]

call_as_llm(message: str, stop: Optional[List[str]] = None, **kwargs: Any) → str¶

Deprecated since version langchain-core==0.1.7: 请使用 invoke 代替。

参数

message (str) – message (消息) (str) –
stop (Optional[List[str]]) –
kwargs (Any) –

返回类型

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]¶

Configure alternatives for Runnables that can be set at runtime. 配置可在运行时设置的 Runnable 的备选项。

参数

which (ConfigurableField) – The ConfigurableField instance that will be used to select the alternative. which (哪个) (ConfigurableField) – 将用于选择备选项的 ConfigurableField 实例。
default_key (str) – The default key to use if no alternative is selected. Defaults to “default”. default_key (默认键) (str) – 如果未选择任何备选项，则使用的默认键。默认为 “default”。
prefix_keys (bool) – Whether to prefix the keys with the ConfigurableField id. Defaults to False. prefix_keys (前缀键) (bool) – 是否用 ConfigurableField id 作为键的前缀。默认为 False。
**kwargs (Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) – A dictionary of keys to Runnable instances or callables that return Runnable instances. **kwargs (Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) – 键到 Runnable 实例或返回 Runnable 实例的可调用对象的字典。

返回值

A new Runnable with the alternatives configured. 配置了备选项的新 Runnable。

返回类型

RunnableSerializable[Input, Output] 可序列化的 Runnable[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]¶

Configure particular Runnable fields at runtime. 配置运行时特定的 Runnable 字段。

参数: **kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – A dictionary of ConfigurableField instances to configure. **kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – 要配置的 ConfigurableField 实例的字典。
返回值: A new Runnable with the fields configured. 配置了字段的新 Runnable。
返回类型: RunnableSerializable[Input, Output] 可序列化的 Runnable[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¶

Pass a sequence of prompts to the model and return model generations. 将一系列提示传递给模型并返回模型生成结果。

此方法应利用模型的批量调用来公开批量 API。

当您想要

利用批量调用，
需要比仅生成的顶级值更多的模型输出，
正在构建对底层语言模型不可知的链时，请使用此方法
类型（例如，纯文本完成模型与聊天模型）。

参数

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 –

返回值

一个 LLMResult，其中包含每个输入提示的候选生成列表以及其他模型提供商特定的输出。: prompt 和其他模型提供商特定的输出。

返回类型

LLMResult

generate_prompt(prompts: List[PromptValue], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, **kwargs: Any) → LLMResult¶

Pass a sequence of prompts to the model and return model generations. 将一系列提示传递给模型并返回模型生成结果。

此方法应利用模型的批量调用来公开批量 API。

当您想要

利用批量调用，
需要比仅生成的顶级值更多的模型输出，
正在构建对底层语言模型不可知的链时，请使用此方法
类型（例如，纯文本完成模型与聊天模型）。

参数

prompts (List[PromptValue]) – PromptValue 列表。 PromptValue 是一个可以被转换以匹配任何语言模型格式的对象（对于纯文本生成模型是字符串，对于聊天模型是 BaseMessages）。
stop (Optional[List[str]]) – 生成时要使用的停止词。模型输出在第一次出现任何这些子字符串时被截断。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能，例如日志记录或流式传输。
**kwargs (Any) – 任意附加关键字参数。这些通常传递给模型提供商 API 调用。

返回值

一个 LLMResult，其中包含每个输入提示的候选生成列表以及其他模型提供商特定的输出。: prompt 和其他模型提供商特定的输出。

返回类型

LLMResult

get_num_tokens(text: str) → int¶

Get the number of tokens present in the text. 获取文本中存在的 tokens 数量。

Useful for checking if an input fits in a model’s context window. 用于检查输入是否适合模型的上下文窗口。

参数: text (str) – The string input to tokenize. text (文本) (str) – 要标记化的字符串输入。
返回值: The integer number of tokens in the text. 文本中的整数 tokens 数量。
返回类型: int 整数

get_num_tokens_from_messages(messages: List[BaseMessage]) → int¶

Get the number of tokens in the messages. 获取消息中的 tokens 数量。

Useful for checking if an input fits in a model’s context window. 用于检查输入是否适合模型的上下文窗口。

参数: messages (List[BaseMessage]) – The message inputs to tokenize. messages (消息) (List[BaseMessage]) – 要标记化的消息输入。
返回值: The sum of the number of tokens across the messages. 所有消息的 tokens 数量总和。
返回类型: int 整数

get_token_ids(text: str) → List[int]¶

Return the ordered ids of the tokens in a text. 返回文本中 tokens 的有序 ID 列表。

参数

text (str) – The string input to tokenize. text (文本) (str) – 要标记化的字符串输入。

返回值

A list of ids corresponding to the tokens in the text, in order they occur 文本中 tokens 对应的 ID 列表，按它们在文本中出现的顺序排列: in the text. 在文本中。

返回类型

List[int] List[int]

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

Transform a single input into an output. Override to implement. 将单个输入转换为输出。重写以实现。

参数

input (LanguageModelInput) – Runnable 的输入。
config (Optional[RunnableConfig]) – A config to use when invoking the Runnable. The config supports standard keys like ‘tags’, ‘metadata’ for tracing purposes, ‘max_concurrency’ for controlling how much work to do in parallel, and other keys. Please refer to the RunnableConfig for more details. config (配置) (Optional[RunnableConfig]) – 调用 Runnable 时使用的配置。该配置支持标准键，例如用于跟踪目的的 ‘tags’、‘metadata’，用于控制并行执行多少工作的 ‘max_concurrency’，以及其他键。有关更多详细信息，请参阅 RunnableConfig。
stop (Optional[List[str]]) –
kwargs (Any) –

返回值

Runnable 的输出。

返回类型

BaseMessage

predict(text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any) → str¶

Deprecated since version langchain-core==0.1.7: 请使用 invoke 代替。

参数

text (str) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –

返回类型

str

predict_messages(messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None, **kwargs: Any) → BaseMessage¶

Deprecated since version langchain-core==0.1.7: 请使用 invoke 代替。

参数

messages (List[BaseMessage]) –
stop (Optional[Sequence[str]]) –
kwargs (Any) –

返回类型

BaseMessage

stream(input: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) → Iterator[BaseMessageChunk]¶

Default implementation of stream, which calls invoke. Subclasses should override this method if they support streaming output. stream 的默认实现，它调用 invoke。如果子类支持流式输出，则应重写此方法。

参数

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

Yields

Runnable 的输出。

返回类型

Iterator[BaseMessageChunk] 迭代器[BaseMessageChunk]

to_json() → Union[SerializedConstructor, SerializedNotImplemented]¶

Serialize the Runnable to JSON. 将 Runnable 序列化为 JSON。

返回值: A JSON-serializable representation of the Runnable. Runnable 的 JSON 可序列化表示形式。
返回类型: Union[SerializedConstructor, SerializedNotImplemented] Union[SerializedConstructor, SerializedNotImplemented]

with_structured_output(schema: Union[Dict, Type], *, include_raw: bool = False, **kwargs: Any) → Runnable[LanguageModelInput, Union[Dict, BaseModel]]¶

Model wrapper that returns outputs formatted to match the given schema. 模型包装器，返回根据给定模式格式化的输出。

参数

schema (Union[Dict, Type]) – schema (模式) (Union[Dict, Type]) –
The output schema. Can be passed in as 输出模式。可以作为以下形式传入：
- an OpenAI function/tool schema, OpenAI 函数/工具模式，
- a JSON Schema, JSON 模式，
- a TypedDict class (support added in 0.2.26), TypedDict 类 (0.2.26 版本中添加了支持)，
- or a Pydantic class. 或 Pydantic 类。
If schema is a Pydantic class then the model output will be a Pydantic instance of that class, and the model-generated fields will be validated by the Pydantic class. Otherwise the model output will be a dict and will not be validated. See langchain_core.utils.function_calling.convert_to_openai_tool() for more on how to properly specify types and descriptions of schema fields when specifying a Pydantic or TypedDict class. 如果 schema 是 Pydantic 类，则模型输出将是该类的 Pydantic 实例，并且模型生成的字段将由 Pydantic 类验证。否则，模型输出将是一个字典，并且不会被验证。有关在指定 Pydantic 或 TypedDict 类时如何正确指定模式字段的类型和描述的更多信息，请参阅 langchain_core.utils.function_calling.convert_to_openai_tool()。

Changed in version 0.2.26: Added support for TypedDict class. 在 0.2.26 版本中变更：添加了对 TypedDict 类的支持。
include_raw (bool) – If False then only the parsed structured output is returned. If an error occurs during model output parsing it will be raised. If True then both the raw model response (a BaseMessage) and the parsed model response will be returned. If an error occurs during output parsing it will be caught and returned as well. The final output is always a dict with keys “raw”, “parsed”, and “parsing_error”. include_raw (包含原始数据) (bool) – 如果为 False，则仅返回已解析的结构化输出。如果在模型输出解析期间发生错误，则会引发错误。如果为 True，则将返回原始模型响应 (BaseMessage) 和已解析的模型响应。如果在输出解析期间发生错误，也会捕获并返回错误。最终输出始终是一个字典，包含键 “raw”、“parsed” 和 “parsing_error”。
kwargs (Any) –

返回值

A Runnable that takes same inputs as a langchain_core.language_models.chat.BaseChatModel. 一个 Runnable，它接受与 langchain_core.language_models.chat.BaseChatModel 相同的输入。

If include_raw is False and schema is a Pydantic class, Runnable outputs an instance of schema (i.e., a Pydantic object). 如果 include_raw 为 False 且 schema 是 Pydantic 类，则 Runnable 输出 schema 的实例 (即 Pydantic 对象)。

Otherwise, if include_raw is False then Runnable outputs a dict. 否则，如果 include_raw 为 False，则 Runnable 输出一个字典。

If include_raw is True, then Runnable outputs a dict with keys 如果 include_raw 为 True，则 Runnable 输出一个字典，其中包含以下键

"raw": BaseMessage "raw": BaseMessage (原始数据)
"parsed": None if there was a parsing error, otherwise the type depends on the schema as described above. "parsed": 如果存在解析错误则为 None，否则类型取决于上面描述的 schema。 (已解析数据)
"parsing_error": Optional[BaseException] "parsing_error": Optional[BaseException] (解析错误)

返回类型

Runnable[LanguageModelInput, Union[Dict, BaseModel]] 可运行对象[LanguageModelInput, Union[Dict, BaseModel]]

Example: Pydantic schema (include_raw=False) 示例：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.'
# )

Example: Pydantic schema (include_raw=True) 示例：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
# }

Example: Dict schema (include_raw=False) 示例：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.'
# }

langchain_core.language_models.fake_chat_models.ParrotFakeChatModel¶

`langchain_core.language_models.fake_chat_models`.ParrotFakeChatModel¶