`langchain_community.llms.octoai_endpoint`.OctoAIEndpoint¶

注意

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

Runnable 接口 具有 runnable 上可用的附加方法，例如 with_types、 with_retry、 assign、 bind、 get_graph 等。

class langchain_community.llms.octoai_endpoint.OctoAIEndpoint[source]¶

基类: BaseOpenAI

OctoAI LLM 端点 - 兼容 OpenAI。

OctoAIEndpoint 是一个用于与 OctoAI 计算服务大型语言模型端点交互的类。

要使用，您应该设置环境变量 OCTOAI_API_TOKEN 为您的 API 令牌，或者将其作为命名参数传递给构造函数。

示例

from langchain_community.llms.octoai_endpoint  import OctoAIEndpoint

llm = OctoAIEndpoint(
    model="llama-2-13b-chat-fp16",
    max_tokens=200,
    presence_penalty=0,
    temperature=0.1,
    top_p=0.9,
)

初始化 OpenAI 对象。

param allowed_special: Union[Literal['all'], AbstractSet[str]]] = {}¶: 允许的特殊 token 集合。

param batch_size: int = 20¶: 当传递多个文档以生成时使用的批次大小。

param best_of: int = 1¶: 在服务器端生成 best_of 完成项并返回“最佳”结果。

param cache: Union[BaseCache, bool, None] = None¶

是否缓存响应。

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

模型流式传输方法目前不支持缓存。

param callback_manager: Optional[BaseCallbackManager] = None¶: [已弃用]

param callbacks: Callbacks = None¶: 添加到运行轨迹的回调。

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

param default_headers: Union[Mapping[str, str], None] = None¶

param default_query: Union[Mapping[str, object], None] = None¶

param disallowed_special: Union[Literal['all'], Collection[str]] = 'all'¶: 不允许的特殊 token 集合。

param frequency_penalty: float = 0¶: 根据频率惩罚重复的 token。

param http_client: Union[Any, None] = None¶: 可选的 httpx.Client。

param logit_bias: Optional[Dict[str, float]] [可选]¶: 调整生成特定 token 的概率。

param max_retries: int = 2¶: 生成时尝试的最大重试次数。

param max_tokens: int = 256¶: 完成时生成的最大 token 数。 -1 返回尽可能多的 token，由提示和模型的最大上下文大小决定。

param metadata: Optional[Dict[str, Any]] = None¶: 添加到运行轨迹的元数据。

param model_kwargs: Dict[str, Any] [可选]¶: 保存 create 调用有效的任何模型参数，这些参数未明确指定。

param model_name: str = 'codellama-7b-instruct'¶: 要使用的模型名称。

param n: int = 1¶: 每个提示要生成多少个完成项。

param octoai_api_base: str = 'https://text.octoai.run/v1/'¶

param octoai_api_token: SecretStr = None¶

约束

type = string
writeOnly = True
format = password

param openai_api_base: Optional[str] = None (别名 'base_url')¶: API 请求的基本 URL 路径，如果不使用代理或服务模拟器，请留空。

param openai_api_key: Optional[str] = None (别名 'api_key')¶: 如果未提供，则从环境变量 OPENAI_API_KEY 自动推断。

param openai_organization: Optional[str] = None (别名 'organization')¶: 如果未提供，则从环境变量 OPENAI_ORG_ID 自动推断。

param openai_proxy: Optional[str] = None¶

param presence_penalty: float = 0¶: 惩罚重复的 token。

param request_timeout: Union[float, Tuple[float, float], Any, None] = None (别名 'timeout')¶: 对 OpenAI 完成 API 请求的超时设置。可以是 float、httpx.Timeout 或 None。

param streaming: bool = False¶: 是否流式传输结果。

param tags: Optional[List[str]] = None¶: 添加到运行轨迹的标签。

param temperature: float = 0.7¶: 要使用的采样温度。

param tiktoken_model_name: Optional[str] = None¶: 使用此类时传递给 tiktoken 的模型名称。 Tiktoken 用于计算文档中的 token 数量，以将其约束在某个限制之下。默认情况下，当设置为 None 时，这将与嵌入模型名称相同。但是，在某些情况下，您可能希望将此 Embedding 类与 tiktoken 不支持的模型名称一起使用。这可能包括使用 Azure 嵌入或使用许多模型提供商之一，这些提供商公开了类似 OpenAI 的 API，但模型不同。在这些情况下，为了避免在调用 tiktoken 时出错，您可以在此处指定要使用的模型名称。

