langchain_openai.chat_models.azure.AzureChatOpenAI

注意

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

Runnable 接口 具有在可运行对象上可用的附加方法，例如 with_types、 with_retry、 assign、 bind、 get_graph 等等。

class langchain_openai.chat_models.azure.AzureChatOpenAI

基类： BaseChatOpenAI

Azure OpenAI 聊天模型集成。

设置

请访问 https://learn.microsoft.com/en-us/azure/ai-services/openai/chatgpt-quickstart?tabs=command-line%2Cpython-new&pivots=programming-language-python 创建您的 Azure OpenAI 部署。

然后安装 langchain-openai 并设置环境变量 AZURE_OPENAI_API_KEY 和 AZURE_OPENAI_ENDPOINT

pip install -U langchain-openai

export AZURE_OPENAI_API_KEY="your-api-key"
export AZURE_OPENAI_ENDPOINT="https://your-endpoint.openai.azure.com/"

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

azure_deployment: str

要使用的 Azure OpenAI 部署的名称。

temperature: float

采样温度。

max_tokens: Optional[int]

要生成的最大令牌数。

logprobs: Optional[bool]

是否返回对数概率。

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

api_version: str

要使用的 Azure OpenAI API 版本。有关不同版本的更多信息，请参阅此处： https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#rest-api-versioning

timeout: Union[float, Tuple[float, float], Any, None]

请求超时时间。

max_retries: int

最大重试次数。

organization: Optional[str]

OpenAI 组织 ID。如果未传入，将从环境变量 OPENAI_ORG_ID 中读取。

model: Optional[str]

底层 OpenAI 模型的名称。用于跟踪和令牌计数。不影响完成。例如 “gpt-4”、“gpt-35-turbo” 等。

model_version: Optional[str]

底层 OpenAI 模型的版本。用于跟踪和令牌计数。不影响完成。例如 “0125”、“0125-preview” 等。

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

实例化

from langchain_openai import AzureChatOpenAI

llm = AzureChatOpenAI(
    azure_deployment="your-deployment",
    api_version="2024-05-01-preview",
    temperature=0,
    max_tokens=None,
    timeout=None,
    max_retries=2,
    # organization="...",
    # model="gpt-35-turbo",
    # model_version="0125",
    # other params...
)

注意：任何未明确支持的参数都将在每次调用模型时直接传递给 openai.AzureOpenAI.chat.completions.create(...) API。例如

from langchain_openai import AzureChatOpenAI
import openai

AzureChatOpenAI(..., logprobs=True).invoke(...)

# results in underlying API call of:

openai.AzureOpenAI(..).chat.completions.create(..., logprobs=True)

# which is also equivalent to:

AzureChatOpenAI(...).invoke(..., logprobs=True)

调用

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

AIMessage(
    content="J'adore programmer.",
    usage_metadata={"input_tokens": 28, "output_tokens": 6, "total_tokens": 34},
    response_metadata={
        "token_usage": {
            "completion_tokens": 6,
            "prompt_tokens": 28,
            "total_tokens": 34,
        },
        "model_name": "gpt-4",
        "system_fingerprint": "fp_7ec89fabc6",
        "prompt_filter_results": [
            {
                "prompt_index": 0,
                "content_filter_results": {
                    "hate": {"filtered": False, "severity": "safe"},
                    "self_harm": {"filtered": False, "severity": "safe"},
                    "sexual": {"filtered": False, "severity": "safe"},
                    "violence": {"filtered": False, "severity": "safe"},
                },
            }
        ],
        "finish_reason": "stop",
        "logprobs": None,
        "content_filter_results": {
            "hate": {"filtered": False, "severity": "safe"},
            "self_harm": {"filtered": False, "severity": "safe"},
            "sexual": {"filtered": False, "severity": "safe"},
            "violence": {"filtered": False, "severity": "safe"},
        },
    },
    id="run-6d7a5282-0de0-4f27-9cc0-82a9db9a3ce9-0",
)

