ChatCerebras#

class langchain_cerebras.chat_models.ChatCerebras[源代码]#

基础类：BaseChatOpenAI

ChatCerebras 聊天模型。

Setup:

安装 langchain-cerebras 并设置环境变量 CEREBRAS_API_KEY。

pip install -U langchain-cerebras
export CEREBRAS_API_KEY="your-api-key"

Key init args — completion params:

model: str: 使用的模型名称。
temperature: float: 采样温度。
max_tokens: Optional[int]: 生成的最大令牌数。

Key init args — client params:

timeout: Union[float, Tuple[float, float], Any, None]: 请求的超时时间。
max_retries: int: 最大重试次数。
api_key: Optional[str]: Cerebras API 密钥。如果未传入，将从环境变量 CEREBRAS_API_KEY 中读取。

Instantiate:

from langchain_cerebras import ChatCerebras

llm = ChatCerebras(
    model="llama-3.3-70b",
    temperature=0,
    max_tokens=None,
    timeout=None,
    max_retries=2,
    # api_key="...",
    # other params...
)

Invoke:

messages = [
    (
        "system",
        "You are a helpful translator. Translate the user sentence to French.",
    ),
    ("human", "I love programming."),
]
llm.invoke(messages)

AIMessage(
    content='The translation of "I love programming" to French is:\n\n"J\'adore programmer."',
    response_metadata={
        'token_usage': {'completion_tokens': 20, 'prompt_tokens': 32, 'total_tokens': 52},
        'model_name': 'llama-3.3-70b',
        'system_fingerprint': 'fp_679dff74c0',
        'finish_reason': 'stop',
    },
    id='run-377c2887-30ef-417e-b0f5-83efc8844f12-0',
    usage_metadata={'input_tokens': 32, 'output_tokens': 20, 'total_tokens': 52})

Stream:

for chunk in llm.stream(messages):
    print(chunk)

content='' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='The' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' translation' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' of' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' "' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='I' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' love' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' programming' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='"' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' to' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' French' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' is' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=':\n\n' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='"' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='J' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content="'" id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='ad' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='ore' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content=' programmer' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='."' id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'
content='' response_metadata={'finish_reason': 'stop', 'model_name': 'llama-3.3-70b', 'system_fingerprint': 'fp_679dff74c0'} id='run-3f9dc84e-208f-48da-b15d-e552b6759c24'

Async:

await llm.ainvoke(messages)

# stream:
# async for chunk in (await llm.astream(messages))

# batch:
# await llm.abatch([messages])

AIMessage(
    content='The translation of "I love programming" to French is:\n\n"J\'adore programmer."',
    response_metadata={
        'token_usage': {'completion_tokens': 20, 'prompt_tokens': 32, 'total_tokens': 52},
        'model_name': 'llama-3.3-70b',
        'system_fingerprint': 'fp_679dff74c0',
        'finish_reason': 'stop',
    },
    id='run-377c2887-30ef-417e-b0f5-83efc8844f12-0',
    usage_metadata={'input_tokens': 32, 'output_tokens': 20, 'total_tokens': 52})

Tool calling:

from langchain_core.pydantic_v1 import BaseModel, Field

llm = ChatCerebras(model="llama-3.3-70b")

class GetWeather(BaseModel):
    '''Get the current weather in a given location'''

    location: str = Field(
        ..., description="The city and state, e.g. San Francisco, CA"
    )

class GetPopulation(BaseModel):
    '''Get the current population in a given location'''

    location: str = Field(
        ..., description="The city and state, e.g. San Francisco, CA"
    )

llm_with_tools = llm.bind_tools([GetWeather, GetPopulation])
ai_msg = llm_with_tools.invoke(
    "Which city is bigger: LA or NY?"
)
ai_msg.tool_calls

[
    {
        'name': 'GetPopulation',
        'args': {'location': 'NY'},
        'id': 'call_m5tstyn2004pre9bfuxvom8x',
        'type': 'tool_call'
    },
    {
        'name': 'GetPopulation',
        'args': {'location': 'LA'},
        'id': 'call_0vjgq455gq1av5sp9eb1pw6a',
        'type': 'tool_call'
    }
]

Structured output:

from typing import Optional

from langchain_core.pydantic_v1 import BaseModel, Field


class Joke(BaseModel):
    '''Joke to tell user.'''

    setup: str = Field(description="The setup of the joke")
    punchline: str = Field(description="The punchline to the joke")
    rating: Optional[int] = Field(description="How funny the joke is, from 1 to 10")


structured_llm = llm.with_structured_output(Joke)
structured_llm.invoke("Tell me a joke about cats")

Joke(
    setup='Why was the cat sitting on the computer?',
    punchline='To keep an eye on the mouse!',
    rating=7
)

JSON mode:

json_llm = llm.bind(response_format={"type": "json_object"})
ai_msg = json_llm.invoke(
    "Return a JSON object with key 'random_ints' and a value of 10 random ints in [0-99]"
)
ai_msg.content

' {\\n"random_ints": [\\n13,\\n54,\\n78,\\n45,\\n67,\\n90,\\n11,\\n29,\\n84,\\n33\\n]\\n}'

Token usage:

ai_msg = llm.invoke(messages)
ai_msg.usage_metadata

{'input_tokens': 37, 'output_tokens': 6, 'total_tokens': 43}

Response metadata

ai_msg = llm.invoke(messages)
ai_msg.response_metadata

{
    'token_usage': {
        'completion_tokens': 4,
        'prompt_tokens': 19,
        'total_tokens': 23
        },
    'model_name': 'mistralai/Mixtral-8x7B-Instruct-v0.1',
    'system_fingerprint': None,
    'finish_reason': 'eos',
    'logprobs': None
}

注意

ChatCerebras 实现了标准的 Runnable Interface。🏃

Runnable Interface 接口在可运行对象上提供了额外的方法，例如 with_types, with_retry, assign, bind, get_graph, 等等。

param cache: BaseCache | bool | None = None#

是否缓存响应。

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

目前不支持对模型的流式方法进行缓存。

param callback_manager: BaseCallbackManager | None = None#: 自版本0.1.7起已弃用：请改用callbacks()。它将在pydantic==1.0中被移除。

回调管理器以添加到运行跟踪中。

param callbacks: Callbacks = None#: 添加到运行跟踪的回调。

param cerebras_api_base: str [Optional] (alias 'base_url')#

param cerebras_api_key: SecretStr | None [Optional] (alias 'api_key')#: 如果没有提供CEREBRAS_API_KEY，则会自动从环境中推断。

param cerebras_proxy: str [Optional]#

param custom_get_token_ids: Callable[[str], list[int]] | None = None#: 用于计数标记的可选编码器。

param default_headers: Mapping[str, str] | None = None#

param default_query: Mapping[str, object] | None = None#

param disable_streaming: bool | Literal['tool_calling'] = False#

是否禁用此模型的流式传输。

如果流式传输被绕过，那么 stream()/astream() 将依赖于 invoke()/ainvoke()。

如果为True，将始终绕过流式传输情况。
如果是“tool_calling”，只有在使用tools关键字参数调用模型时，才会绕过流式处理的情况。
如果为 False（默认值），将始终使用流式情况（如果可用）。

param disabled_params: Dict[str, Any] | None = None#

应该为给定模型禁用的OpenAI客户端或chat.completions端点的参数。

应指定为 {"param": None | ['val1', 'val2']}，其中键是参数，值要么是 None，表示该参数永远不应使用，要么是该参数的禁用值列表。