param top_p: float = 1¶: 每一步要考虑的 token 的总概率质量。

param verbose [可选]¶: 是否打印输出响应文本。

__call__(prompt: str, stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → str¶

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

检查缓存并在给定的提示和输入上运行 LLM。

参数

prompt (str) – 生成内容的提示。
stop (Optional[List[str]]) – 生成时使用的停止词。模型输出将在首次出现任何这些子字符串时被截断。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能，例如日志记录或流式传输。
tags (Optional[List[str]]) – 与提示关联的标签列表。
metadata (Optional[Dict[str, Any]]) – 与提示关联的元数据。
**kwargs (Any) – 任意额外的关键字参数。这些通常传递给模型提供商 API 调用。

返回值

生成的文本。

引发

ValueError – 如果提示不是字符串。

返回类型

str

async abatch(inputs: List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Any) → List[str]¶

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

批处理的默认实现适用于 IO 绑定的 Runnable。

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

参数

inputs (List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]]) – Runnable 的输入列表。
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) – 调用 Runnable 时使用的配置。该配置支持标准键，如用于追踪目的的 ‘tags’、‘metadata’，用于控制并行执行多少工作的 ‘max_concurrency’，以及其他键。请参阅 RunnableConfig 以获取更多详细信息。默认为 None。
return_exceptions (bool) – 是否返回异常而不是引发异常。默认为 False。
kwargs (Any) – 要传递给 Runnable 的其他关键字参数。

返回值

来自 Runnable 的输出列表。

返回类型

List[str]

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 agenerate(prompts: List[str], stop: Optional[List[str]] = None, callbacks: Union[List[BaseCallbackHandler], BaseCallbackManager, None, List[Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]]] = None, *, tags: Optional[Union[List[str], List[List[str]]]] = None, metadata: Optional[Union[Dict[str, Any]], List[Dict[str, Any]]]] = None, run_name: Optional[Union[str, List[str]]] = None, run_id: Optional[Union[UUID, List[Optional[UUID]]]] = None, **kwargs: Any) → LLMResult¶

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

此方法应利用对公开批处理 API 的模型的批处理调用。

当您想要以下操作时，请使用此方法

利用批处理调用，
需要比仅仅是最佳生成值更多的模型输出，
正在构建与底层语言模型无关的链
类型（例如，纯文本完成模型与聊天模型）。

参数

prompts (List[str]) – 字符串提示列表。
stop (Optional[List[str]]) – 生成时使用的停止词。模型输出将在首次出现任何这些子字符串时被截断。
callbacks (Union[List[BaseCallbackHandler], BaseCallbackManager, None, List[Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]]]) – 要传递的回调。用于在整个生成过程中执行额外的功能，例如日志记录或流式传输。
tags (Optional[Union[List[str], List[List[str]]]]) – 要与每个提示关联的标签列表。如果提供，则列表的长度必须与提示列表的长度匹配。
metadata (Optional[Union[Dict[str, Any], List[Dict[str, Any]]]]) – 要与每个提示关联的元数据字典列表。如果提供，则列表的长度必须与提示列表的长度匹配。
run_name (Optional[Union[str, List[str]]]) – 要与每个提示关联的运行名称列表。如果提供，则列表的长度必须与提示列表的长度匹配。
run_id (Optional[Union[UUID, List[Optional[UUID]]]]) – 要与每个提示关联的运行 ID 列表。如果提供，则列表的长度必须与提示列表的长度匹配。
**kwargs (Any) – 任意额外的关键字参数。这些通常传递给模型提供商 API 调用。

返回值

一个 LLMResult，其中包含每个输入的候选 Generations 列表: 提示和额外的模型提供商特定的输出。

返回类型

LLMResult

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

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

此方法应利用对公开批处理 API 的模型的批处理调用。

当您想要以下操作时，请使用此方法

利用批处理调用，
需要比仅仅是最佳生成值更多的模型输出，
正在构建与底层语言模型无关的链
类型（例如，纯文本完成模型与聊天模型）。

参数

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

返回值

一个 LLMResult，其中包含每个输入的候选 Generations 列表: 提示和额外的模型提供商特定的输出。

返回类型

LLMResult

async ainvoke(input: Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) → str¶

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

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

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

参数