流式处理

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

AIMessageChunk(content="", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content="J", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content="'", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content="ad", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content="ore", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content=" la", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content=" programm", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content="ation", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(content=".", id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f")
AIMessageChunk(
    content="",
    response_metadata={
        "finish_reason": "stop",
        "model_name": "gpt-4",
        "system_fingerprint": "fp_811936bd4f",
    },
    id="run-a6f294d3-0700-4f6a-abc2-c6ef1178c37f",
)

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

AIMessageChunk(
    content="J'adore la programmation.",
    response_metadata={
        "finish_reason": "stop",
        "model_name": "gpt-4",
        "system_fingerprint": "fp_811936bd4f",
    },
    id="run-ba60e41c-9258-44b8-8f3a-2f10599643b3",
)

异步

await llm.ainvoke(messages)

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

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

工具调用

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


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

[
    {
        "name": "GetWeather",
        "args": {"location": "Los Angeles, CA"},
        "id": "call_6XswGD5Pqk8Tt5atYr7tfenU",
    },
    {
        "name": "GetWeather",
        "args": {"location": "New York, NY"},
        "id": "call_ZVL15vA8Y7kXqOy3dtmQgeCi",
    },
    {
        "name": "GetPopulation",
        "args": {"location": "Los Angeles, CA"},
        "id": "call_49CFW8zqC9W7mh7hbMLSIrXw",
    },
    {
        "name": "GetPopulation",
        "args": {"location": "New York, NY"},
        "id": "call_6ghfKxV264jEfe1mRIkS3PE7",
    },
]

结构化输出

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=None,
)

有关更多信息，请参阅 AzureChatOpenAI.with_structured_output()。

JSON 模式

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{\n  "random_ints": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]\n}'

图像输入

import base64
import httpx
from langchain_core.messages import HumanMessage

image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
image_data = base64.b64encode(httpx.get(image_url).content).decode("utf-8")
message = HumanMessage(
    content=[
        {"type": "text", "text": "describe the weather in this image"},
        {
            "type": "image_url",
            "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
        },
    ]
)
ai_msg = llm.invoke([message])
ai_msg.content

"The weather in the image appears to be quite pleasant. The sky is mostly clear"

令牌使用量

ai_msg = llm.invoke(messages)
ai_msg.usage_metadata

{"input_tokens": 28, "output_tokens": 5, "total_tokens": 33}

对数概率

logprobs_llm = llm.bind(logprobs=True)
ai_msg = logprobs_llm.invoke(messages)
ai_msg.response_metadata["logprobs"]

{
    "content": [
        {
            "token": "J",
            "bytes": [74],
            "logprob": -4.9617593e-06,
            "top_logprobs": [],
        },
        {
            "token": "'adore",
            "bytes": [39, 97, 100, 111, 114, 101],
            "logprob": -0.25202933,
            "top_logprobs": [],
        },
        {
            "token": " la",
            "bytes": [32, 108, 97],
            "logprob": -0.20141791,
            "top_logprobs": [],
        },
        {
            "token": " programmation",
            "bytes": [
                32,
                112,
                114,
                111,
                103,
                114,
                97,
                109,
                109,
                97,
                116,
                105,
                111,
                110,
            ],
            "logprob": -1.9361265e-07,
            "top_logprobs": [],
        },
        {
            "token": ".",
            "bytes": [46],
            "logprob": -1.2233183e-05,
            "top_logprobs": [],
        },
    ]
}

响应元数据

ai_msg = llm.invoke(messages)
ai_msg.response_metadata