例如，较旧的模型可能根本不支持‘parallel_tool_calls’参数，在这种情况下，可以传入disabled_params={"parallel_tool_calls: None}。

如果一个参数被禁用，那么默认情况下它不会在任何方法中使用，例如在with_structured_output()中。然而，这并不阻止用户在调用时直接传入该参数。

param extra_body: Mapping[str, Any] | None = None#: 在向OpenAI兼容的API（如vLLM）发出请求时，可选的额外JSON属性包含在请求参数中。

param frequency_penalty: float | None = None#: 根据频率惩罚重复的标记。

param http_async_client: Any | None = None#: 可选的httpx.AsyncClient。仅用于异步调用。如果您希望为同步调用使用自定义客户端，则还必须指定http_client。

param http_client: Any | None = None#: 可选的httpx.Client。仅用于同步调用。如果您希望为异步调用使用自定义客户端，则还必须指定http_async_client。

param include_response_headers: bool = False#: 是否在输出消息response_metadata中包含响应头。

param logit_bias: Dict[int, int] | None = None#: 修改指定标记在完成中出现的可能性。

param logprobs: bool | None = None#: 是否返回对数概率。

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

param max_tokens: int | None = None#: 生成的最大令牌数。

param metadata: dict[str, Any] | None = None#: 要添加到运行跟踪的元数据。

param model_kwargs: Dict[str, Any] [Optional]#: 保存任何适用于create调用但未明确指定的模型参数。

param model_name: str [Required] (alias 'model')#: 使用的模型名称。

param n: int = 1#: 为每个提示生成的聊天完成次数。

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

param openai_api_key: SecretStr | None [Optional] (alias 'api_key')#

param openai_organization: str | None = None (alias 'organization')#: 如果未提供，则自动从环境变量 OPENAI_ORG_ID 推断。

param openai_proxy: str | None [Optional]#

param presence_penalty: float | None = None#: 惩罚重复的标记。

param rate_limiter: BaseRateLimiter | None = None#: 一个可选的速率限制器，用于限制请求的数量。

param reasoning_effort: str | None = None#

限制推理模型在推理上的努力。

仅限o1型号。

目前支持的值有低、中和高。减少推理努力可以导致更快的响应和在响应中使用的推理令牌更少。

在版本0.2.14中添加。

param request_timeout: float | Tuple[float, float] | Any | None = None (alias 'timeout')#: 请求OpenAI完成API的超时时间。可以是浮点数、httpx.Timeout或None。

param seed: int | None = None#: 生成种子

param stop: List[str] | str | None = None (alias 'stop_sequences')#: 默认的停止序列。

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

param tags: list[str] | None = None#: 要添加到运行跟踪的标签。

param temperature: float = 0.7#: 使用什么采样温度。

param tiktoken_model_name: str | None = None#: 在使用此类时传递给tiktoken的模型名称。 Tiktoken用于计算文档中的令牌数量，以限制它们不超过某个限制。默认情况下，当设置为None时，这将与嵌入模型名称相同。然而，在某些情况下，您可能希望将此嵌入类与tiktoken不支持的模型名称一起使用。这可能包括在使用Azure嵌入或使用许多模型提供商之一时，这些提供商暴露了一个类似OpenAI的API，但使用不同的模型。在这些情况下，为了避免在调用tiktoken时出错，您可以在此处指定要使用的模型名称。

param top_logprobs: int | None = None#: 在每个标记位置返回的最可能的标记数量，每个标记都有一个相关的对数概率。如果使用此参数，logprobs必须设置为true。

param top_p: float | None = None#: 每一步考虑的词元的总概率质量。

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

__call__(messages: list[BaseMessage], stop: list[str] | None = None, callbacks: list[BaseCallbackHandler] | BaseCallbackManager | None = None, **kwargs: Any) → BaseMessage#

自版本0.1.7起已弃用：请改用invoke()。在langchain-core==1.0之前不会移除。

Parameters:

messages (列表[BaseMessage])
stop (列表[字符串] | 无)
callbacks (列表[BaseCallbackHandler] | BaseCallbackManager | 无)
kwargs (Any)

Return type:

BaseMessage

async abatch(inputs: list[Input], config: RunnableConfig | list[RunnableConfig] | None = None, *, return_exceptions: bool = False, **kwargs: Any | None) → list[Output]#

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

batch的默认实现对于IO绑定的runnables效果很好。

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

Parameters:

inputs (list[Input]) – Runnable 的输入列表。
config (RunnableConfig | list[RunnableConfig] | None) – 调用Runnable时使用的配置。该配置支持标准键，如用于跟踪目的的‘tags’、‘metadata’，用于控制并行工作量的‘max_concurrency’，以及其他键。更多详情请参考RunnableConfig。默认为None。
return_exceptions (bool) – 是否返回异常而不是抛出它们。默认为 False。
kwargs (Any | None) – 传递给Runnable的额外关键字参数。

Returns:

Runnable 的输出列表。

Return type:

列表[输出]

async abatch_as_completed(inputs: Sequence[Input], config: RunnableConfig | Sequence[RunnableConfig] | None = None, *, return_exceptions: bool = False, **kwargs: Any | None) → AsyncIterator[tuple[int, Output | Exception]]#

在输入列表上并行运行ainvoke，在它们完成时产生结果。

Parameters:

inputs (Sequence[Input]) – Runnable 的输入列表。
config (RunnableConfig | Sequence[RunnableConfig] | None) – 调用Runnable时使用的配置。该配置支持标准键，如用于跟踪目的的'tags'、'metadata'，用于控制并行工作量的'max_concurrency'，以及其他键。有关更多详细信息，请参阅RunnableConfig。默认为None。默认为None。
return_exceptions (bool) – 是否返回异常而不是抛出它们。默认为 False。
kwargs (Any | None) – 传递给Runnable的额外关键字参数。

Yields:

输入索引和Runnable输出的元组。

Return type:

AsyncIterator[元组[int, Output | 异常]]

async ainvoke(input: LanguageModelInput, config: RunnableConfig | None = None, *, stop: list[str] | None = None, **kwargs: Any) → BaseMessage#

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

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

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

Parameters:

输入 (LanguageModelInput)
config (可选[RunnableConfig])
stop (可选[列表[字符串]])
kwargs (Any)

Return type:

BaseMessage

async astream(input: LanguageModelInput, config: RunnableConfig | None = None, *, stop: list[str] | None = None, **kwargs: Any) → AsyncIterator[BaseMessageChunk]#

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

Parameters:

input (LanguageModelInput) – Runnable 的输入。
config (可选[RunnableConfig]) – 用于Runnable的配置。默认为None。
kwargs (Any) – 传递给Runnable的额外关键字参数。
stop (可选[列表[字符串]])

Yields:

Runnable 的输出。

Return type:

异步迭代器[BaseMessageChunk]

async astream_events(input: Any, config: RunnableConfig | None = None, *, version: Literal['v1', 'v2'], include_names: Sequence[str] | None = None, include_types: Sequence[str] | None = None, include_tags: Sequence[str] | None = None, exclude_names: Sequence[str] | None = None, exclude_types: Sequence[str] | None = None, exclude_tags: Sequence[str] | None = None, **kwargs: Any) → AsyncIterator[StandardStreamEvent | CustomStreamEvent]#

生成事件流。

用于创建一个迭代器，遍历提供实时信息的StreamEvents，包括来自中间结果的StreamEvents。

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

event: str - 事件名称的格式为
格式: on_[runnable_type]_(start|stream|end).
name: str - 生成事件的 Runnable 的名称。
run_id: str - 与给定执行相关联的随机生成的ID
发出事件的Runnable。作为父Runnable执行的一部分被调用的子Runnable会被分配其自己唯一的ID。
parent_ids: List[str] - 生成事件的父可运行对象的ID。
根可运行对象将有一个空列表。父ID的顺序是从根到直接父对象。仅适用于API的v2版本。API的v1版本将返回一个空列表。
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	[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	[模型名称]	‘Hello’
on_llm_end	[model name]		‘你好，人类！’
链上开始	格式化文档
on_chain_stream	format_docs	“你好世界！，再见世界！”
on_chain_end	format_docs		[Document(…)]	“你好世界！，再见世界！”
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版本中显示！

自定义事件具有以下格式：

属性	类型	描述
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}

提示:

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)

