`langchain_community.chat_models.minimax`.MiniMaxChat¶

注意

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

Runnable 接口 具有在 runnables 上可用的其他方法，例如 with_types, with_retry, assign, bind, get_graph 等。

class langchain_community.chat_models.minimax.MiniMaxChat[source]¶

基类: BaseChatModel

MiniMax 聊天模型集成。

设置: 要使用，您应该设置环境变量 ``MINIMAX_API_KEY``，其中包含

您的 API 密钥。

export MINIMAX_API_KEY="your-api-key"

关键初始化参数 — 完成参数

model: Optional[str]: 要使用的 MiniMax 模型的名称。
max_tokens: Optional[int]: 要生成的最大 token 数。
temperature: Optional[float]: 采样温度。
top_p: Optional[float]: 每步要考虑的 token 的总概率质量。
streaming: Optional[bool]: 是否流式传输结果。

关键初始化参数 — 客户端参数

api_key: Optional[str]: MiniMax API 密钥。如果未传入，则将从环境变量 MINIMAX_API_KEY 中读取。
base_url: Optional[str]: API 请求的基础 URL。

请参阅参数部分中受支持的初始化参数及其描述的完整列表。

实例化

from langchain_community.chat_models import MiniMaxChat

chat = MiniMaxChat(
    api_key=api_key,
    model='abab6.5-chat',
    # temperature=...,
    # other params...
)

调用

messages = [
    ("system", "你是一名专业的翻译家，可以将用户的中文翻译为英文。"),
    ("human", "我喜欢编程。"),
]
chat.invoke(messages)

AIMessage(
    content='I enjoy programming.',
    response_metadata={
        'token_usage': {'total_tokens': 48},
        'model_name': 'abab6.5-chat',
        'finish_reason': 'stop'
    },
    id='run-42d62ba6-5dc1-4e16-98dc-f72708a4162d-0'
)

流式传输

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

content='I' id='run-a5837c45-4aaa-4f64-9ab4-2679bbd55522'
content=' enjoy programming.' response_metadata={'finish_reason': 'stop'} id='run-a5837c45-4aaa-4f64-9ab4-2679bbd55522'

stream = chat.stream(messages)
full = next(stream)
for chunk in stream:
    full += chunk
full

AIMessageChunk(
    content='I enjoy programming.',
    response_metadata={'finish_reason': 'stop'},
    id='run-01aed0a0-61c4-4709-be22-c6d8b17155d6'
)

异步

await chat.ainvoke(messages)

# stream
# async for chunk in chat.astream(messages):
#     print(chunk)

# batch
# await chat.abatch([messages])

AIMessage(
    content='I enjoy programming.',
    response_metadata={
        'token_usage': {'total_tokens': 48},
        'model_name': 'abab6.5-chat',
        'finish_reason': 'stop'
    },
    id='run-c263b6f1-1736-4ece-a895-055c26b3436f-0'
)

工具调用

from langchain_core.pydantic_v1 import BaseModel, Field


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

chat_with_tools = chat.bind_tools([GetWeather, GetPopulation])
ai_msg = chat_with_tools.invoke(
    "Which city is hotter today and which is bigger: LA or NY?"
)
ai_msg.tool_calls

[
    {
        'name': 'GetWeather',
        'args': {'location': 'LA'},
        'id': 'call_function_2140449382',
        'type': 'tool_call'
    }
]

结构化输出

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_chat = chat.with_structured_output(Joke)
structured_chat.invoke("Tell me a joke about cats")

Joke(
    setup='Why do cats have nine lives?',
    punchline='Because they are so cute and cuddly!',
    rating=None
)

响应元数据

ai_msg = chat.invoke(messages)
ai_msg.response_metadata

{'token_usage': {'total_tokens': 48},
 'model_name': 'abab6.5-chat',
 'finish_reason': 'stop'}

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

是否缓存响应。

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

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

param callback_manager: Optional[BaseCallbackManager] = None¶: [已弃用] 要添加到运行跟踪的回调管理器。

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

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

param max_tokens: int = 256¶: 表示每次生成要预测的 token 数量。

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

param minimax_api_host: str = 'https://api.minimax.chat/v1/text/chatcompletion_v2' （别名 'base_url'）¶

param minimax_api_key: SecretStr [必需] （别名 'api_key'）¶

Minimax API 密钥

约束

type = string
writeOnly = True
format = password

param minimax_group_id: Optional[str] = None （别名 'group_id'）¶: [已弃用，为了向后兼容而保留] Group Id

param model: str = 'abab6.5-chat'¶

要使用的模型名称。

param model_kwargs: Dict[str, Any]] [可选]¶

包含 create 调用有效的任何模型参数，但未明确指定。

param rate_limiter: Optional[BaseRateLimiter] = None¶

