`langchain_community.chat_models.ollama`.ChatOllama¶

注意

ChatOllama实现了标准Runnable Interface。🏃

Runnable Interface具有额外的运行方法，例如with_types，with_retry，assign，bind，get_graph等。

class langchain_community.chat_models.ollama.ChatOllama[source]¶

基类: BaseChatModel, _OllamaCommon

Ollama在本地运行大型语言模型。

使用方法，请参阅https://ollama.ai/的说明。

示例

from langchain_community.chat_models import ChatOllama
ollama = ChatOllama(model="llama2")

param auth: Union[Callable, Tuple, None] = None¶: 额外的认证元组或可调用对象以启用基本/摘要/自定义HTTP认证。期望的格式、类型和值与requests.request的auth参数相同。

param base_url: str = 'http://localhost:11434'¶: 模型托管的基础 URL。

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

是否缓存响应。

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

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

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

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

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

参数format: 可选的 [str] = None¶: 指定输出格式（例如，json）

参数headers: 可选的 [dict] = None¶: 传递给端点（例如：Authorization, Referer）的附加头。当Ollama托管在需要令牌进行认证的云服务上时，这非常有用。

param keep_alive: 可选[联合[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: 可选[dict[str, Any]] = None¶: 添加到运行跟踪的元数据。

param mirostat: 可选[int] = None¶: 启用Mirostat采样以控制困惑度。（默认：0，0 = 禁用，1 = Mirostat，2 = Mirostat 2.0）

param mirostat_eta: 可选[float] = None¶: 影响算法对生成文本反馈的响应速度。较低的 learning rate 会导致调整速度较慢，而较高的 learning rate 将使算法更响应。（默认：0.1）

param mirostat_tau: 可选[float] = None¶: 控制输出之间的连贯性和多样性平衡。较低的值将导致文本更加集中和连贯。（默认：5.0）

param model: str = 'llama2'¶: 要使用的模型名称。

param num_ctx: 可选[int] = None¶: 设置生成下一个标记时使用的上下文窗口大小。（默认：2048）

param num_gpu: 可选[int] = None¶: 要使用的GPU数量。在macOS上默认为1以启用金属支持，0以禁用。

param num_predict: 可选[int] = None¶: 生成文本时预测的最大标记数。（默认：128，-1 = 无限生成，-2 = 填充上下文）

param num_thread: 可选[int] = None¶: 设置计算期间使用的线程数。默认情况下，Ollama会自动检测以实现最佳性能。建议将此值设置为系统物理CPU核心的数量（与逻辑核心数相比）。

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

param raw: 可选[bool] = None¶: 是否为原始数据。

参数 repeat_last_n: 可选[int] = None¶: 设置模型回退的时间范围以防止重复。（默认：64，0 = 禁用，-1 = num_ctx）

参数 repeat_penalty: 可选[float] = None¶: 设置对重复内容的惩罚力度。更高的值（例如，1.5）将更强烈地惩罚重复，而更低的值（例如，0.9）将更加宽容。（默认：1.1）

参数 stop: 可选[List[str] = None¶: 设置要使用的停止标记。

参数 system: 可选[str] = None¶: system 提示（覆盖 Modelfile中定义的内容）

参数 tags: 可选[List[str] = None¶: 要将的标签添加到运行跟踪中。

参数 temperature: 可选[float] = None¶: 模型的温度。增加温度将使模型回答更加有创意。（默认：0.8）

参数 template: 可选[str] = None¶: 完整的提示或提示模板（覆盖Modelfile中定义的内容）

参数 tfs_z: 可选[float] = None¶: 使用尾自由采样来减少输出中不太可能出现的标记的影响。更高的值（例如，2.0）将减少更多的影响，而1.0的值将禁用此设置。（默认：1）

参数 timeout: 可选[int] = None¶: 请求流的超时时间

参数 top_k: 可选[int] = None¶: 减少生成无意义内容的可能性。更高的值（例如，100）将提供更多样化的答案，而较低的值（例如，10）将更加保守。（默认：40）

参数 top_p: 可选[float] = None¶: 与top-k一起使用。更高的值（例如，0.95）将导致更多样化的文本，而较低的值（例如，0.5）将生成更专注和保守的文本。（默认：0.9）

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

__call__(messages: List[BaseMessage], stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, **kwargs: Any) → BaseMessage¶

自 langchain-core==0.1.7 版起始弃用：请使用 invoke 代替。

参数

messages (列表[BaseMessage]) –
stop (可选[列表[字符串]]) –
callbacks (可选[联合[列表[BaseCallbackHandler], BaseCallbackManager]]) –
kwargs (任何类型) –

返回类型

BaseMessage

async abatch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]¶

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

批量默认实现适合I/O密集型runnables。

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

参数

inputs（《输入列表》） – Runnable的输入列表。
config（《配置文件》） – 调用Runnable时使用的配置。配置支持如‘tags’、‘metadata’（用于跟踪目的）和‘max_concurrency’（用于控制并行工作数量）等标准键。请参阅RunnableConfig获取更多详细信息。默认为None。
return_exceptions（《是否返回异常》） – 是否返回异常而不是引发它们。默认为False。
kwargs（《额外键值对》） – 传递给Runnable的额外关键字参数。

返回

Runnable的输出列表。

返回类型

《输出列表》

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

并行执行run_invoke在一系列输入上，随着它们的完成返回结果。

参数

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

生成

输入索引和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¶

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

该方法应适用于支持批量调用的模型。

当需要以下功能时使用此方法：

利用批量调用，
需要模型输出的不仅仅是顶级生成值，
正在构建对底层语言模型无感知的链。
类型（例如，纯文本完成模型与聊天模型）。

参数

消息（列表[[列表[[BaseMessage]]]） - 消息的列表。
stop（可选[[列表[[字符串]]]） - 生成时使用的停用词。模型输出在首次出现任何这些子字符串时截断。
callbacks（可选[[列表[[BaseCallbackHandler]]， BaseCallbackManager]]） - 传递的回调。用于在整个生成过程中执行附加功能，例如记录或流式传输。
**kwargs（任意） - 任意额外的关键字参数。这些通常传递给模型提供商API调用。
tags（可选[[列表[[字符串]]]） -
metadata（可选[[字典[[字符串，任何]]]） –
run_name（可选[[字符串]） –
run_id（可选[[UUID]） –
**kwargs –

返回

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

返回类型

LLMResult

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

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

该方法应适用于支持批量调用的模型。

当需要以下功能时使用此方法：

利用批量调用，
需要模型输出的不仅仅是顶级生成值，
正在构建对底层语言模型无感知的链。
类型（例如，纯文本完成模型与聊天模型）。

参数

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

返回

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

返回类型

LLMResult

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

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

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

子类应该在该方法中覆盖它，如果它们可以异步运行。

参数

input (LanguageModelInput) –
config (可选[RunnableConfig]) –
stop (可选[列表[字符串]]) –
kwargs (任何类型) –

返回类型

BaseMessage

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

从版本langchain-core==0.1.7以来已弃用：使用ainvoke代替。

参数

text (字符串) –
stop (可选[字符串序列[]) –
kwargs (任何类型) –

返回类型

字符串

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

从版本langchain-core==0.1.7以来已弃用：使用ainvoke代替。

参数

messages (列表[BaseMessage]) –
stop (可选[字符串序列[]) –
kwargs (任何类型) –

返回类型

BaseMessage

as_tool(args_schema: Optional[Type[BaseModel]], *, name: Optional[str] = None, description: Optional[str] = None, arg_types: Optional[Dict[str, Type]]) → BaseTool¶

测试版

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

从可运行的代码创建BaseTool。

as_tool将从Runnable中实例化一个BaseTool，包含名称、描述和args_schema。尽可能的情况下，从runnable.get_input_schema推断模式。或者（例如，如果Runnable接受字典作为输入且特定字典键未进行类型化），可以通过args_schema直接指定模式。您还可以通过arg_types只指定所需参数及其类型。

参数

args_schema (可选[类型[BaseModel]]) - 工具的模式。默认为None。
name (可选[字符串]) - 工具的名称。默认为None。
description (可选[字符串]) - 工具的描述。默认为None。
arg_types (可选[字典[字符串，类型]]) - 参数名称到类型的字典。默认为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: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[列表[字符串]] = None, **kwargs: 任何) → AsyncIterator[BaseMessageChunk]¶

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

参数

input (LanguageModelInput) - Runnable的输入。
config (可选[RunnableConfig]) - 使用Runnable的配置。默认为None。
kwargs (任何) - 传递给 Runnable 的附加关键字参数。
stop (可选[列表[字符串]]) –

生成

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

测试版

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

生成事件流。

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

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

event: 字符串 - 事件名称为以下格式：
format: on_[runnable_type]_(start|stream|end)。
name: 字符串 - 生成事件的 Runnable 的名称。
run_id: 字符串 - 与给定执行的 Runnable 相关的随机生成 ID。
一个作为父 Runnable 执行部分而被调用的子 Runnable 将分配其自己的唯一 ID。
parent_ids: 字符串列表 - 生成事件的父 runnable 的 ID。
根 Runnable 将具有空列表。父 ID 的顺序是从根到直接父级。仅适用于 API 的 v2 版本。API 的 v1 版本将返回空列表。
tags: 可选的字符串列表 - 生成事件的 Runnable 的标签。
。
metadata: 可选的 Dict[str, 任何] - 生成事件的 Runnable 的元数据。
。
data: 字典

以下是可能由各种链生成的一些事件的表格。为了简洁，省略了元数据字段。以下表格之后包含链定义。

注意此参考资料表是针对方案的 V2 版本。

事件	名称	块	输入	输出
on_chat_model_start	[模型名称]		{“消息”：[[系统消息，人的消息]]}
on_chat_model_stream	[模型名称]	AIMessageChunk(content="hello")
on_chat_model_end	[模型名称]		{“消息”：[[系统消息，人的消息]]}	AIMessageChunk(content="hello world")
on_llm_start	[模型名称]		{‘输入’：‘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		[文档(…)]	“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	[检索器名称]		{“查询”：，“hello”}
on_retriever_end	[检索器名称]		{“查询”：，“hello”}	[Document(…), ..]
on_prompt_start	[模板名称]		{“问题”：，“hello”}
on_prompt_end	[模板名称]		{“问题”：，“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)

参数

输入 (任何) - Runnable 的输入。
配置 (可选的[RunnableConfig]) - 用于 Runnable 的配置。
版本 (文字字符串['v1', 'v2']) – 指定使用的模式版本，可以是 v2 或 v1。用户应使用 v2。 v1 用于向后兼容，将在 0.4.0 版本中弃用。在 API 稳定之前，不会分配默认版本。自定义事件仅在 v2 中可见。
include_names (可选[字符串序列]) – 仅包括具有匹配名称的可运行事件。
include_types (可选[字符串序列]) – 仅包括具有匹配类型的可运行事件。
include_tags (可选[字符串序列]) – 仅包括具有匹配标签的可运行事件。
exclude_names (可选[字符串序列]) – 排除具有匹配名称的可运行事件。
exclude_types (可选[字符串序列]) – 排除具有匹配类型的可运行事件。
exclude_tags (可选[字符串序列]) – 排除具有匹配标签的可运行事件。
kwargs (任何类型) – 传递给 Runnable 的附加关键字参数。这些将传递给 astream_log，因为 astream_events 的实现基于 astream_log。

生成

异步 StreamEvents 流。

异常抛出

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

返回类型

异步迭代器[联合类型 [ StandardStreamEvent, CustomStreamEvent ]]

batch(inputs: List[Input], config: 可选[ RunnableConfig 或 RunnableConfig 列表 ]], return_exceptions: 布尔值 = False, kwargs: 可选[ 任何类型 ], 返回异常: Output 列表)¶

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

批量默认实现适合I/O密集型runnables。

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

参数

inputs (输入列表) –
config (可选[联合[RunnableConfig, List[RunnableConfig]]]) –
return_exceptions (布尔) –
kwargs (可选[任意]) –

返回类型

《输出列表》

batch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]],
参数: inputs (序列[输入]) –

config (可选[联合[RunnableConfig, 序列[RunnableConfig]]]) –

return_exceptions (布尔) –

kwargs (可选[任意]) –
返回类型: 迭代器[元组[整型, 联合[输出, Exception]]

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

参数

tools (Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]]) –
kwargs (任何类型) –

返回类型

Runnable[LanguageModelInput, BaseMessage]

call_as_llm(message: str, stop: Optional[List[str] 自 langchain-core==0.1.7 版起始弃用：请使用 invoke 代替。

langchain_community.chat_models.ollama.ChatOllama¶

使用 ChatOllama 的示例

`langchain_community.chat_models.ollama`.ChatOllama¶