`langchain_community.llms.cerebriumai`.CerebriumAI¶

注意

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

Runnable 接口具有额外的运行时可用的方法，例如with_types、with_retry、assign、bind、get_graph等。

class langchain_community.llms.cerebriumai.CerebriumAI[source]¶

基类: LLM

CerebriumAI大型语言模型。

要使用，应安装cerebrium Python包。您还应该设置环境变量CEREBRIUMAI_API_KEY为您的API密钥，或者在构造函数中以命名参数的形式传递。

可以将任何有效的调用参数传递，即使这些参数在此类中未明确保存。

示例

from langchain_community.llms import CerebriumAI
cerebrium = CerebriumAI(endpoint_url="", cerebriumai_api_key="my-api-key")

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

是否缓存响应。

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

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

参数 callback_manager: 可选[BaseCallbackManager] = None¶: [已废弃]

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

参数 cerebriumai_api_key: 可选[SecretStr] = None¶

约束条件

类型 = 字符串
只写 = True
格式 = 密码

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

参数 endpoint_url: str = ''¶: 要使用的模型端点

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

参数 model_kwargs: Dict[str, Any] [可选]¶: 包含任何在 create 调用中未明确指定的、适用于模型的参数。

param tags: Optional[List[str]] = None¶: 要将标签添加到运行跟踪中。

param verbose: bool [Optional]¶: 是否打印出响应文本。

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

自版本 langchain-core==0.1.7 起已弃用: 请使用 invoke 代替。

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

参数

prompt (str) – 生成文本的提示。
stop (可选[列表[字符串]]) – 生成时要使用的停用词。模型输出会在任意这些子字符串的第一个出现时被截断。
callbacks (可选[联合[列表[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调函数。用于在整个生成过程中执行额外的功能，如日志记录或流处理。
tags (可选[列表[字符串]]) – 与提示关联的标签列表。
metadata (可选[字典[字符串，任何类型]]) – 与提示关联的元数据。
**kwargs (任何类型) – 任意额外的关键字参数。这些通常传递给模型提供者API调用。

返回值

生成的文本。

抛出

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

返回类型

字符串

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 并行运行 invoke。

默认的实现方式对IO密集型运行程序非常有效。

如果子类能以更有效的方式实现批处理，应该覆盖此方法；例如，如果底层Runnable使用支持批处理模式的API。

参数

inputs (列表[联合[PromptValue、str、Sequence[联合[BaseMessage、列表[str]、Tuple[str、str]、str、字典[str、Any]]]]) – Runnable 对象的输入列表。
config (可选[联合[RunnableConfig、列表[RunnableConfig]]]) – 调用 Runnable 时使用的配置。配置支持标准键，如 ‘tags’、‘metadata’ 用于跟踪目的、‘max_concurrency’ 用于控制并行工作量，以及其他键。请参阅 RunnableConfig 以获取更多详情。默认为 None。
return_exceptions (布尔值) – 是否返回异常而不是抛出它们。默认为 False。
kwargs (Any) – 传递给 Runnable 的额外关键字参数。

返回值

Runnable 的输出列表。

返回类型

列表[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、联合[Output、Exception]]]¶

在输入列表上并行运行 ainvoke，按完成顺序产生结果。

参数

inputs (Sequence[Input]) – Runnable 对象的输入列表。
config （可选[并集[RunnableConfig，序列[RunnableConfig]]]） – 在调用Runnable时使用的配置。该配置支持标准键，如‘tags’、‘metadata’用于跟踪目的，‘max_concurrency’用于控制并发完成的工作量，以及其他键。请参阅RunnableConfig以获取更多详细信息。默认为None。默认为None。
return_exceptions (布尔值) – 是否返回异常而不是抛出它们。默认为 False。
kwargs （可选[任何]） – 传递给Runnable的额外关键字参数。

生成

一个包含Runnable的输入和输出索引的元组。

返回类型

AsyncIterator[元组[int, 并集[输出, 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 （列表[str]） – 字符串提示列表。
stop (可选[列表[字符串]]) – 生成时要使用的停用词。模型输出会在任意这些子字符串的第一个出现时被截断。
callbacks （并集[列表[BaseCallbackHandler]，BaseCallbackManager，None，列表[可选[并集[列表[BaseCallbackHandler]，BaseCallbackManager]]]]) – 传递的回调。用于在生成过程中执行额外的功能，如日志记录或流式传输。
tags （可选[并集[列表[str]，列表[列表[str]]]]]) – 与每个提示相关联的标签列表。如果提供，则列表长度必须与提示列表的长度匹配。
metadata （可选[并集[字典[str，任何]，列表[字典[str，任何]]]]]) – 与每个提示相关联的元数据字典列表。如果提供，则列表长度必须与提示列表的长度匹配。
run_name （可选[并集[str，列表[str]]]]) – 与每个提示相关联的运行名称列表。如果提供，则列表长度必须与提示列表的长度匹配。
run_id （可选[并集[UUID，列表[可选[UUID]]]]) – 与每个提示相关联的运行ID列表。如果提供，则列表长度必须与提示列表的长度匹配。
**kwargs (任何类型) – 任意额外的关键字参数。这些通常传递给模型提供者API调用。