可选的速率限制器，用于限制请求数量。

param streaming: bool = False¶

是否流式传输结果。

param tags: Optional[List[str]] = None¶

要添加到运行跟踪的标签。

param temperature: float = 0.7¶

一个非负浮点数，用于调整生成中的随机程度。

param top_p: float = 0.95¶

每步要考虑的 token 的总概率质量。

param verbose [可选]¶

是否打印输出响应文本。

__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) –

返回类型

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。

批处理的默认实现非常适合 IO 绑定的 runnable。

如果子类可以更有效地进行批处理，则应覆盖此方法；例如，如果底层 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 列表
提示和额外的模型提供商特定的输出。

返回类型

LLMResult

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 是一个可以转换为匹配任何语言模型格式的对象（纯文本生成模型的字符串和聊天模型的基础消息）。

stop (Optional[List[str]]) – 生成时要使用的停止词。模型输出在首次出现任何这些子字符串时被截断。

callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能，例如日志记录或流式传输。

**kwargs (Any) – 任意其他关键字参数。这些通常传递给模型提供商 API 调用。

返回值

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

返回类型

LLMResult

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

返回类型

BaseMessage

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

Deprecated since version langchain-core==0.1.7: 自 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: 自 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 接受 dict 作为输入且未键入特定的 dict 键），可以使用 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 实例。

返回类型

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 input, specifying schema via args_schema

from typing import Any, Dict, List from langchain_core.pydantic_v1 import BaseModel, Field from langchain_core.runnables import RunnableLambda def f(x: Dict[str, Any]) -> str: return str(x["a"] * max(x["b"])) class FSchema(BaseModel): """Apply a function to an integer and list of integers.""" a: int = Field(..., description="Integer") b: List[int] = Field(..., description="List of ints") runnable = RunnableLambda(f) as_tool = runnable.as_tool(FSchema) as_tool.invoke({"a": 3, "b": [1, 2]})

dict input, specifying schema via arg_types

from typing import Any, Dict, List from langchain_core.runnables import RunnableLambda def f(x: Dict[str, Any]) -> str: return str(x["a"] * max(x["b"])) runnable = RunnableLambda(f) as_tool = runnable.as_tool(arg_types={"a": int, "b": List[int]}) as_tool.invoke({"a": 3, "b": [1, 2]})

String input

from langchain_core.runnables import RunnableLambda def f(x: str) -> str: return x + "a" def g(x: str) -> str: return x + "z" runnable = RunnableLambda(f) | g as_tool = runnable.as_tool() as_tool.invoke("b")

New in version 0.2.14.

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 将被分配其自己的唯一 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

[model name]

{“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

[model name]

‘Hello’

on_llm_end

[model name]

‘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 版本中显示！

自定义事件具有以下格式

Attribute

Type

Description

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

Example

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。

批处理的默认实现非常适合 IO 绑定的 runnable。

如果子类可以更有效地进行批处理，则应覆盖此方法；例如，如果底层 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]]) – 要绑定到此聊天模型的工具定义列表。可以是字典、Pydantic 模型、可调用对象或 BaseTool。Pydantic 模型、可调用对象和 BaseTool 将自动转换为其模式字典表示形式。

**kwargs (Any) – 传递给 :class: ~langchain.runnable.Runnable 构造函数的任何其他参数。

返回类型

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 列表
提示和额外的模型提供商特定的输出。

返回类型

LLMResult

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 是一个可以转换为匹配任何语言模型格式的对象（纯文本生成模型的字符串和聊天模型的基础消息）。

stop (Optional[List[str]]) – 生成时要使用的停止词。模型输出在首次出现任何这些子字符串时被截断。

callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 要传递的回调。用于在整个生成过程中执行额外的功能，例如日志记录或流式传输。

**kwargs (Any) – 任意其他关键字参数。这些通常传递给模型提供商 API 调用。

返回值

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

返回类型

LLMResult

get_num_tokens(text: str) → int¶

获取文本中存在的 token 数量。

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

参数

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

返回值

文本中的 token 整数数量。

返回类型

int

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

获取消息中的 token 数量。

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

参数

messages (List[BaseMessage]) – 要分词的消息输入。

返回值

消息中 token 数量的总和。

返回类型

int

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

返回文本中 token 的有序 ID。

参数

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

返回值

与文本中的 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 的输出。

返回类型

BaseMessage

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

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

参数

text (str) –

stop (Optional[Sequence[str]]) –

kwargs (Any) –

返回类型

str

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

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

参数

messages (List[BaseMessage]) –

stop (Optional[Sequence[str]]) –

kwargs (Any) –

返回类型

BaseMessage

stream(input: LanguageModelInput, config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) → Iterator[BaseMessageChunk]¶

流式处理的默认实现，它调用 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 可序列化表示形式。