{
    "token_usage": {
        "completion_tokens": 6,
        "prompt_tokens": 28,
        "total_tokens": 34,
    },
    "model_name": "gpt-35-turbo",
    "system_fingerprint": None,
    "prompt_filter_results": [
        {
            "prompt_index": 0,
            "content_filter_results": {
                "hate": {"filtered": False, "severity": "safe"},
                "self_harm": {"filtered": False, "severity": "safe"},
                "sexual": {"filtered": False, "severity": "safe"},
                "violence": {"filtered": False, "severity": "safe"},
            },
        }
    ],
    "finish_reason": "stop",
    "logprobs": None,
    "content_filter_results": {
        "hate": {"filtered": False, "severity": "safe"},
        "self_harm": {"filtered": False, "severity": "safe"},
        "sexual": {"filtered": False, "severity": "safe"},
        "violence": {"filtered": False, "severity": "safe"},
    },
}

param azure_ad_token: Optional[SecretStr] = None

您的 Azure Active Directory 令牌。

如果未提供，则自动从环境变量 AZURE_OPENAI_AD_TOKEN 推断。 更多信息： https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id。

约束

• type = string

• writeOnly = True

• format = password

param azure_ad_token_provider: Union[Callable[[], str], None] = None

一个返回 Azure Active Directory 令牌的函数。

将在每个请求上调用。

param azure_endpoint: Union[str, None] = None

您的 Azure 端点，包括资源。

如果未提供，则自动从环境变量 AZURE_OPENAI_ENDPOINT 推断。 示例： https://example-resource.azure.openai.com/

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 default_headers: Union[Mapping[str, str], None] = None

param default_query: Union[Mapping[str, object], None] = None

param deployment_name: Union[str, None] (别名 'azure_deployment')

模型部署。

如果给定，则将基本客户端 URL 设置为包含 /deployments/{azure_deployment}。 注意：这意味着您将无法使用非部署端点。

param extra_body: Optional[Mapping[str, Any]] = None

在向 OpenAI 兼容的 API（例如 vLLM）发出请求时，要包含在请求参数中的可选附加 JSON 属性。

param frequency_penalty: Optional[float] = None

根据频率惩罚重复的令牌。

param http_async_client: Union[Any, None] = None

可选的 httpx.AsyncClient。 仅用于异步调用。 如果您想要用于同步调用的自定义客户端，则还必须指定 http_client。

param http_client: Union[Any, None] = None

可选的 httpx.Client。 仅用于同步调用。 如果您想要用于异步调用的自定义客户端，则还必须指定 http_async_client。

param include_response_headers: bool = False

是否在输出消息 response_metadata 中包含响应标头。

param logit_bias: Optional[Dict[int, int]] = None

修改指定令牌在完成中出现的可能性。

param logprobs: Optional[bool] = False

是否返回对数概率。

param max_retries: int = 2

生成时的最大重试次数。

param max_tokens: Optional[int] = None

要生成的最大令牌数。

param metadata: Optional[Dict[str, Any]] = None

要添加到运行跟踪的元数据。

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

保存任何对 create 调用有效的模型参数，这些参数未明确指定。

param model_name: Optional[str] = None (别名 'model')

已部署的 OpenAI 模型的名称，例如 “gpt-4o”、“gpt-35-turbo” 等。

与 Azure 部署名称不同，Azure 部署名称由 Azure 用户设置。 用于跟踪和令牌计数。 不影响完成。

param model_version: str = ''

模型的版本（例如，gpt-3.5-0125 的 “0125”）。

Azure OpenAI 默认情况下不返回响应中的模型版本，因此如果您想在下游使用此信息（例如，在计算成本时），则必须手动指定模型版本。

当您指定版本时，它将附加到响应中的模型名称。 设置正确的版本将帮助您正确计算成本。 模型版本未经过验证，因此请确保正确设置以获得正确的成本。

param n: int = 1

为每个提示生成的聊天完成次数。

param openai_api_base: Optional[str] = None (别名 'base_url')

API 请求的基本 URL 路径，如果不使用代理或服务模拟器，则留空。

param openai_api_key: Optional[SecretStr] = None (别名 'api_key')

如果未提供，则自动从环境变量 AZURE_OPENAI_API_KEY 推断。

约束

• type = string