返回值

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

返回类型

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 (列表[提示值]) – 提示值列表。提示值是一个可以转换为任何语言模型格式的对象（纯文本生成模型的字符串和聊天模型的BaseMessages）。
stop (可选[列表[字符串]]) – 生成时要使用的停用词。模型输出会在任意这些子字符串的第一个出现时被截断。
callbacks （并集[列表[BaseCallbackHandler]，BaseCallbackManager，None，列表[可选[并集[列表[BaseCallbackHandler]，BaseCallbackManager]]]]) – 传递的回调。用于在生成过程中执行额外的功能，如日志记录或流式传输。
**kwargs (任何类型) – 任意额外的关键字参数。这些通常传递给模型提供者API调用。

返回值

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

返回类型

LLMResult

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

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

默认实现允许即使在 Runnable 未实现 invoke 的原生异步版本的情况下，也能使用异步代码。

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

参数

输入 (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) –
配置 (Optional[RunnableConfig]) –
停止 (Optional[List[str]]) –
kwargs (Any) –

返回类型

字符串

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

自版本 langchain-core==0.1.7 已弃用：请使用 ainvoke 代替。

参数

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

返回类型

字符串

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

自版本 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以字典作为输入并且特定的字典键没有类型（例如），可以使用args_schema直接指定模式。您还可以传递arg_types来仅指定所需的参数及其类型。

参数

args_schema (可选[类型[BaseModel]]) – 工具的模式。默认为None。
name (可选[str]) – 工具的名称。默认为None。
description (可选[str]) – 工具的描述。默认为None。
arg_types (可选[Dict[str, Type]]) – 参数名称到类型的字典。默认为None。

返回值

BaseTool实例。

返回类型

BaseTool

类型化字典输入

from typing import List
from typing_extensions import TypedDict
from langchain_core.runnables import RunnableLambda

class Args(TypedDict):
    a: int
    b: List[int]

def f(x: Args) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool()
as_tool.invoke({"a": 3, "b": [1, 2]})

dict输入，通过args_schema指定模式

from typing import Any, Dict, List
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

class FSchema(BaseModel):
    """Apply a function to an integer and list of integers."""

    a: int = Field(..., description="Integer")
    b: List[int] = Field(..., description="List of ints")

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(FSchema)
as_tool.invoke({"a": 3, "b": [1, 2]})

dict输入，通过arg_types指定模式

from typing import Any, Dict, List
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(arg_types={"a": int, "b": List[int]})
as_tool.invoke({"a": 3, "b": [1, 2]})

字符串输入

from langchain_core.runnables import RunnableLambda

def f(x: str) -> str:
    return x + "a"

def g(x: str) -> str:
    return x + "z"