input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) –
config (Optional[RunnableConfig]) –
stop (Optional[List[str]]) –
kwargs (Any) –

返回类型

str

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

Deprecated since version 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: 请使用 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¶

BetaBeta 版本

This API is in beta and may change in the future.此 API 处于 Beta 版本，未来可能会发生变更。

Create a BaseTool from a Runnable.从 Runnable 创建一个 BaseTool。

as_tool will instantiate a BaseTool with a name, description, and as_tool 将使用名称、描述和 args_schema from a Runnable. Where possible, schemas are inferred from 从 Runnable 实例化一个 BaseTool。在可能的情况下，模式会从 runnable.get_input_schema . Alternatively (e.g., if the Runnable takes a dict as input and the specific dict keys are not typed), the schema can be specified directly with 中推断。或者（例如，如果 Runnable 接受字典作为输入，并且未键入特定的字典键），则可以直接使用 args_schema . You can also pass 指定模式。您还可以传递 arg_types to just specify the required arguments and their types.以仅指定所需的参数及其类型。

参数

args_schema (Optional[Type[BaseModel]]) – The schema for the tool. Defaults to None.args_schema (可选[Type[BaseModel]]) – 工具的模式。默认为 None。
name (Optional[str]) – The name of the tool. Defaults to None.name (可选[str]) – 工具的名称。默认为 None。
description (Optional[str]) – The description of the tool. Defaults to None.description (可选[str]) – 工具的描述。默认为 None。
arg_types (Optional[Dict[str, Type]]) – A dictionary of argument names to types. Defaults to None.arg_types (可选[Dict[str, Type]]) – 参数名称到类型的字典。默认为 None。

返回值

A BaseTool instance.一个 BaseTool 实例。

返回类型

BaseToolBaseTool

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, specifying schema via 输入，通过 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 input, specifying schema via 输入，通过 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]})

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")

New in version 0.2.14.0.2.14 版本新增。

async astream(input: Union[PromptValue, str, Sequence[Union[BaseMessage, List][str], Tuple][str, str], str, Dict][str, Any]]]], config: Optional[RunnableConfig] = None, *, stop: Optional[List][str]] = None, **kwargs: Any) → AsyncIterator[str]¶

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

参数

input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – The input to the Runnable.input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – Runnable 的输入。
config (Optional[RunnableConfig]) – The config to use for the Runnable. Defaults to None.config (可选[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。
kwargs (Any) – 要传递给 Runnable 的其他关键字参数。
stop (Optional[List[str]]) –

产生

The output of the Runnable.Runnable 的输出。

返回类型

AsyncIteratorAsyncIterator[str]

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

BetaBeta 版本

This API is in beta and may change in the future.此 API 处于 Beta 版本，未来可能会发生变更。

Generate a stream of events.生成事件流。

Use to create an iterator over StreamEvents that provide real-time information about the progress of the Runnable, including StreamEvents from intermediate results.用于创建 StreamEvent 的迭代器，该迭代器提供关于 Runnable 进度的实时信息，包括来自中间结果的 StreamEvent。

A StreamEvent is a dictionary with the following schemaStreamEvent 是一个具有以下模式的字典

event: str - Event names are of thestr: str - 事件名称的格式为
format: on_[runnable_type]_(start|stream|end).格式：on_[runnable_type]_(start|stream|end)。
name: str - The name of the Runnable that generated the event.str: str - 生成事件的 Runnable 的名称。
run_id: str - randomly generated ID associated with the given execution ofstr: 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] - The IDs of the parent runnables thatstr: 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]] - The tags of the Runnable that generatedstr: Optional[List[str]] - 生成事件的 Runnable 的标签。
the event.
metadata: Optional[Dict[str, Any]] - The metadata of the Runnablestr: Optional[Dict[str, Any]] - 生成事件的 Runnable 的元数据。
that generated the event.
data: Dict[str, Any]str: Dict[str, Any]

Below is a table that illustrates some evens that might be emitted by various chains. Metadata fields have been omitted from the table for brevity. Chain definitions have been included after the table.下面是一个表格，说明了各种链可能发出的一些事件。为了简洁起见，元数据字段已从表中省略。链定义已包含在表格之后。

ATTENTION This reference table is for the V2 version of the schema.注意此参考表适用于模式的 V2 版本。