• writeOnly = True

• format = password

param openai_api_type: str = ''

旧版，用于支持 openai<1.0.0。

param openai_api_version: str = '' (别名 'api_version')

如果未提供，则自动从环境变量 OPENAI_API_VERSION 推断。

param openai_organization: Optional[str] = None (别名 'organization')

如果未提供，则自动从环境变量 OPENAI_ORG_ID 推断。

param openai_proxy: Optional[str] = None

param presence_penalty: Optional[float] = None

惩罚重复的令牌。

param rate_limiter: Optional[BaseRateLimiter] = None

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

param request_timeout: Union[float, Tuple[float, float], Any, None] = None (别名 'timeout')

对 OpenAI 完成 API 的请求超时时间。 可以是 float、httpx.Timeout 或 None。

param seed: Optional[int] = None

生成种子

param stop: 可选的[Union[List[str], str]] = None (别名 'stop_sequences')

默认停止序列。

param streaming: bool = False

是否流式传输结果。

param tags: 可选的[List[str]] = None

添加到运行跟踪的标签。

param temperature: float = 0.7

要使用的采样温度。

param tiktoken_model_name: 可选的[str] = None

使用此类时传递给 tiktoken 的模型名称。Tiktoken 用于计算文档中的 token 数量，以将其限制在某个限制之下。默认情况下，当设置为 None 时，这将与嵌入模型名称相同。但是，在某些情况下，您可能希望将此 Embedding 类与 tiktoken 不支持的模型名称一起使用。这可能包括使用 Azure 嵌入或使用许多模型提供商之一，这些提供商公开了类似 OpenAI 的 API，但具有不同的模型。在这些情况下，为了避免在调用 tiktoken 时出错，您可以指定此处要使用的模型名称。

param top_logprobs: 可选的[int] = None

在每个 token 位置返回的最有可能的 token 数量，每个 token 都有一个相关的对数概率。如果使用此参数，则必须将 logprobs 设置为 true。

param top_p: 可选的[float] = None

在每个步骤中要考虑的 token 的总概率质量。

param validate_base_url: bool = True

如果传入旧版参数 openai_api_base，请尝试推断它是否为 base_url 或 azure_endpoint，并相应地更新客户端参数。

param verbose: bool [可选]

是否打印响应文本。