runnable = RunnableLambda(f) | g
as_tool = runnable.as_tool()
as_tool.invoke("b")

新功能版本0.2.14。

async astream(input: 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]¶

astream 的默认实现，调用 ainvoke。子类应重写此方法以支持流式输出。

参数

input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – 可运行对象的输入。
config (Optional[RunnableConfig]) – 使用该配置可运行对象。默认为 None。
kwargs (Any) – 传递给 Runnable 的额外关键字参数。
停止 (Optional[List[str]]) –

生成

可运行对象的输出。

返回类型

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

beta

此API处于beta测试阶段，将来可能会有所变化。

生成事件流。

用于迭代提供关于可运行对象进度的实时信息的 StreamEvents，包括中间结果的事件。

StreamEvent 是一个具有以下模式的字典

event: str - 事件名称是
格式: on_[运行类型]_(开始|流|结束)。
name: str - 触发事件的 Runnable 对象的名称。
run_id: str - 与给定执行关联的随机生成的 ID。此 ID 与触发事件的 Runnable 对象有关。当一个 Runnable 对象在其父级 Runnable 对象的执行过程中被调用时，其会分配一个唯一的 ID。
下面是事件父 Runnable 对象的 ID 列表。根 Runnable 对象将有一个空列表。父 ID 的顺序是从根到直接父级。仅适用于 API 的 v2 版本。API 的 v1 版本将返回一个空列表。
parent_ids: List[str] - 生成事件的父级 Runnable 对象的 ID。
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 对象的标签。
事件。
metadata: Optional[Dict[str, Any]] - 触发事件的 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 版本中显示！

自定义事件的格式如下

属性	类型	描述
名称	字符串	用户定义的事件名称。
数据	任何	与事件关联的数据。这可以是任何内容，尽管我们建议让它是可序列化的 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]]) – 仅包含具有匹配名称的 Runnable 的事件。
include_types (Optional[Sequence[str]]) – 仅包含具有匹配类型的 Runnable 的事件。
include_tags (可选[序列[字符串]]) – 仅包括具有匹配标签的可执行块的事件。
exclude_names (可选[序列[字符串]]) – 排除具有匹配名称的可执行块的事件。
exclude_types (可选[序列[字符串]]) – 排除具有匹配类型的可执行块的事件。
exclude_tags (可选[序列[字符串]]) – 排除具有匹配标签的可执行块的事件。
kwargs (任意) – 传递到可供使用的额外关键字参数。这些将被传递到astream_log，因为astream_events的此实现是在astream_log的基础上构建的。

生成

异步流中的StreamEvents。

抛出

NotImplementedError – 如果版本不是v1或v2。

返回类型

AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]

批量(inputs: 列表[联合[PromptValue, str, 序列[联合[BaseMessage, 列表[str], 元组[str, str], str, 字典[str, 任何类型]]]]], str, str, dict[str, 任何类型]]]], config: 可选[联合[RunnableConfig, 列表[RunnableConfig]]]], *, return_exceptions: bool = False, **kwargs: 任何类型) → 列表[str]¶

默认实现在线程池管理器中并行调用。

默认的实现方式对IO密集型运行程序非常有效。

如果子类能以更有效的方式实现批处理，应该覆盖此方法；例如，如果底层Runnable使用支持批处理模式的API。

参数

inputs (列表[联合[PromptValue, str, 序列[联合[BaseMessage, 列表[str], 元组[str, str], str, 字典[str, 任何类型]]]]]) –
config (可选[联合[RunnableConfig, 列表[RunnableConfig]]]) –
return_exceptions (bool) –
kwargs (Any) –

返回类型

列表[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]]]¶

在输入列表上并行运行 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 实例的 callables 的字典。

返回值

一个带有配置的替代选项的新 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]¶

在运行时配置特定的可运行字段的参数。