Parameters:

input (Any) – Runnable 的输入。
config (RunnableConfig | None) – 用于Runnable的配置。
version (Literal['v1', 'v2']) – 使用的模式版本，可以是 v2 或 v1。用户应使用 v2。 v1 是为了向后兼容，将在 0.4.0 版本中弃用。在 API 稳定之前不会分配默认值。自定义事件仅在 v2 中显示。
include_names (Sequence[str] | None) – 仅包含来自具有匹配名称的可运行对象的事件。
include_types (Sequence[str] | None) – 仅包含来自具有匹配类型的可运行对象的事件。
include_tags (Sequence[str] | None) – 仅包含具有匹配标签的可运行对象的事件。
exclude_names (Sequence[str] | None) – 排除具有匹配名称的可运行对象的事件。
exclude_types (Sequence[str] | None) – 排除具有匹配类型的可运行对象的事件。
exclude_tags (Sequence[str] | None) – 排除具有匹配标签的可运行对象的事件。
kwargs (Any) – 传递给 Runnable 的额外关键字参数。这些参数将传递给 astream_log，因为 astream_events 的实现是基于 astream_log 的。

Yields:

一个异步的StreamEvents流。

Raises:

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

Return type:

AsyncIterator[StandardStreamEvent | CustomStreamEvent]

batch(inputs: list[Input], config: RunnableConfig | list[RunnableConfig] | None = None, *, return_exceptions: bool = False, **kwargs: Any | None) → list[Output]#

默认实现使用线程池执行器并行运行invoke。

batch的默认实现对于IO绑定的runnables效果很好。

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

Parameters:

inputs (列表[Input])
config (RunnableConfig | list[RunnableConfig] | None)
return_exceptions (bool)
kwargs (任意 | 无)

Return type:

列表[输出]

batch_as_completed(inputs: Sequence[Input], config: RunnableConfig | Sequence[RunnableConfig] | None = None, *, return_exceptions: bool = False, **kwargs: Any | None) → Iterator[tuple[int, Output | Exception]]#

在输入列表上并行运行invoke，在它们完成时产生结果。

Parameters:

inputs (Sequence[Input])
config (RunnableConfig | Sequence[RunnableConfig] | None)
return_exceptions (bool)
kwargs (任意 | 无)

Return type:

Iterator[元组[int, Output | 异常]]

bind(**kwargs: Any) → Runnable[Input, Output]#

将参数绑定到Runnable，返回一个新的Runnable。

当链中的Runnable需要一个不在前一个Runnable输出中或用户输入中的参数时，这很有用。

Parameters:: kwargs (Any) – 绑定到Runnable的参数。
Returns:: 一个新的Runnable，参数已绑定。
Return type:: Runnable[Input, Output]

示例：

from langchain_community.chat_models import ChatOllama
from langchain_core.output_parsers import StrOutputParser

llm = ChatOllama(model='llama2')

# Without bind.
chain = (
    llm
    | StrOutputParser()
)

chain.invoke("Repeat quoted words exactly: 'One two three four five.'")
# Output is 'One two three four five.'

# With bind.
chain = (
    llm.bind(stop=["three"])
    | StrOutputParser()
)

chain.invoke("Repeat quoted words exactly: 'One two three four five.'")
# Output is 'One two'