__call__(messages: List[BaseMessage], stop: 可选的[List[str]] = None, callbacks: 可选的[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: 可选的[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]

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

batch 的默认实现对于 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: 可选的[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 的其他关键字参数。

产生

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

返回类型

AsyncIterator[Tuple[int, Union[Output, Exception]]]

async agenerate(messages: List[List[BaseMessage]], stop: 可选的[List[str]] = None, callbacks: 可选的[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: 可选的[List[str]] = None, metadata: 可选的[Dict[str, Any]] = None, run_name: 可选的[str] = None, run_id: 可选的[UUID] = None, **kwargs: Any) → LLMResult

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

此方法应利用模型的批量调用，这些模型公开了批量 API。

当您想要以下操作时，请使用此方法

1. 利用批量调用，

2. 需要比模型仅生成的最高值更多的输出，

3. 正在构建对底层语言模型不可知的链

   类型（例如，纯文本完成模型与聊天模型）。

参数

• 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，其中包含每个输入

提示的候选生成列表和额外的模型提供商特定的输出。

返回类型

LLMResult

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

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

此方法应利用模型的批量调用，这些模型公开了批量 API。

当您想要以下操作时，请使用此方法

1. 利用批量调用，

2. 需要比模型仅生成的最高值更多的输出，

3. 正在构建对底层语言模型不可知的链

   类型（例如，纯文本完成模型与聊天模型）。

参数

• prompts (List[PromptValue]) – PromptValue 列表。PromptValue 是一个可以转换为匹配任何语言模型格式的对象（纯文本生成模型的字符串和聊天模型的 BaseMessages）。

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

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

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

返回

一个 LLMResult，其中包含每个输入

提示的候选生成列表和额外的模型提供商特定的输出。

返回类型

LLMResult

async ainvoke(input: LanguageModelInput, config: 可选的[RunnableConfig] = None, *, stop: 可选的[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: 可选的[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: 可选的[Sequence[str]] = None, **kwargs: Any) → BaseMessage

Deprecated since version 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: 可选的[str] = None, description: 可选的[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 实例。

返回类型

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[List[str]] = None, **kwargs: Any) → AsyncIterator[BaseMessageChunk]

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

参数

• input (LanguageModelInput) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。

• kwargs (Any) – 传递给 Runnable 的其他关键字参数。

• stop (Optional[List[str]]) –

产生

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 - 与给定 Runnable 执行关联的随机生成的 ID，该 Runnable 发出事件。作为父 Runnable 执行的一部分调用的子 Runnable 会被分配其自己唯一的 ID。

  Runnable 发出事件。作为父 Runnable 执行的一部分调用的子 Runnable 会被分配其自己唯一的 ID。

• parent_ids: List[str] - 生成事件的父 runnables 的 ID。根 Runnable 将有一个空列表。父 ID 的顺序是从根到直接父级。仅适用于 API 的 v2 版本。API 的 v1 版本将返回一个空列表。

  generated the event. The root Runnable will have an empty list. The order of the parent IDs is from the root to the immediate parent. Only available for v2 version of the API. The v1 version of the API will return an empty list.

• tags: Optional[List[str]] - 生成事件的 Runnable 的标签。

  the event.

• metadata: Optional[Dict[str, Any]] - 生成事件的 Runnable 的元数据。

  that generated the event.

• 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	[检索器名称]		{“query”: “hello”}
on_retriever_end	[检索器名称]		{“query”: “hello”}	[Document(…), ..]
on_prompt_start	[模板名称]		{“question”: “hello”}
on_prompt_end	[模板名称]		{“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 之上。

产生

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 绑定的 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_functions(functions: Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]], function_call: Optional[Union[_FunctionCall, str, Literal['auto', 'none']]] = None, **kwargs: Any) → Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]], BaseMessage]

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

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

注意：建议改用 bind_tools，因为 functions 和 function_call 请求参数已被 OpenAI 官方标记为已弃用。

function_call request parameters are officially marked as deprecated by OpenAI.

参数

• functions (Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]]) – 要绑定到此聊天模型的功能定义列表。可以是字典、pydantic 模型或可调用对象。Pydantic 模型和可调用对象将自动转换为它们的模式字典表示形式。

• function_call (Optional[Union[_FunctionCall, str, Literal['auto', 'none']]]) – 需要模型调用的函数。必须是单个提供的函数的名称，或 “auto” 以自动确定要调用的函数（如果有）。

• **kwargs (Any) – 要传递给 Runnable 构造函数的任何其他参数。

返回类型

Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], BaseMessage]

bind_tools(tools: Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]], *, tool_choice: Optional[Union[dict, str, Literal['auto', 'none', 'any', 'required'], bool]] = None, **kwargs: Any) → Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], BaseMessage]

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

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

参数

• tools (Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]]) – 绑定到此聊天模型的工具定义列表。支持 langchain_core.utils.function_calling.convert_to_openai_tool() 处理的任何工具定义。

• tool_choice (Optional[Union[dict, str, Literal['auto', 'none', 'any', 'required'], bool]]) –

  需要模型调用的工具选项。

  • str 形式为 "<<tool_name>>"：调用 <<tool_name>> 工具。

  • "auto"：自动选择工具（包括不选择工具）。

  • "none"：不调用任何工具。

  • "any" 或 "required" 或 True：强制至少调用一个工具。

  • dict 形式为 {"type": "function", "function": {"name": <<tool_name>>}}：调用 <<tool_name>> 工具。

  • False 或 None：无效果，默认 OpenAI 行为。