event事件	name名称	chunk块	input输入	output输出
on_chat_model_starton_chat_model_start	[model name][模型名称]		{“messages”: [[SystemMessage, HumanMessage]]}{“messages”: [[SystemMessage, HumanMessage]]}
on_chat_model_streamon_chat_model_stream	[model name][模型名称]	AIMessageChunk(content=”hello”)AIMessageChunk(content=”hello”)
on_chat_model_endon_chat_model_end	[model name][模型名称]		{“messages”: [[SystemMessage, HumanMessage]]}{“messages”: [[SystemMessage, HumanMessage]]}	AIMessageChunk(content=”hello world”)AIMessageChunk(content=”hello world”)
on_llm_starton_llm_start	[model name][模型名称]		{‘input’: ‘hello’}{‘input’: ‘hello’}
on_llm_streamon_llm_stream	[model name][模型名称]	‘Hello’‘Hello’
on_llm_endon_llm_end	[model name][模型名称]		‘Hello human!’‘Hello human!’
on_chain_starton_chain_start	format_docsformat_docs
on_chain_streamon_chain_stream	format_docsformat_docs	“hello world!, goodbye world!”“hello world!, goodbye world!”
on_chain_endon_chain_end	format_docsformat_docs		[Document(…)][Document(…)]	“hello world!, goodbye world!”“hello world!, goodbye world!”
on_tool_starton_tool_start	some_toolsome_tool		{“x”: 1, “y”: “2”}{“x”: 1, “y”: “2”}
on_tool_endon_tool_end	some_toolsome_tool			{“x”: 1, “y”: “2”}{“x”: 1, “y”: “2”}
on_retriever_starton_retriever_start	[retriever name][检索器名称]		{“query”: “hello”}{“query”: “hello”}
on_retriever_endon_retriever_end	[retriever name][检索器名称]		{“query”: “hello”}{“query”: “hello”}	[Document(…), ..][Document(…), ..]
on_prompt_starton_prompt_start	[template_name][模板名称]		{“question”: “hello”}{“question”: “hello”}
on_prompt_endon_prompt_end	[template_name][模板名称]		{“question”: “hello”}{“question”: “hello”}	ChatPromptValue(messages: [SystemMessage, …])ChatPromptValue(messages: [SystemMessage, …])

In addition to the standard events, users can also dispatch custom events (see example below).除了标准事件之外，用户还可以分派自定义事件（请参阅下面的示例）。

Custom events will be only be surfaced with in the 自定义事件将仅在 v2 version of the API!版本的 API 中显示！

A custom event has following format自定义事件具有以下格式

Attribute属性	Type类型	Description描述
name名称	str	A user defined name for the event.事件的用户定义名称。
data数据	AnyAny	The data associated with the event. This can be anything, though we suggest making it JSON serializable.与事件关联的数据。这可以是任何内容，但我们建议使其可 JSON 序列化。

Here are declarations associated with the standard events shown above以下是与上面显示的标准事件关联的声明

format_docsformat_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_toolsome_tool:

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

promptprompt:

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": [],
    },
]

Example: Dispatch Custom Event示例：分派自定义事件

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) – The input to the Runnable.input (Any) – Runnable 的输入。
config (Optional[RunnableConfig]) – The config to use for the Runnable.config (可选[RunnableConfig]) – 用于 Runnable 的配置。
version (Literal['v1', 'v2']) – The version of the schema to use either version (Literal['v1', 'v2']) – 要使用的模式版本，可以是 v2 or 或 v1. Users should use 。用户应使用 v2. 。 v1 is for backwards compatibility and will be deprecated in 0.4.0. No default will be assigned until the API is stabilized. custom events will only be surfaced in 用于向后兼容，将在 0.4.0 版本中弃用。在 API 稳定之前，不会分配默认值。自定义事件将仅在 v2 .中显示。
include_names (Optional[Sequence[str]]) – Only include events from runnables with matching names.include_names (可选[Sequence[str]]) – 仅包括来自具有匹配名称的 runnables 的事件。
include_types (Optional[Sequence[str]]) – Only include events from runnables with matching types.include_types (可选[Sequence[str]]) – 仅包括来自具有匹配类型的 runnables 的事件。
include_tags (Optional[Sequence[str]]) – Only include events from runnables with matching tags.include_tags (可选[Sequence[str]]) – 仅包括来自具有匹配标签的 runnables 的事件。
exclude_names (Optional[Sequence[str]]) – Exclude events from runnables with matching names.exclude_names (可选[Sequence[str]]) – 排除来自具有匹配名称的 runnables 的事件。
exclude_types (Optional[Sequence[str]]) – Exclude events from runnables with matching types.exclude_types (可选[Sequence[str]]) – 排除来自具有匹配类型的 runnables 的事件。
exclude_tags (Optional[Sequence[str]]) – Exclude events from runnables with matching tags.exclude_tags (可选[Sequence[str]]) – 排除来自具有匹配标签的 runnables 的事件。
kwargs (Any) – Additional keyword arguments to pass to the Runnable. These will be passed to astream_log as this implementation of astream_events is built on top of astream_log.kwargs (Any) – 要传递给 Runnable 的其他关键字参数。这些参数将传递给 astream_log，因为 astream_events 的此实现构建在 astream_log 之上。