返回类型

Union[SerializedConstructor, SerializedNotImplemented]

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[str, Any]]]], Union[Dict, BaseModel]][source]¶

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

参数

schema (Union[Dict, Type[BaseModel]]) – 作为字典或 Pydantic 类的输出模式。如果为 Pydantic 类，则模型输出将是该类的对象。如果为字典，则模型输出将是字典。使用 Pydantic 类，返回的属性将经过验证，而使用字典则不会。如果 method 是 “function_calling” 并且 schema 是字典，则该字典必须符合 OpenAI function-calling 规范。

include_raw (bool) – 如果为 False，则仅返回解析后的结构化输出。如果在模型输出解析期间发生错误，将引发该错误。如果为 True，则将返回原始模型响应 (BaseMessage) 和解析后的模型响应。如果在输出解析期间发生错误，则会捕获该错误并也返回。最终输出始终是一个字典，其中包含键 “raw”、“parsed” 和 “parsing_error”。

kwargs (Any) –

返回值

如果 include_raw 为 True，则返回一个带有以下键的字典
raw: BaseMessage parsed: Optional[_DictOrPydantic] parsing_error: Optional[BaseException]

如果 include_raw 为 False，则仅返回 _DictOrPydantic，其中 _DictOrPydantic 取决于模式

如果 schema 是 Pydantic 类，则 _DictOrPydantic 是 Pydantic
类。

如果 schema 是字典，则 _DictOrPydantic 是字典。

返回类型

一个 Runnable，它接受任何 ChatModel 输入并返回作为输出

示例：函数调用，Pydantic 模式 (method=”function_calling”, include_raw=False)
from langchain_community.chat_models import MiniMaxChat 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 = MiniMaxChat() structured_llm = llm.with_structured_output(AnswerWithJustification) structured_llm.invoke("What weighs more a pound of bricks or a pound of feathers") # -> AnswerWithJustification( # answer='A pound of bricks and a pound of feathers weigh the same.', # justification='The weight of the feathers is much less dense than the weight of the bricks, but since both weigh one pound, they weigh the same.' # )

示例：函数调用，Pydantic 模式 (method=”function_calling”, include_raw=True)
from langchain_community.chat_models import MiniMaxChat 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 = MiniMaxChat() 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_function_8953642285', 'type': 'function', 'function': {'name': 'AnswerWithJustification', 'arguments': '{"answer": "A pound of bricks and a pound of feathers weigh the same.", "justification": "The weight of the feathers is much less dense than the weight of the bricks, but since both weigh one pound, they weigh the same."}'}}]}, response_metadata={'token_usage': {'total_tokens': 257}, 'model_name': 'abab6.5-chat', 'finish_reason': 'tool_calls'}, id='run-d897e037-2796-49f5-847e-f9f69dd390db-0', tool_calls=[{'name': 'AnswerWithJustification', 'args': {'answer': 'A pound of bricks and a pound of feathers weigh the same.', 'justification': 'The weight of the feathers is much less dense than the weight of the bricks, but since both weigh one pound, they weigh the same.'}, 'id': 'call_function_8953642285', 'type': 'tool_call'}]), # 'parsed': AnswerWithJustification(answer='A pound of bricks and a pound of feathers weigh the same.', justification='The weight of the feathers is much less dense than the weight of the bricks, but since both weigh one pound, they weigh the same.'), # 'parsing_error': None # }

示例：函数调用，字典模式 (method=”function_calling”, include_raw=False)
from langchain_community.chat_models import MiniMaxChat from langchain_core.pydantic_v1 import BaseModel from langchain_core.utils.function_calling import convert_to_openai_tool class AnswerWithJustification(BaseModel): '''An answer to the user question along with justification for the answer.''' answer: str justification: str dict_schema = convert_to_openai_tool(AnswerWithJustification) llm = MiniMaxChat() structured_llm = llm.with_structured_output(dict_schema) structured_llm.invoke("What weighs more a pound of bricks or a pound of feathers") # -> { # 'answer': 'A pound of bricks and a pound of feathers both weigh the same, which is a pound.', # 'justification': 'The difference is that bricks are much denser than feathers, so a pound of bricks will take up much less space than a pound of feathers.' # }

MiniMaxChat 的示例¶

MiniMaxChat

Minimax

event	name	chunk	input	output
on_chat_model_start	[model name]		{“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	[model name]	‘Hello’
on_llm_end	[model name]		‘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, …])

Attribute	Type	Description
name	str	用户为事件定义的名称。
data	Any	与事件关联的数据。这可以是任何内容，但我们建议使其可 JSON 序列化。

langchain_community.chat_models.minimax.MiniMaxChat¶

MiniMaxChat 的示例¶

`langchain_community.chat_models.minimax`.MiniMaxChat¶