langchain_experimental.llms.ollama_functions
.OllamaFunctions¶
Note
OllamaFunctions 实现了标准的 Runnable Interface
。 🏃
Runnable Interface
具有在可运行对象上可用的其他方法,例如 with_types
、 with_retry
、 assign
、 bind
、 get_graph
等。
- class langchain_experimental.llms.ollama_functions.OllamaFunctions[source]¶
Bases:
ChatOllama
Deprecated since version 0.0.64: Use
langchain_ollama.ChatOllama
instead.使用 Ollama API 的函数聊天模型。
- param auth: Union[Callable, Tuple, None] = None¶
用于启用 Basic/Digest/Custom HTTP Auth 的额外 auth 元组或可调用对象。 期望与 requests.request auth 参数相同的格式、类型和值。
- param base_url: str = 'http://localhost:11434'¶
模型托管的基本 URL。
- 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¶
用于计算令牌的可选编码器。
- param format: Optional[str] = None¶
指定输出格式(例如,json)
- param headers: Optional[dict] = None¶
要传递到端点的其他标头(例如,Authorization,Referer)。 当 Ollama 托管在需要令牌进行身份验证的云服务上时,这非常有用。
- param keep_alive: Optional[Union[int, str]] = None¶
模型在内存中保持加载的时间。
参数(默认值:5 分钟)可以设置为:1. Golang 中的持续时间字符串(例如“10m”或“24h”); 2. 以秒为单位的数字(例如 3600); 3. 任何负数,都将使模型保持加载在内存中(例如 -1 或“-1m”); 4. 0,它将在生成响应后立即卸载模型;
请参阅 [Ollama 文档](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-do-i-keep-a-model-loaded-in-memory-or-make-it-unload-immediately)
- param metadata: Optional[Dict[str, Any]] = None¶
要添加到运行轨迹的元数据。
- param mirostat: Optional[int] = None¶
启用 Mirostat 采样以控制困惑度。(默认值:0,0 = 禁用,1 = Mirostat,2 = Mirostat 2.0)
- param mirostat_eta: Optional[float] = None¶
影响算法对生成文本的反馈响应速度。 较低的学习率将导致较慢的调整,而较高的学习率将使算法更具响应性。 (默认值:0.1)
- param mirostat_tau: Optional[float] = None¶
控制输出的连贯性和多样性之间的平衡。 较低的值将导致更加集中和连贯的文本。 (默认值:5.0)
- param model: str = 'llama2'¶
要使用的模型名称。
- param num_ctx: Optional[int] = None¶
设置用于生成下一个令牌的上下文窗口的大小。 (默认值:2048)
- param num_gpu: Optional[int] = None¶
要使用的 GPU 数量。 在 macOS 上,它默认为 1 以启用金属支持,0 为禁用。
- param num_predict: Optional[int] = None¶
生成文本时要预测的最大令牌数。 (默认值:128,-1 = 无限生成,-2 = 填充上下文)
- param num_thread: Optional[int] = None¶
设置计算期间要使用的线程数。 默认情况下,Ollama 将检测到这一点以获得最佳性能。 建议将此值设置为系统具有的物理 CPU 核心数(而不是逻辑核心数)。
- param rate_limiter: Optional[BaseRateLimiter] = None¶
可选的速率限制器,用于限制请求数量。
- param raw: Optional[bool] = None¶
是否为 raw。
- param repeat_last_n: Optional[int] = None¶
设置模型回溯以防止重复的距离。 (默认值:64,0 = 禁用,-1 = num_ctx)
- param repeat_penalty: Optional[float] = None¶
设置惩罚重复的强度。 较高的值(例如,1.5)将更强烈地惩罚重复,而较低的值(例如,0.9)将更加宽松。 (默认值:1.1)
- param stop: Optional[List[str]] = None¶
设置要使用的停止令牌。
- param system: Optional[str] = None¶
系统提示(覆盖 Modelfile 中定义的提示)
- param tags: Optional[List[str]] = None¶
要添加到运行轨迹的标签。
- param temperature: Optional[float] = None¶
模型的温度。 增加温度将使模型更具创造性地回答。 (默认值:0.8)
- param template: Optional[str] = None¶
完整提示或提示模板(覆盖 Modelfile 中定义的提示)
- param tfs_z: Optional[float] = None¶
尾部自由采样用于减少输出中不太可能出现的令牌的影响。 较高的值(例如,2.0)将更多地减少影响,而值 1.0 将禁用此设置。 (默认值:1)
- param timeout: Optional[int] = None¶
请求流的超时
- param tool_system_prompt_template: str = 'You have access to the following tools:\n\n{tools}\n\nYou must always select one of the above tools and respond with only a JSON object matching the following schema:\n\n{{\n "tool": <name of the selected tool>,\n "tool_input": <parameters for the selected tool, matching the tool\'s JSON schema>\n}}\n'¶
- param top_k: Optional[int] = None¶
降低生成无意义内容的可能性。 较高的值(例如 100)将提供更多样化的答案,而较低的值(例如 10)将更加保守。 (默认值:40)
- param top_p: Optional[float] = None¶
与 top-k 一起使用。 较高的值(例如 0.95)将导致更多样化的文本,而较低的值(例如 0.5)将生成更集中和保守的文本。 (默认值:0.9)
- param verbose [Optional]¶
是否打印出响应文本。
- __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) –
- 返回类型
- 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 绑定的 runnables。
如果子类可以更有效地进行批量处理,则应覆盖此方法;例如,如果底层的 Runnable 使用了支持批量模式的 API。
- 参数
inputs (List[Input]) – Runnable 的输入列表。
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) – 调用 Runnable 时使用的配置。该配置支持标准键,如 ‘tags’、‘metadata’ 用于跟踪目的,‘max_concurrency’ 用于控制并行执行的工作量,以及其他键。有关更多详细信息,请参阅 RunnableConfig。默认为 None。
return_exceptions (bool) – 是否返回异常而不是引发异常。默认为 False。
kwargs (Optional[Any]) – 传递给 Runnable 的其他关键字参数。
- 返回
来自 Runnable 的输出列表。
- 返回类型
List[Output]
- async abatch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) AsyncIterator[Tuple[int, Union[Output, Exception]]] ¶
并行运行列表中输入的 ainvoke,并在结果完成时生成结果。
- 参数
inputs (Sequence[Input]) – Runnable 的输入列表。
config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) – 调用 Runnable 时使用的配置。该配置支持标准键,如 ‘tags’、‘metadata’ 用于跟踪目的,‘max_concurrency’ 用于控制并行执行的工作量,以及其他键。有关更多详细信息,请参阅 RunnableConfig。默认为 None。默认为 None。
return_exceptions (bool) – 是否返回异常而不是引发异常。默认为 False。
kwargs (Optional[Any]) – 传递给 Runnable 的其他关键字参数。
- Yields
输入索引和来自 Runnable 的输出的元组。
- 返回类型
AsyncIterator[Tuple[int, Union[Output, Exception]]]
- 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,其中包含每个输入的候选 Generations 列表
提示和附加的模型提供商特定的输出。
- 返回类型
- 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,其中包含每个输入的候选 Generations 列表
提示和附加的模型提供商特定的输出。
- 返回类型
- 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) –
- 返回类型
- 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) –
- 返回类型
- 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 (Optional[Type[BaseModel]]) – 工具的模式。默认为 None。
name (Optional[str]) – 工具的名称。默认为 None。
description (Optional[str]) – 工具的描述。默认为 None。
arg_types (Optional[Dict[str, Type]]) – 参数名称到类型的字典。默认为 None。
- 返回
一个 BaseTool 实例。
- 返回类型
Typed dict input
from typing import List from typing_extensions import TypedDict from langchain_core.runnables import RunnableLambda class Args(TypedDict): a: int b: List[int] def f(x: Args) -> str: return str(x["a"] * max(x["b"])) runnable = RunnableLambda(f) as_tool = runnable.as_tool() as_tool.invoke({"a": 3, "b": [1, 2]})
dict
输入,通过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]})
String input
from langchain_core.runnables import RunnableLambda def f(x: str) -> str: return x + "a" def g(x: str) -> str: return x + "z" runnable = RunnableLambda(f) | g as_tool = runnable.as_tool() as_tool.invoke("b")
0.2.14 版本新增功能。
- async astream(input: 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 - 事件名称的格式为格式:on_[runnable_type]_(start|stream|end)。
name
:str - 生成事件的 Runnable 的名称。run_id
:str - 随机生成的 ID,与给定 Runnable 的执行相关联,该 Runnable 发出了事件。作为父 Runnable 执行的一部分而被调用的子 Runnable 将被分配其自己唯一的 ID。Runnable 发出事件的给定执行的随机生成 ID。作为父 Runnable 执行一部分调用的子 Runnable 会被分配其自己的唯一 ID。
parent_ids
:List[str] - 生成事件的父 runnables 的 ID。根 Runnable 将有一个空列表。父 ID 的顺序是从根到直接父级。仅适用于 API 的 v2 版本。API 的 v1 版本将返回一个空列表。
tags
:Optional[List[str]] - 生成事件的 Runnable 的标签。事件。
metadata
:Optional[Dict[str, Any]] - Runnable 的元数据生成了事件。
data
:Dict[str, Any]
下面是一个表格,说明了各种链可能发出的一些事件。为了简洁起见,表格中省略了元数据字段。链定义已包含在表格之后。
注意 此参考表适用于 V2 版本的架构。
event
name
chunk
input
output
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
[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}
prompt:
template = ChatPromptTemplate.from_messages( [("system", "You are Cat Agent 007"), ("human", "{question}")] ).with_config({"run_name": "my_template", "tags": ["my_template"]})
示例
from langchain_core.runnables import RunnableLambda async def reverse(s: str) -> str: return s[::-1] chain = RunnableLambda(func=reverse) events = [ event async for event in chain.astream_events("hello", version="v2") ] # will produce the following events (run_id, and parent_ids # has been omitted for brevity): [ { "data": {"input": "hello"}, "event": "on_chain_start", "metadata": {}, "name": "reverse", "tags": [], }, { "data": {"chunk": "olleh"}, "event": "on_chain_stream", "metadata": {}, "name": "reverse", "tags": [], }, { "data": {"output": "olleh"}, "event": "on_chain_end", "metadata": {}, "name": "reverse", "tags": [], }, ]
示例:分派自定义事件
from langchain_core.callbacks.manager import ( adispatch_custom_event, ) from langchain_core.runnables import RunnableLambda, RunnableConfig import asyncio async def slow_thing(some_input: str, config: RunnableConfig) -> str: """Do something that takes a long time.""" await asyncio.sleep(1) # Placeholder for some slow operation await adispatch_custom_event( "progress_event", {"message": "Finished step 1 of 3"}, config=config # Must be included for python < 3.10 ) await asyncio.sleep(1) # Placeholder for some slow operation await adispatch_custom_event( "progress_event", {"message": "Finished step 2 of 3"}, config=config # Must be included for python < 3.10 ) await asyncio.sleep(1) # Placeholder for some slow operation return "Done" slow_thing = RunnableLambda(slow_thing) async for event in slow_thing.astream_events("some_input", version="v2"): print(event)
- 参数
input (Any) – Runnable 的输入。
config (Optional[RunnableConfig]) – 用于 Runnable 的配置。
version (Literal['v1', 'v2']) – 要使用的架构版本,v2 或 v1。用户应使用 v2。v1 用于向后兼容,将在 0.4.0 中弃用。在 API 稳定之前,不会分配默认值。自定义事件将仅在 v2 中显示。
include_names (Optional[Sequence[str]]) – 仅包括来自具有匹配名称的 runnables 的事件。
include_types (Optional[Sequence[str]]) – 仅包括来自具有匹配类型的 runnables 的事件。
include_tags (Optional[Sequence[str]]) – 仅包括来自具有匹配标签的 runnables 的事件。
exclude_names (Optional[Sequence[str]]) – 排除来自具有匹配名称的 runnables 的事件。
exclude_types (Optional[Sequence[str]]) – 排除来自具有匹配类型的 runnables 的事件。
exclude_tags (Optional[Sequence[str]]) – 排除来自具有匹配标签的 runnables 的事件。
kwargs (Any) – 要传递给 Runnable 的其他关键字参数。这些将传递给 astream_log,因为 astream_events 的此实现构建在 astream_log 之上。
- Yields
StreamEvents 的异步流。
- Raises
NotImplementedError – 如果版本不是 v1 或 v2。
- 返回类型
AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]
- batch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) List[Output] ¶
默认实现使用线程池执行器并行运行 invoke。
batch 的默认实现非常适合 IO 绑定的 runnables。
如果子类可以更有效地进行批量处理,则应覆盖此方法;例如,如果底层的 Runnable 使用了支持批量模式的 API。
- 参数
inputs (List[Input]) –
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) –
return_exceptions (bool) –
kwargs (Optional[Any]) –
- 返回类型
List[Output]
- batch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) Iterator[Tuple[int, Union[Output, Exception]]] ¶
在输入列表上并行运行 invoke,并在完成时产生结果。
- 参数
inputs (Sequence[Input]) –
config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) –
return_exceptions (bool) –
kwargs (Optional[Any]) –
- 返回类型
Iterator[Tuple[int, Union[Output, Exception]]]
- bind_tools(tools: Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]], **kwargs: Any) Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]], BaseMessage] [source]¶
- 参数
tools (Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]]) –
kwargs (Any) –
- 返回类型
Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], 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) –
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] ¶
配置可在运行时设置的 Runnables 的备选项。
- 参数
which (ConfigurableField) – 将用于选择备选项的 ConfigurableField 实例。
default_key (str) – 如果未选择任何备选项,则使用的默认键。默认为 “default”。
prefix_keys (bool) – 是否使用 ConfigurableField id 作为键的前缀。默认为 False。
**kwargs (Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) – 键到 Runnable 实例或返回 Runnable 实例的可调用对象的字典。
- 返回
配置了备选项的新 Runnable。
- 返回类型
RunnableSerializable[Input, Output]
from langchain_anthropic import ChatAnthropic from langchain_core.runnables.utils import ConfigurableField from langchain_openai import ChatOpenAI model = ChatAnthropic( model_name="claude-3-sonnet-20240229" ).configurable_alternatives( ConfigurableField(id="llm"), default_key="anthropic", openai=ChatOpenAI() ) # uses the default model ChatAnthropic print(model.invoke("which organization created you?").content) # uses ChatOpenAI print( model.with_config( configurable={"llm": "openai"} ).invoke("which organization created you?").content )
- configurable_fields(**kwargs: Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) RunnableSerializable[Input, Output] ¶
在运行时配置特定的 Runnable 字段。
- 参数
**kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – 要配置的 ConfigurableField 实例的字典。
- 返回
配置了字段的新 Runnable。
- 返回类型
RunnableSerializable[Input, Output]
from langchain_core.runnables import ConfigurableField from langchain_openai import ChatOpenAI model = ChatOpenAI(max_tokens=20).configurable_fields( max_tokens=ConfigurableField( id="output_token_number", name="Max tokens in the output", description="The maximum number of tokens in the output", ) ) # max_tokens = 20 print( "max_tokens_20: ", model.invoke("tell me something about chess").content ) # max_tokens = 200 print("max_tokens_200: ", model.with_config( configurable={"output_token_number": 200} ).invoke("tell me something about chess").content )
- 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 ¶
将提示序列传递给模型并返回模型生成结果。
此方法应利用模型的批量调用来公开批量 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,其中包含每个输入的候选 Generations 列表
提示和附加的模型提供商特定的输出。
- 返回类型
- generate_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,其中包含每个输入的候选 Generations 列表
提示和附加的模型提供商特定的输出。
- 返回类型
- get_num_tokens(text: str) int ¶
获取文本中存在的 token 数量。
用于检查输入是否适合模型的上下文窗口。
- 参数
text (str) – 要进行 token 化的字符串输入。
- 返回
文本中 token 的整数数量。
- 返回类型
int
- get_num_tokens_from_messages(messages: List[BaseMessage]) int ¶
获取消息中的 token 数量。
用于检查输入是否适合模型的上下文窗口。
- 参数
messages (List[BaseMessage]) – 要进行 token 化的消息输入。
- 返回
消息中 token 数量的总和。
- 返回类型
int
- get_token_ids(text: str) List[int] ¶
返回文本中 token 的有序 ID。
- 参数
text (str) – 要进行 token 化的字符串输入。
- 返回
- 与文本中的 token 相对应的 ID 列表,按它们在文本中出现的顺序排列
在文本中。
- 返回类型
List[int]
- invoke(input: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) BaseMessage ¶
将单个输入转换为输出。覆盖以实现。
- 参数
input (LanguageModelInput) – Runnable 的输入。
config (Optional[RunnableConfig]) – 调用 Runnable 时要使用的配置。该配置支持用于跟踪目的的标准键,例如“tags”,“metadata”,用于控制并行执行量的“max_concurrency”以及其他键。有关更多详细信息,请参阅 RunnableConfig。
stop (Optional[List[str]]) –
kwargs (Any) –
- 返回
Runnable 的输出。
- 返回类型
- 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) –
- 返回类型
- stream(input: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) Iterator[BaseMessageChunk] ¶
stream 的默认实现,它调用 invoke。如果子类支持流式输出,则应重写此方法。
- 参数
input (LanguageModelInput) – Runnable 的输入。
config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。
kwargs (Any) – 传递给 Runnable 的其他关键字参数。
stop (Optional[List[str]]) –
- Yields
Runnable 的输出。
- 返回类型
Iterator[BaseMessageChunk]
- to_json() Union[SerializedConstructor, SerializedNotImplemented] ¶
将 Runnable 序列化为 JSON。
- 返回
Runnable 的 JSON 可序列化表示形式。
- 返回类型
- with_structured_output(schema: Union[Dict, Type[BaseModel]], *, include_raw: bool = False, **kwargs: Any) Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict]]], Union[Dict, BaseModel]] [source]¶
模型包装器,返回格式化为匹配给定模式的输出。
- 参数
schema (Union[Dict, Type[BaseModel]]) – 作为 dict 或 Pydantic 类的输出模式。如果为 Pydantic 类,则模型输出将是该类的对象。如果为 dict,则模型输出将是 dict。对于 Pydantic 类,返回的属性将被验证,而对于 dict 则不会。
include_raw (bool) – 如果为 False,则仅返回解析后的结构化输出。如果在模型输出解析期间发生错误,将引发该错误。如果为 True,则将返回原始模型响应 (BaseMessage) 和解析后的模型响应。如果在输出解析期间发生错误,则会捕获该错误并也返回。最终输出始终是一个包含键 “raw”、“parsed” 和 “parsing_error” 的 dict。
kwargs (Any) –
- 返回
- 如果 include_raw 为 True,则返回一个包含键的 dict
raw: BaseMessage parsed: Optional[_DictOrPydantic] parsing_error: Optional[BaseException]
如果 include_raw 为 False,则仅返回 _DictOrPydantic,其中 _DictOrPydantic 取决于模式
- 如果 schema 是 Pydantic 类,则 _DictOrPydantic 是 Pydantic
类。
如果 schema 是 dict,则 _DictOrPydantic 是 dict。
- 返回类型
一个 Runnable,它接受任何 ChatModel 输入并返回作为输出
- 示例:Pydantic 模式 (include_raw=False)
from langchain_experimental.llms import OllamaFunctions 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 = OllamaFunctions(model="phi3", format="json", 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.' # )
- 示例:Pydantic 模式 (include_raw=True)
from langchain_experimental.llms import OllamaFunctions 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 = OllamaFunctions(model="phi3", format="json", 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 # }
- 示例:dict 模式 (method=”include_raw=False)
from langchain_experimental.llms import OllamaFunctions, convert_to_ollama_tool 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 dict_schema = convert_to_ollama_tool(AnswerWithJustification) llm = OllamaFunctions(model="phi3", format="json", 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.' # }