• kwargs (Any) – 任何额外的参数都直接传递给 self.bind(**kwargs)。

返回类型

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]

配置可在运行时设置的 Runnable 的备选项。

参数

• 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。

当您想要以下操作时，请使用此方法

1. 利用批量调用，

2. 需要比模型仅生成的最高值更多的输出，

3. 正在构建对底层语言模型不可知的链

   类型（例如，纯文本完成模型与聊天模型）。

参数

• 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，其中包含每个输入

提示的候选生成列表和额外的模型提供商特定的输出。

返回类型

LLMResult

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

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

此方法应利用模型的批量调用，这些模型公开了批量 API。

当您想要以下操作时，请使用此方法

1. 利用批量调用，

2. 需要比模型仅生成的最高值更多的输出，

3. 正在构建对底层语言模型不可知的链

   类型（例如，纯文本完成模型与聊天模型）。

参数

• prompts (List[PromptValue]) – PromptValue 列表。PromptValue 是一个可以转换为匹配任何语言模型格式的对象（纯文本生成模型的字符串和聊天模型的 BaseMessages）。

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

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

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

返回

一个 LLMResult，其中包含每个输入

提示的候选生成列表和额外的模型提供商特定的输出。

返回类型

LLMResult

get_num_tokens(text: str) → int

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

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

参数

text (str) – 要标记化的字符串输入。

返回

文本中的整数 token 数量。

返回类型

int

get_num_tokens_from_messages(messages: List[BaseMessage]) → int

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

Requirements: 如果您希望在指定图像为 base64 字符串时计算图像 token，则必须安装 pillow；如果您指定图像为 URL，则必须同时安装 pillow 和 httpx。如果未安装这些库，图像输入将在 token 计数中被忽略。

OpenAI 参考： https://github.com/openai/openai-cookbook/blob/ main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb

参数

messages (List[BaseMessage]) –

返回类型

int

get_token_ids(text: str) → List[int]

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

参数

text (str) –

返回类型

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

产生

Runnable 的输出。

返回类型

Iterator[BaseMessageChunk]

to_json() → Union[SerializedConstructor, SerializedNotImplemented]

将 Runnable 序列化为 JSON。

返回

Runnable 的 JSON 可序列化表示。

返回类型

Union[SerializedConstructor, SerializedNotImplemented]

with_structured_output(schema: Optional[Union[Dict[str, Any]], Type[_BM]]] = None, *, method: Literal['function_calling', 'json_mode'] = 'function_calling', include_raw: Literal[True] = True, **kwargs: Any) → Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], _AllReturnType]

with_structured_output(schema: Optional[Union[Dict[str, Any]], Type[_BM]]] = None, *, method: Literal['function_calling', 'json_mode'] = 'function_calling', include_raw: Literal[False] = False, **kwargs: Any) → Runnable[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], Union[Dict, _BM]]

模型包装器，返回根据给定模式格式化的输出。

Args

schema

输出模式。可以作为以下形式传入：

• OpenAI 函数/工具模式，

• JSON Schema，

• TypedDict 类，

• 或 Pydantic 类。

如果 schema 是 Pydantic 类，则模型输出将是该类的 Pydantic 实例，并且模型生成的字段将由 Pydantic 类验证。否则，模型输出将是 dict，并且不会被验证。有关如何在指定 Pydantic 或 TypedDict 类时正确指定模式字段的类型和描述的更多信息，请参阅 langchain_core.utils.function_calling.convert_to_openai_tool()。

method

用于指导模型生成的方法，可以是 “function_calling” 或 “json_mode”。如果为 “function_calling”，则模式将转换为 OpenAI 函数，并且返回的模型将使用函数调用 API。如果为 “json_mode”，则将使用 OpenAI 的 JSON 模式。请注意，如果使用 “json_mode”，则必须在模型调用中包含将输出格式化为所需模式的说明。

include_raw

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

返回

接受与 langchain_core.language_models.chat.BaseChatModel>` 相同的输入的 Runnable。

如果 `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]