产生

An async stream of StreamEvents.StreamEvents 的异步流。

引发

NotImplementedError – If the version is not NotImplementedError – 如果版本不是 v1 or 或 v2.。

返回类型

AsyncIteratorAsyncIterator[UnionUnion[StandardStreamEvent, CustomStreamEvent]]

batch(inputs: List[Union[PromptValue, str, Sequence[Union[BaseMessage, List][str], Tuple][str, str], str, Dict][str, Any]]]]], config: Optional[Union[RunnableConfig, List][RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Any) → List[str]¶

Default implementation runs invoke in parallel using a thread pool executor.默认实现使用线程池执行器并行运行 invoke。

批处理的默认实现适用于 IO 绑定的 Runnable。

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

参数

inputs (List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]]) –inputs (List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]]) –
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) –config (可选[Union[RunnableConfig, List[RunnableConfig]]]) –
return_exceptions (bool) –return_exceptions (bool) –
kwargs (Any) –

返回类型

List[str]

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

Run invoke in parallel on a list of inputs, yielding results as they complete.在一系列输入上并行运行 invoke，并在结果完成时产生结果。

参数

inputs (Sequence[Input]) –inputs (Sequence[Input]) –
config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) –config (可选[Union[RunnableConfig, Sequence[RunnableConfig]]]) –
return_exceptions (bool) –return_exceptions (bool) –
kwargs (Optional[Any]) –kwargs (可选[Any]) –

返回类型

IteratorIterator[TupleTuple[int, UnionUnion[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]¶

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

参数

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。

返回类型

RunnableSerializableRunnableSerializable[InputInput, OutputOutput]

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。
返回类型: RunnableSerializableRunnableSerializable[InputInput, OutputOutput]

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
)

create_llm_result(choices: Any, prompts: List[str], params: Dict[str, Any], token_usage: Dict[str, int], *, system_fingerprint: Optional[str] = None) → LLMResult¶

从 choices 和 prompts 创建 LLMResult。

参数

choices (Any) –
prompts (List[str]) –
params (Dict[str, Any]) –
token_usage (Dict[str, int]) –
system_fingerprint (Optional[str]) –

返回类型

LLMResult

generate(prompts: List[str], stop: Optional[List[str]] = None, callbacks: Union[List[BaseCallbackHandler], BaseCallbackManager, None, List[Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]]] = None, *, tags: Optional[Union[List[str], List[List[str]]]] = None, metadata: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None, run_name: Optional[Union[str, List[str]]] = None, run_id: Optional[Union[UUID, List[Optional[UUID]]]] = None, **kwargs: Any) → LLMResult¶

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

此方法应利用对公开批处理 API 的模型的批处理调用。

当您想要以下操作时，请使用此方法

利用批处理调用，
需要比仅仅是最佳生成值更多的模型输出，
正在构建与底层语言模型无关的链
类型（例如，纯文本完成模型与聊天模型）。

参数

prompts (List[str]) – 字符串提示列表。
stop (Optional[List[str]]) – 生成时使用的停止词。模型输出将在首次出现任何这些子字符串时被截断。
callbacks (Union[List[BaseCallbackHandler], BaseCallbackManager, None, List[Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]]]) – 要传递的回调。用于在整个生成过程中执行额外的功能，例如日志记录或流式传输。
tags (Optional[Union[List[str], List[List[str]]]]) – 要与每个提示关联的标签列表。如果提供，则列表的长度必须与提示列表的长度匹配。
metadata (Optional[Union[Dict[str, Any], List[Dict[str, Any]]]]) – 要与每个提示关联的元数据字典列表。如果提供，则列表的长度必须与提示列表的长度匹配。
run_name (Optional[Union[str, List[str]]]) – 要与每个提示关联的运行名称列表。如果提供，则列表的长度必须与提示列表的长度匹配。
run_id (Optional[Union[UUID, List[Optional[UUID]]]]) – 要与每个提示关联的运行 ID 列表。如果提供，则列表的长度必须与提示列表的长度匹配。
**kwargs (Any) – 任意额外的关键字参数。这些通常传递给模型提供商 API 调用。