自版本0.2.1起已弃用：请改用bind_tools()。在langchain-openai==1.0.0之前不会移除。

将函数（和其他对象）绑定到此聊天模型。

假设模型与OpenAI函数调用API兼容。

NOTE: Using bind_tools is recommended instead, as the functions and: function_call 请求参数已被 OpenAI 正式标记为弃用。

Parameters:

functions (Sequence[Dict[str, Any] | Type[BaseModel] | Callable | BaseTool]) – 绑定到此聊天模型的一系列函数定义。可以是字典、pydantic 模型或可调用对象。Pydantic 模型和可调用对象将自动转换为它们的模式字典表示。
function_call (_FunctionCall | str | Literal['auto', 'none'] | None) – 需要模型调用的函数。必须是提供的单个函数的名称或 “auto”以自动确定要调用的函数（如果有的话）。
**kwargs (Any) – 传递给Runnable构造函数的任何额外参数。

Return type:

将类似工具的对象绑定到此聊天模型。

假设模型与OpenAI工具调用API兼容。

Parameters:

tools (Sequence[Dict[str, Any] | Type | Callable | BaseTool]) – 绑定到此聊天模型的工具定义列表。支持由 langchain_core.utils.function_calling.convert_to_openai_tool()处理的任何工具定义。
tool_choice (dict | str | Literal['auto', 'none', 'required', 'any'] | bool | None) –
要求模型调用的工具。选项有：
- 形式为 "<>" 的字符串：调用 <> 工具。
- "auto"：自动选择一个工具（包括不选择工具）。
- "none"：不调用工具。
- "any" 或 "required" 或 True：强制至少调用一个工具。
- 形式为 {"type": "function", "function": {"name": <>}} 的字典：调用 <> 工具。
- False 或 None：无效果，默认的 OpenAI 行为。
strict (bool | None) – 如果为True，模型输出将保证与工具定义中提供的JSON Schema完全匹配。如果为True，输入模式将根据https://platform.openai.com/docs/guides/structured-outputs/supported-schemas进行验证。如果为False，输入模式将不会被验证，模型输出也不会被验证。如果为None，strict参数将不会传递给模型。
kwargs (Any) – 任何额外的参数都直接传递给 bind().

Return type:

在版本0.1.21中更改：添加了对strict参数的支持。

configurable_alternatives(which: ConfigurableField, *, default_key: str = 'default', prefix_keys: bool = False, **kwargs: Runnable[Input, Output] | Callable[[], Runnable[Input, Output]]) → RunnableSerializable#

配置可以在运行时设置的Runnables的替代方案。

Parameters:

which (ConfigurableField) – 将用于选择替代项的ConfigurableField实例。
default_key (str) – 如果没有选择其他选项，则使用的默认键。默认为“default”。
prefix_keys (bool) – 是否在键前加上 ConfigurableField 的 id。默认为 False。
**kwargs (Runnable[Input, Output] | Callable[[], Runnable[Input, Output]]) – 一个字典，键为Runnable实例或返回Runnable实例的可调用对象。

Returns:

一个新的Runnable，配置了替代方案。

Return type:

RunnableSerializable

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: ConfigurableField | ConfigurableFieldSingleOption | ConfigurableFieldMultiOption) → RunnableSerializable#

在运行时配置特定的Runnable字段。

Parameters:: **kwargs (ConfigurableField | ConfigurableFieldSingleOption | ConfigurableFieldMultiOption) – 一个包含ConfigurableField实例的字典，用于配置。
Returns:: 一个新的Runnable，其字段已配置。
Return type:: RunnableSerializable

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
)

get_num_tokens(text: str) → int#

获取文本中存在的标记数量。

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

Parameters:: 文本 (字符串) – 要分词的字符串输入。
Returns:: 文本中的标记的整数数量。
Return type:: 整数

get_num_tokens_from_messages(messages: List[BaseMessage], tools: Sequence[Dict[str, Any] | Type | Callable | BaseTool] | None = None) → int#

使用tiktoken包计算gpt-3.5-turbo和gpt-4的令牌数量。

要求: 如果您想将图像指定为base64字符串并计算图像令牌，则必须安装pillow；如果您将图像指定为URL，则必须同时安装pillow和httpx。如果未安装这些库，则在令牌计数中将忽略图像输入。

OpenAI 参考：openai/openai-cookbook main/examples/如何格式化输入到ChatGPT模型的示例.ipynb

Parameters:

messages (List[BaseMessage]) – 要标记化的消息输入。
工具 (序列[字典[字符串, 任意类型] | 类型 | 可调用对象 | BaseTool] | 无) – 如果提供，字典、BaseModel、函数或BaseTools的序列将被转换为工具模式。

Return type:

整数

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

使用tiktoken包获取文本中存在的tokens。

Parameters:: 文本 (str)
Return type:: 列表[int]