示例：schema=Pydantic 类, method=”function_calling”, include_raw=False

from typing import Optional

from langchain_openai import AzureChatOpenAI
from langchain_core.pydantic_v1 import BaseModel, Field


class AnswerWithJustification(BaseModel):
    '''An answer to the user question along with justification for the answer.'''

    answer: str
    # If we provide default values and/or descriptions for fields, these will be passed
    # to the model. This is an important part of improving a model's ability to
    # correctly return structured outputs.
    justification: Optional[str] = Field(
        default=None, description="A justification for the answer."
    )


llm = AzureChatOpenAI(model="gpt-3.5-turbo-0125", 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.'
# )

示例：schema=Pydantic 类, method=”function_calling”, include_raw=True

from langchain_openai import AzureChatOpenAI
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 = AzureChatOpenAI(model="gpt-3.5-turbo-0125", 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
# }

示例：schema=TypedDict 类, method=”function_calling”, include_raw=False

# IMPORTANT: If you are using Python <=3.8, you need to import Annotated
# from typing_extensions, not from typing.
from typing_extensions import Annotated, TypedDict

from langchain_openai import AzureChatOpenAI


class AnswerWithJustification(TypedDict):
    '''An answer to the user question along with justification for the answer.'''

    answer: str
    justification: Annotated[
        Optional[str], None, "A justification for the answer."
    ]


llm = AzureChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
structured_llm = llm.with_structured_output(AnswerWithJustification)

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.'
# }

示例：schema=OpenAI 函数 schema, method=”function_calling”, include_raw=False

 from langchain_openai import AzureChatOpenAI

 oai_schema = {
     'name': 'AnswerWithJustification',
     'description': 'An answer to the user question along with justification for the answer.',
     'parameters': {
         'type': 'object',
         'properties': {
             'answer': {'type': 'string'},
             'justification': {'description': 'A justification for the answer.', 'type': 'string'}
         },
        'required': ['answer']
    }
}

 llm = AzureChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
 structured_llm = llm.with_structured_output(oai_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.'
 # }

示例：schema=Pydantic 类, method=”json_mode”, include_raw=True

from langchain_openai import AzureChatOpenAI
from langchain_core.pydantic_v1 import BaseModel

class AnswerWithJustification(BaseModel):
    answer: str
    justification: str

llm = AzureChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
structured_llm = llm.with_structured_output(
    AnswerWithJustification,
    method="json_mode",
    include_raw=True
)

structured_llm.invoke(
    "Answer the following question. "
    "Make sure to return a JSON blob with keys 'answer' and 'justification'.

“

“一磅砖头还是一磅羽毛更重？”

) # -> { # ‘raw’: AIMessage(content=’{

“answer”: “它们重量相同。”, “justification”: “一磅砖头和一磅羽毛都重一磅。区别在于材料的体积和密度，而不是重量。”

}’),

# ‘parsed’: AnswerWithJustification(answer=’They are both the same weight.’, justification=’Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight.’), # ‘parsing_error’: None # }

示例：schema=None, method=”json_mode”, include_raw=True

structured_llm = llm.with_structured_output(method="json_mode", include_raw=True)

structured_llm.invoke(
    "Answer the following question. "
    "Make sure to return a JSON blob with keys 'answer' and 'justification'.

“

“一磅砖头还是一磅羽毛更重？”

) # -> { # ‘raw’: AIMessage(content=’{

“answer”: “它们重量相同。”, “justification”: “一磅砖头和一磅羽毛都重一磅。区别在于材料的体积和密度，而不是重量。”

}’),

# ‘parsed’: { # ‘answer’: ‘They are both the same weight.’, # ‘justification’: ‘Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight.’ # }, # ‘parsing_error’: None # }

使用 AzureChatOpenAI 的示例

• Azure Cosmos DB for Apache Gremlin

• AzureChatOpenAI

• 微软

• OpenAI