返回值

一个 LLMResult，其中包含每个输入的候选 Generations 列表: 提示和额外的模型提供商特定的输出。

返回类型

LLMResult

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

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

此方法应利用对公开批处理 API 的模型的批处理调用。

当您想要以下操作时，请使用此方法

利用批处理调用，
需要比仅仅是最佳生成值更多的模型输出，
正在构建与底层语言模型无关的链
类型（例如，纯文本完成模型与聊天模型）。

参数

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

返回值

一个 LLMResult，其中包含每个输入的候选 Generations 列表: 提示和额外的模型提供商特定的输出。

返回类型

LLMResult

get_num_tokens(text: str) → int¶

获取文本中存在的令牌数量。

用于检查输入是否适合模型的上下文窗口。

参数: text (str) – 要标记化的字符串输入。
返回值: 文本中的整数令牌数。
返回类型: int

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

获取消息中的令牌数量。

用于检查输入是否适合模型的上下文窗口。

参数: messages (List[BaseMessage]) – 要标记化的消息输入。
返回值: 消息中令牌数量的总和。
返回类型: int

get_sub_prompts(params: Dict[str, Any], prompts: List[str], stop: Optional[List[str]] = None) → List[List[str]]¶

获取 llm 调用的子提示。

参数

params (Dict[str, Any]) –
prompts (List[str]) –
stop (Optional[List[str]]) –

返回类型

List[List[str]]

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

使用 tiktoken 包获取令牌 ID。

参数: text (str) –
返回类型: List[int]

invoke(input: Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) → str¶

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

参数

input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – The input to the Runnable.input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – Runnable 的输入。
config (Optional[RunnableConfig]) – 调用 Runnable 时要使用的配置。该配置支持标准键，如用于跟踪目的的 ‘tags’、‘metadata’，用于控制并行工作量的 ‘max_concurrency’，以及其他键。有关更多详细信息，请参阅 RunnableConfig。
stop (Optional[List[str]]) –
kwargs (Any) –

返回值

The output of the Runnable.Runnable 的输出。

返回类型

str

max_tokens_for_prompt(prompt: str) → int¶

计算提示可以生成的最大令牌数。

参数: prompt (str) – 要传递到模型中的提示。
返回值: 提示可以生成的最大令牌数。
返回类型: int

示例

max_tokens = openai.max_token_for_prompt("Tell me a joke.")

static modelname_to_contextsize(modelname: str) → int¶

计算模型可以生成的最大令牌数。

参数: modelname (str) – 我们想要知道上下文大小的模型名称。
返回值: 最大上下文大小
返回类型: int

示例

max_tokens = openai.modelname_to_contextsize("gpt-3.5-turbo-instruct")

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

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

保存 LLM。

参数: file_path (Union[Path, str]) – 将 LLM 保存到的文件路径。
引发: ValueError – 如果文件路径不是字符串或 Path 对象。
返回类型: None

示例: .. code-block:: python

llm.save(file_path=”path/llm.yaml”)

stream(input: Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) → Iterator[str]¶

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

参数

input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – The input to the Runnable.input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – Runnable 的输入。
config (Optional[RunnableConfig]) – The config to use for the Runnable. Defaults to None.config (可选[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。
kwargs (Any) – 要传递给 Runnable 的其他关键字参数。
stop (Optional[List[str]]) –

产生

The output of the Runnable.Runnable 的输出。

返回类型

Iterator[str]

to_json() → Union[SerializedConstructor, SerializedNotImplemented]¶

将 Runnable 序列化为 JSON。

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

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

未在此类中实现。

参数

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

property max_context_size: int¶: 获取此模型的最大上下文大小。

OctoAIEndpoint 的使用示例¶

OctoAI

langchain_community.llms.octoai_endpoint.OctoAIEndpoint¶

OctoAIEndpoint 的使用示例¶

`langchain_community.llms.octoai_endpoint`.OctoAIEndpoint¶