invoke(input: LanguageModelInput, config: RunnableConfig | None = None, *, stop: list[str] | None = None, **kwargs: Any) → BaseMessage#

将单个输入转换为输出。重写以实现。

Parameters:

input (LanguageModelInput) – Runnable 的输入。
config (可选[RunnableConfig]) – 调用Runnable时使用的配置。该配置支持标准键，如用于跟踪目的的‘tags’、‘metadata’，用于控制并行工作量的‘max_concurrency’，以及其他键。更多详情请参考RunnableConfig。
stop (可选[列表[字符串]])
kwargs (Any)

Returns:

Runnable 的输出。

Return type:

BaseMessage

stream(input: LanguageModelInput, config: RunnableConfig | None = None, *, stop: list[str] | None = None, **kwargs: Any) → Iterator[BaseMessageChunk]#

流的默认实现，调用invoke。如果子类支持流输出，则应重写此方法。

Parameters:

input (LanguageModelInput) – Runnable 的输入。
config (可选[RunnableConfig]) – 用于Runnable的配置。默认为None。
kwargs (Any) – 传递给Runnable的额外关键字参数。
stop (可选[列表[字符串]])

Yields:

Runnable 的输出。

Return type:

迭代器[BaseMessageChunk]

with_alisteners(*, on_start: AsyncListener | None = None, on_end: AsyncListener | None = None, on_error: AsyncListener | None = None) → Runnable[Input, Output]#

将异步生命周期监听器绑定到一个Runnable，返回一个新的Runnable。

on_start: 在Runnable开始运行之前异步调用。 on_end: 在Runnable完成运行之后异步调用。 on_error: 如果Runnable抛出错误，则异步调用。

Run对象包含有关运行的信息，包括其id、类型、输入、输出、错误、开始时间、结束时间以及添加到运行中的任何标签或元数据。

Parameters:

on_start (Optional[AsyncListener]) – 在Runnable开始运行之前异步调用。默认为None。
on_end (Optional[AsyncListener]) – 在Runnable运行结束后异步调用。默认为None。
on_error (可选[AsyncListener]) – 如果Runnable抛出错误，则异步调用。默认为None。

Returns:

一个新的Runnable，绑定了监听器。

Return type:

Runnable[Input, Output]

示例：

from langchain_core.runnables import RunnableLambda
import time

async def test_runnable(time_to_sleep : int):
    print(f"Runnable[{time_to_sleep}s]: starts at {format_t(time.time())}")
    await asyncio.sleep(time_to_sleep)
    print(f"Runnable[{time_to_sleep}s]: ends at {format_t(time.time())}")