参数: **kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – 需要配置的 ConfigurableField 实例的字典。
返回值: 配置字段后创建的新可运行对象。
返回类型: 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(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 （列表[str]） – 字符串提示列表。
stop (可选[列表[字符串]]) – 生成时要使用的停用词。模型输出会在任意这些子字符串的第一个出现时被截断。
callbacks （并集[列表[BaseCallbackHandler]，BaseCallbackManager，None，列表[可选[并集[列表[BaseCallbackHandler]，BaseCallbackManager]]]]) – 传递的回调。用于在生成过程中执行额外的功能，如日志记录或流式传输。
tags （可选[并集[列表[str]，列表[列表[str]]]]]) – 与每个提示相关联的标签列表。如果提供，则列表长度必须与提示列表的长度匹配。
metadata （可选[并集[字典[str，任何]，列表[字典[str，任何]]]]]) – 与每个提示相关联的元数据字典列表。如果提供，则列表长度必须与提示列表的长度匹配。
run_name （可选[并集[str，列表[str]]]]) – 与每个提示相关联的运行名称列表。如果提供，则列表长度必须与提示列表的长度匹配。
run_id （可选[并集[UUID，列表[可选[UUID]]]]) – 与每个提示相关联的运行ID列表。如果提供，则列表长度必须与提示列表的长度匹配。
**kwargs (任何类型) – 任意额外的关键字参数。这些通常传递给模型提供者API调用。

返回值

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

返回类型

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 (列表[提示值]) – 提示值列表。提示值是一个可以转换为任何语言模型格式的对象（纯文本生成模型的字符串和聊天模型的BaseMessages）。
stop (可选[列表[字符串]]) – 生成时要使用的停用词。模型输出会在任意这些子字符串的第一个出现时被截断。
callbacks （并集[列表[BaseCallbackHandler]，BaseCallbackManager，None，列表[可选[并集[列表[BaseCallbackHandler]，BaseCallbackManager]]]]) – 传递的回调。用于在生成过程中执行额外的功能，如日志记录或流式传输。
**kwargs (任何类型) – 任意额外的关键字参数。这些通常传递给模型提供者API调用。

返回值

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

返回类型

LLMResult

get_num_tokens(text: str) → int¶

获取文本中的标记数量。

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

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

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

获取消息中的标记数。

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

参数: messages (ListBaseMessage]) – 用于标记化的消息输入。
返回值: 消息中标记总数的总和。
返回类型: int

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

返回文本中标记的有序ID。

参数

text (str) – 要分词的字符串输入。

返回值

对应文本中标记的ID列表，按其在文本中出现的顺序。: 在文本中按照出现顺序排列的ID列表。

返回类型

列表[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]]]]) – 可运行对象的输入。
config (可选[RunnableConfig]) - 在调用可运行时使用配置。该配置支持标准的键，如用于追踪的 'tags'、'metadata'，用于控制并行工作量的 'max_concurrency'，以及其他键。请参考RunnableConfig以获取更多详细信息。
停止 (Optional[List[str]]) –
kwargs (Any) –

返回值

可运行对象的输出。

返回类型

字符串

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

自版本 langchain-core==0.1.7 起已弃用: 请使用 invoke 代替。

参数

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

返回类型

字符串

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

自版本 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]¶

stream的默认实现，调用invoke。若子类支持流式输出，应重写此方法。

参数

input (Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]) – 可运行对象的输入。
config (Optional[RunnableConfig]) – 使用该配置可运行对象。默认为 None。
kwargs (Any) – 传递给 Runnable 的额外关键字参数。
停止 (Optional[List[str]]) –

生成

可运行对象的输出。

返回类型

str

to_json() → Union[SerializedConstructor, SerializedNotImplemented]¶

将可执行对象序列化为JSON。

返回值: 可序列化为JSON的Runnable表示。
返回类型: 联合[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]]

CerebriumAI的用法示例¶

CerebriumAI

langchain_community.llms.cerebriumai.CerebriumAI¶

CerebriumAI的用法示例¶

`langchain_community.llms.cerebriumai`.CerebriumAI¶