async def fn_start(run_obj : Runnable):
    print(f"on start callback starts at {format_t(time.time())}
    await asyncio.sleep(3)
    print(f"on start callback ends at {format_t(time.time())}")

async def fn_end(run_obj : Runnable):
    print(f"on end callback starts at {format_t(time.time())}
    await asyncio.sleep(2)
    print(f"on end callback ends at {format_t(time.time())}")

runnable = RunnableLambda(test_runnable).with_alisteners(
    on_start=fn_start,
    on_end=fn_end
)
async def concurrent_runs():
    await asyncio.gather(runnable.ainvoke(2), runnable.ainvoke(3))

asyncio.run(concurrent_runs())
Result:
on start callback starts at 2024-05-16T14:20:29.637053+00:00
on start callback starts at 2024-05-16T14:20:29.637150+00:00
on start callback ends at 2024-05-16T14:20:32.638305+00:00
on start callback ends at 2024-05-16T14:20:32.638383+00:00
Runnable[3s]: starts at 2024-05-16T14:20:32.638849+00:00
Runnable[5s]: starts at 2024-05-16T14:20:32.638999+00:00
Runnable[3s]: ends at 2024-05-16T14:20:35.640016+00:00
on end callback starts at 2024-05-16T14:20:35.640534+00:00
Runnable[5s]: ends at 2024-05-16T14:20:37.640169+00:00
on end callback starts at 2024-05-16T14:20:37.640574+00:00
on end callback ends at 2024-05-16T14:20:37.640654+00:00
on end callback ends at 2024-05-16T14:20:39.641751+00:00

with_config(config: RunnableConfig | None = None, **kwargs: Any) → Runnable[Input, Output]#

将配置绑定到一个可运行对象，返回一个新的可运行对象。

Parameters:

config (RunnableConfig | None) – 绑定到Runnable的配置。
kwargs (Any) – 传递给Runnable的额外关键字参数。

Returns:

一个新的Runnable，带有绑定的配置。

Return type:

Runnable[Input, Output]

with_fallbacks(fallbacks: Sequence[Runnable[Input, Output]], *, exceptions_to_handle: tuple[type[BaseException], ...] = (<class 'Exception'>,), exception_key: Optional[str] = None) → RunnableWithFallbacksT[Input, Output]#

为Runnable添加回退，返回一个新的Runnable。

新的Runnable将尝试原始的Runnable，然后在失败时依次尝试每个回退。

Parameters:

fallbacks (Sequence[Runnable[Input, Output]]) – 如果原始 Runnable 失败，将尝试的一系列 runnables。
exceptions_to_handle (tuple[type[BaseException], ...]) – 要处理的异常类型的元组。默认为 (Exception,)。
exception_key (Optional[str]) – 如果指定了字符串，则处理的异常将作为输入的一部分传递给后备函数，使用指定的键。如果为 None，异常将不会传递给后备函数。如果使用此参数，基础 Runnable 及其后备函数必须接受字典作为输入。默认为 None。

Returns:

一个新的Runnable，它将在失败时尝试原始的Runnable，然后依次尝试每个回退。

Return type:

RunnableWithFallbacksT[Input, Output]

示例

from typing import Iterator

from langchain_core.runnables import RunnableGenerator


def _generate_immediate_error(input: Iterator) -> Iterator[str]:
    raise ValueError()
    yield ""


def _generate(input: Iterator) -> Iterator[str]:
    yield from "foo bar"


runnable = RunnableGenerator(_generate_immediate_error).with_fallbacks(
    [RunnableGenerator(_generate)]
    )
print(''.join(runnable.stream({}))) #foo bar

Parameters:

fallbacks (Sequence[Runnable[Input, Output]]) – 如果原始 Runnable 失败，将尝试的一系列 runnables。
exceptions_to_handle (tuple[type[BaseException], ...]) – 要处理的异常类型的元组。
exception_key (Optional[str]) – 如果指定了字符串，则处理的异常将作为输入的一部分传递给后备函数，使用指定的键。如果为 None，异常将不会传递给后备函数。如果使用此参数，基础 Runnable 及其后备函数必须接受字典作为输入。

Returns:

一个新的Runnable，它将在失败时尝试原始的Runnable，然后依次尝试每个回退。

Return type:

RunnableWithFallbacksT[Input, Output]

with_listeners(*, on_start: Callable[[Run], None] | Callable[[Run, RunnableConfig], None] | None = None, on_end: Callable[[Run], None] | Callable[[Run, RunnableConfig], None] | None = None, on_error: Callable[[Run], None] | Callable[[Run, RunnableConfig], None] | None = None) → Runnable[Input, Output]#

将生命周期监听器绑定到一个Runnable，返回一个新的Runnable。

on_start: 在Runnable开始运行之前调用，带有Run对象。 on_end: 在Runnable完成运行之后调用，带有Run对象。 on_error: 如果Runnable抛出错误时调用，带有Run对象。

Run对象包含有关运行的信息，包括其id、类型、输入、输出、错误、开始时间、结束时间以及添加到运行中的任何标签或元数据。

Parameters:

on_start (可选[联合[可调用[[运行], 无], 可调用[[运行, RunnableConfig], 无]]]) – 在Runnable开始运行之前调用。默认为无。
on_end (可选[联合[可调用[[运行], 无], 可调用[[运行, RunnableConfig], 无]]]) – 在Runnable完成运行后调用。默认为无。
on_error (可选[联合[可调用[[运行], 无], 可调用[[运行, RunnableConfig], 无]]]) – 如果Runnable抛出错误时调用。默认为无。

Returns:

一个新的Runnable，绑定了监听器。

Return type:

Runnable[Input, Output]

示例：

from langchain_core.runnables import RunnableLambda
from langchain_core.tracers.schemas import Run

import time

def test_runnable(time_to_sleep : int):
    time.sleep(time_to_sleep)

def fn_start(run_obj: Run):
    print("start_time:", run_obj.start_time)

def fn_end(run_obj: Run):
    print("end_time:", run_obj.end_time)

chain = RunnableLambda(test_runnable).with_listeners(
    on_start=fn_start,
    on_end=fn_end
)
chain.invoke(2)

with_retry(*, retry_if_exception_type: tuple[type[BaseException], ...] = (<class 'Exception'>,), wait_exponential_jitter: bool = True, stop_after_attempt: int = 3) → Runnable[Input, Output]#

创建一个新的Runnable，在异常时重试原始的Runnable。

Parameters:

retry_if_exception_type (tuple[type[BaseException], ...]) – 一个异常类型的元组，用于重试。默认值为 (Exception,)。
wait_exponential_jitter (bool) – 是否在重试之间的等待时间中添加抖动。默认为 True。
stop_after_attempt (int) – 在放弃之前尝试的最大次数。默认为3。

Returns:

一个新的Runnable，在异常时重试原始的Runnable。

Return type:

Runnable[Input, Output]

示例：

from langchain_core.runnables import RunnableLambda

count = 0


def _lambda(x: int) -> None:
    global count
    count = count + 1
    if x == 1:
        raise ValueError("x is 1")
    else:
         pass


runnable = RunnableLambda(_lambda)
try:
    runnable.with_retry(
        stop_after_attempt=2,
        retry_if_exception_type=(ValueError,),
    ).invoke(1)
except ValueError:
    pass

assert (count == 2)

Parameters:

retry_if_exception_type (tuple[type[BaseException], ...]) – 一个异常类型的元组，用于在发生这些异常时重试
wait_exponential_jitter (bool) – 是否在重试之间为等待时间添加抖动
stop_after_attempt (int) – 在放弃之前尝试的最大次数

Returns:

一个新的Runnable，在异常时重试原始的Runnable。

Return type:

Runnable[Input, Output]

模型包装器，返回格式化为匹配给定模式的输出。

Parameters:

schema (Dict[str, Any] | Type[_BM] | Type | None) –
输出模式。可以作为以下形式传入：
- 一个OpenAI函数/工具模式，
- 一个JSON模式，
- 一个TypedDict类（在0.1.20版本中添加了支持），
- 或一个Pydantic类。
如果schema是一个Pydantic类，那么模型输出将是该类的一个Pydantic实例，并且模型生成的字段将由Pydantic类进行验证。否则，模型输出将是一个字典，并且不会被验证。有关在指定Pydantic或TypedDict类时如何正确指定模式字段的类型和描述的更多信息，请参见langchain_core.utils.function_calling.convert_to_openai_tool()。
method (Literal['function_calling', 'json_mode', 'json_schema']) –
用于引导模型生成的方法，其中之一：
- ”function_calling”:
  使用OpenAI的工具调用（以前称为函数调用） API: https://platform.openai.com/docs/guides/function-calling
- ”json_schema”:
  使用OpenAI的结构化输出API: https://platform.openai.com/docs/guides/structured-outputs 支持“gpt-4o-mini”、“gpt-4o-2024-08-06”及之后的模型。
- ”json_mode”:
  使用OpenAI的JSON模式。请注意，如果使用JSON模式，则必须将格式化输出为所需模式的指令包含在模型调用中： https://platform.openai.com/docs/guides/structured-outputs/json-mode
了解更多关于这些方法之间的区别以及哪些模型支持哪些方法的信息：
- https://platform.openai.com/docs/guides/structured-outputs/structured-outputs-vs-json-mode
- https://platform.openai.com/docs/guides/structured-outputs/function-calling-vs-response-format
include_raw (bool) – 如果为False，则仅返回解析后的结构化输出。如果在模型输出解析过程中发生错误，将会抛出。如果为True，则返回原始模型响应（一个BaseMessage）和解析后的模型响应。如果在输出解析过程中发生错误，它将被捕获并返回。最终输出始终是一个包含“raw”、“parsed”和“parsing_error”键的字典。
strict (bool | None) –
- True:
  模型输出保证与模式完全匹配。输入模式也将根据 https://platform.openai.com/docs/guides/structured-outputs/supported-schemas 进行验证。
- False:
  输入模式将不会被验证，模型输出也不会被验证。
- None:
  strict 参数将不会传递给模型。
如果 method 是 “json_schema”，则默认为 True。如果 method 是 “function_calling” 或 “json_mode”，则默认为 None。只有在 method 是 “function_calling” 或 “json_schema” 时，才能为非空。
kwargs (Any) – 不支持额外的关键字参数。

Returns:

一个Runnable，它接受与langchain_core.language_models.chat.BaseChatModel相同的输入。

如果include_raw为False且schema是一个Pydantic类，Runnable输出一个schema的实例（即一个Pydantic对象）。否则，如果include_raw为False，则Runnable输出一个字典。

如果include_raw为True，则Runnable输出一个包含以下键的字典：

”raw”: BaseMessage
”parsed”: 如果存在解析错误则为None，否则类型取决于上述的schema。
”parsing_error”: Optional[BaseException]

Return type:

在版本0.1.20中更改：添加了对TypedDict类schema的支持。

在版本0.1.21中更改：添加了对strict参数的支持。添加了对method = “json_schema”的支持。

注意

计划在版本0.3.0中的重大变更

method 默认值将从
“function_calling” 更改为 “json_schema”。
strict 将在 method 为
“function_calling” 时默认为 True，自版本 0.3.0 起。

with_types(*, input_type: type[Input] | None = None, output_type: type[Output] | None = None) → Runnable[Input, Output]#

将输入和输出类型绑定到一个Runnable，返回一个新的Runnable。

Parameters:

input_type (type[Input] | None) – 要绑定到Runnable的输入类型。默认为None。
output_type (type[Output] | None) – 要绑定到Runnable的输出类型。默认为None。

Returns:

一个带有类型绑定的新Runnable。

Return type:

Runnable[Input, Output]