聊天模型集成测试#

class langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests[source]#

聊天模型集成测试的基类。

测试子类必须实现 chat_model_class 和 chat_model_params 属性，以指定要测试的模型及其 初始化参数。

示例：

from typing import Type

from langchain_tests.integration_tests import ChatModelIntegrationTests
from my_package.chat_models import MyChatModel


class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def chat_model_class(self) -> Type[MyChatModel]:
        # Return the chat model class to test here
        return MyChatModel

    @property
    def chat_model_params(self) -> dict:
        # Return initialization parameters for the model.
        return {"model": "model-001", "temperature": 0}

注意

个别测试方法的API参考包括故障排除提示。

测试子类必须实现以下两个属性：

chat_model_class

要测试的聊天模型类，例如 ChatParrotLink。

示例：

@property
def chat_model_class(self) -> Type[ChatParrotLink]:
    return ChatParrotLink
chat_model_params

聊天模型的初始化参数。

示例：

@property
def chat_model_params(self) -> dict:
    return {"model": "bird-brain-001", "temperature": 0}

此外，测试子类可以通过选择性地覆盖以下属性来控制测试哪些功能（例如工具调用或多模态）。展开以查看详细信息：

has_tool_calling

布尔属性，指示聊天模型是否支持工具调用。

默认情况下，这由聊天模型的bind_tools方法是否被重写决定。通常在测试类上不需要重写它。

示例覆盖：

@property
def has_tool_calling(self) -> bool:
    return True
tool_choice_value

在测试中使用的工具选择的值。

一些用于工具调用功能的测试尝试通过tool_choice参数强制工具调用。此参数的常见值为“any”。默认为None。

注意：如果值设置为“tool_name”，则每个测试中使用的工具名称将设置为tool_choice的值。

示例：

@property
def tool_choice_value(self) -> Optional[str]:
    return "any"
has_structured_output

布尔属性，指示聊天模型是否支持结构化输出。

默认情况下，这取决于聊天模型的with_structured_output方法是否被重写。如果打算使用基本实现，则应重写此方法。

参见：https://python.langchain.com/docs/concepts/structured_outputs/

示例：

@property
def has_structured_output(self) -> bool:
    return True
supports_json_mode

布尔属性，指示聊天模型是否支持在with_structured_output中使用JSON模式。

参见：https://python.langchain.com/docs/concepts/structured_outputs/#json-mode

示例：

@property
def supports_json_mode(self) -> bool:
    return True
supports_image_inputs

布尔属性，指示聊天模型是否支持图像输入。 默认为 False。

如果设置为True，聊天模型将使用以下形式的内容块进行测试

[
    {"type": "text", "text": "describe the weather in this image"},
    {
        "type": "image_url",
        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
    },
]

参见 https://python.langchain.com/docs/concepts/multimodality/

示例：

@property
def supports_image_inputs(self) -> bool:
    return True
supports_video_inputs

布尔属性，指示聊天模型是否支持图像输入。 默认为 False。目前没有为此功能编写测试。

returns_usage_metadata

布尔属性，指示聊天模型是否在调用和流式响应时返回使用元数据。

usage_metadata 是 AIMessages 上的一个可选字典属性，用于跟踪输入和输出令牌：https://python.langchain.com/api_reference/core/messages/langchain_core.messages.ai.UsageMetadata.html

示例：

@property
def returns_usage_metadata(self) -> bool:
    return False
supports_anthropic_inputs

布尔属性，指示聊天模型是否支持Anthropic风格的输入。

这些输入可能包含“工具使用”和“工具结果”内容块，例如，

[
    {"type": "text", "text": "Hmm let me think about that"},
    {
        "type": "tool_use",
        "input": {"fav_color": "green"},
        "id": "foo",
        "name": "color_picker",
    },
]

如果设置为 True，将使用此表单的内容块测试聊天模型。

示例：

@property
def supports_anthropic_inputs(self) -> bool:
    return False
supports_image_tool_message

布尔属性，指示聊天模型是否支持包含图像内容的ToolMessages，例如，

ToolMessage(
    content=[
        {
            "type": "image_url",
            "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
        },
    ],
    tool_call_id="1",
    name="random_image",
)

如果设置为 True，聊天模型将使用包含此类 ToolMessages 的消息序列进行测试。

示例：

@property
def supports_image_tool_message(self) -> bool:
    return False
supported_usage_metadata_details

属性控制在使用和流中发出哪些使用元数据详细信息。

usage_metadata 是 AIMessages 上的一个可选字典属性，用于跟踪输入和输出令牌：https://python.langchain.com/api_reference/core/messages/langchain_core.messages.ai.UsageMetadata.html

它包括可选的键 input_token_details 和 output_token_details，可以跟踪与特殊类型令牌相关的使用详情，例如缓存的、音频的或推理的。

只有在提供这些详细信息时才需要重写。

属性

chat_model_class

要测试的聊天模型类，例如 ChatParrotLink。

chat_model_params

聊天模型的初始化参数。

has_structured_output

(bool) 聊天模型是否支持结构化输出。

has_tool_calling

(bool) 模型是否支持工具调用。

returns_usage_metadata

(bool) 聊天模型是否在调用和流式响应时返回使用元数据。

supported_usage_metadata_details

(字典) 在调用和流中发出的使用元数据详细信息。

supports_anthropic_inputs

(bool) 聊天模型是否支持Anthropic风格的输入。

supports_image_inputs

(bool) 聊天模型是否支持图像输入，默认为 False。

supports_image_tool_message

(bool) 聊天模型是否支持包含图像内容的ToolMessages。

supports_json_mode

(bool) 聊天模型是否支持JSON模式。

supports_video_inputs

(bool) 聊天模型是否支持视频输入，默认为 False。

tool_choice_value

(None 或 str) 用于测试时的工具选择。

方法

test_abatch(model)

测试以验证 await model.abatch([messages]) 是否有效。

test_ainvoke(model)

测试以验证 await model.ainvoke(simple_message) 是否有效。

test_anthropic_inputs(model)

测试模型是否可以处理Anthropic风格的消息历史。

test_astream(model)

测试以验证 await model.astream(simple_message) 是否有效。

test_batch(model)

测试以验证 model.batch([messages]) 是否有效。

test_bind_runnables_as_tools(model)

测试模型是否为从LangChain runnables派生的工具生成工具调用。

test_conversation(model)

测试以验证模型能够处理多轮对话。

test_image_inputs(model)

测试模型能够处理图像输入。

test_image_tool_message(model)

测试模型能否处理带有图像输入的ToolMessages。

test_invoke(model)

测试以验证 model.invoke(simple_message) 是否有效。

test_json_mode(model)

通过`JSON模式测试结构化输出。

test_message_with_name(model)

测试可以处理带有name字段值的HumanMessage。

test_stop_sequence(model)

测试当使用stop参数调用模型时，模型不会失败，该参数是用于在某个标记处停止生成的标准参数。

test_stream(model)

测试以验证 model.stream(simple_message) 是否有效。

test_structured_few_shot_examples(model, ...)

测试模型能否处理带有工具调用的少样本示例。

test_structured_output(model)

测试以验证在调用和流式传输时生成结构化输出。

test_structured_output_async(model)

测试以验证在调用和流式传输时都会生成结构化输出。

test_structured_output_optional_param(model)

测试以验证我们可以生成包含可选参数的结构化输出。

test_structured_output_pydantic_2_v1(model)

测试以验证我们可以使用 pydantic.v1.BaseModel 生成结构化输出。

test_tool_calling(model)

测试模型生成工具调用。

test_tool_calling_async(model)

测试模型生成工具调用。

test_tool_calling_with_no_arguments(model)

测试模型是否为没有参数的生成工具调用。

test_tool_message_error_status(model, ...)

测试可以处理带有status="error"的ToolMessage。

test_tool_message_histories_list_content(...)

测试消息历史记录是否与列表工具内容兼容（例如Anthropic格式）。

test_tool_message_histories_string_content(...)

测试消息历史记录是否与字符串工具内容兼容（例如OpenAI格式）。

test_usage_metadata(model)

测试以验证模型返回正确的使用元数据。

test_usage_metadata_streaming(model)

测试以验证模型在流模式下返回正确的使用元数据。
async test_abatch(model: BaseChatModel) → None[source]#

测试以验证await model.abatch([messages])是否有效。

这应该适用于所有集成。测试模型在单个批次中异步处理多个提示的能力。

Troubleshooting

首先，调试 test_batch() 和 test_ainvoke() 因为 abatch 有一个默认实现，它为批次中的每条消息调用 ainvoke。

如果那些测试通过了但这个没有通过，你应该确保你的abatch方法没有引发任何异常，并且它返回了一个有效的AIMessage对象列表。

Parameters:

模型 (BaseChatModel)

Return type:

无

async test_ainvoke(model: BaseChatModel) → None[来源]#

测试以验证await model.ainvoke(simple_message)是否有效。

这应该适用于所有集成。通过此测试并不表示“原生异步”实现，而是表示该模型可以在异步上下文中使用。

Troubleshooting

首先，调试 test_invoke()。 因为 ainvoke 有一个默认实现，它在异步上下文中调用 invoke。

如果那个测试通过了但这个没有通过，你应该确保你的 _agenerate 方法不会引发任何异常，并且它返回一个有效的 ChatResult 如下所示：

return ChatResult(
    generations=[ChatGeneration(
        message=AIMessage(content="Output text")
    )]
)
Parameters:

模型 (BaseChatModel)

Return type:

无

test_anthropic_inputs(model: BaseChatModel) → None[source]#

测试模型是否可以处理Anthropic风格的消息历史。

这些消息历史将包括带有tool_use内容块的AIMessage对象，例如，

AIMessage(
    [
        {"type": "text", "text": "Hmm let me think about that"},
        {
            "type": "tool_use",
            "input": {"fav_color": "green"},
            "id": "foo",
            "name": "color_picker",
        },
    ]
)

以及包含tool_result内容块的HumanMessage对象：

HumanMessage(
    [
        {
            "type": "tool_result",
            "tool_use_id": "foo",
            "content": [
                {
                    "type": "text",
                    "text": "green is a great pick! that's my sister's favorite color",  # noqa: E501
                }
            ],
            "is_error": False,
        },
        {"type": "text", "text": "what's my sister's favorite color"},
    ]
)

如果模型不支持这种形式的消息（或者通常不支持工具调用），则应跳过此测试。请参阅下面的配置。

Configuration

要禁用此测试，请在您的测试类中将 supports_anthropic_inputs 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_anthropic_inputs(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查：

  1. 该模型能够正确处理包含具有列表内容的消息对象的消息历史。

  2. AIMessage 对象上的 tool_calls 属性被正确处理并以适当的格式传递给模型。

  3. 带有“tool_result”内容块的HumanMessages被正确处理。

否则，如果不支持Anthropic工具调用和结果格式，将supports_anthropic_inputs属性设置为False。

Parameters:

模型 (BaseChatModel)

Return type:

无

async test_astream(model: BaseChatModel) → None[源代码]#

测试以验证await model.astream(simple_message)是否有效。

这应该适用于所有集成。通过此测试并不表示“原生异步”或“流式”实现，而是表示该模型可以在异步流式上下文中使用。

Troubleshooting

首先，调试 test_stream(). 和 test_ainvoke(). 因为 astream 有一个默认实现，如果实现了 _stream，则在异步上下文中调用它，如果没有实现，则调用 ainvoke 并将结果作为单个块生成。

如果那些测试通过了但这个没有通过，你应该确保你的 _astream 方法不会引发任何异常，并且它生成有效的 ChatGenerationChunk 对象，如下所示：

yield ChatGenerationChunk(
    message=AIMessageChunk(content="chunk text")
)
Parameters:

模型 (BaseChatModel)

Return type:

无

test_batch(model: BaseChatModel) → None[source]#

测试以验证model.batch([messages])是否有效。

这应该适用于所有集成。测试模型处理单个批次中多个提示的能力。

Troubleshooting

首先，调试 test_invoke() 因为 batch 有一个默认实现，它为批次中的每条消息调用 invoke。

如果那个测试通过了但这个没有通过，你应该确保你的batch方法不会引发任何异常，并且它返回一个有效的AIMessage对象列表。

Parameters:

模型 (BaseChatModel)

Return type:

无

test_bind_runnables_as_tools(model: BaseChatModel) → None[源代码]#

测试模型是否为从LangChain可运行对象派生的工具生成工具调用。如果测试类上的has_tool_calling属性设置为False，则跳过此测试。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查bind_tools是否已正确实现，将LangChain工具对象转换为适合您的聊天模型的相应模式。

如果聊天模型不支持tool_choice参数，此测试可能会失败。此参数可用于强制工具调用。如果不支持tool_choice并且模型始终无法通过此测试，您可以将测试标记为xfail：

@pytest.mark.xfail(reason=("Does not support tool_choice."))
def test_bind_runnables_as_tools(self, model: BaseChatModel) -> None:
    super().test_bind_runnables_as_tools(model)

否则，请确保在测试类上正确指定了tool_choice_value属性。

Parameters:

模型 (BaseChatModel)

Return type:

无

test_conversation(model: BaseChatModel) → None[源代码]#

测试以验证模型能否处理多轮对话。

这应该适用于所有集成。测试模型处理交替的人类和AI消息序列作为生成下一个响应的上下文的能力。

Troubleshooting

首先，调试 test_invoke() 因为这个测试也使用了 model.invoke()。

如果那个测试通过了但这个没有通过，你应该验证： 1. 你的模型是否正确处理了消息历史 2. 模型是否保持了之前消息的适当上下文 3. 响应是否是一个有效的 AIMessage

Parameters:

模型 (BaseChatModel)

Return type:

无

test_image_inputs(model: BaseChatModel) → None[源代码]#

测试模型能够处理图像输入。

如果模型不支持图像输入，则应跳过此测试（请参阅下面的配置）。这些将以带有OpenAI风格图像内容块的消息形式出现：

[
    {"type": "text", "text": "describe the weather in this image"},
    {
        "type": "image_url",
        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
    },
]

参见 https://python.langchain.com/docs/concepts/multimodality/

Configuration

要禁用此测试，请在您的测试类中将 supports_image_inputs 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_image_inputs(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查模型是否能够正确处理包含OpenAI格式的图像内容块的消息，包括base64编码的图像。否则，将supports_image_inputs属性设置为False。

Parameters:

模型 (BaseChatModel)

Return type:

无

test_image_tool_message(model: BaseChatModel) → None[source]#

测试模型能够处理带有图像输入的ToolMessages。

如果模型不支持以下形式的消息，则应跳过此测试：

ToolMessage(
    content=[
        {
            "type": "image_url",
            "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
        },
    ],
    tool_call_id="1",
    name="random_image",
)

可以通过将supports_image_tool_message属性设置为False来跳过此测试（请参阅下面的配置）。

Configuration

要禁用此测试，请在您的测试类中将 supports_image_tool_message 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_image_tool_message(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查模型是否能够正确处理包含图像内容块的消息，包括base64编码的图像。否则，将supports_image_tool_message属性设置为False。

Parameters:

模型 (BaseChatModel)

Return type:

无

test_invoke(model: BaseChatModel) → None[source]#

测试以验证model.invoke(simple_message)是否有效。

这应该适用于所有集成。

Troubleshooting

如果此测试失败，您应确保您的 _generate 方法 不会引发任何异常，并且它返回一个有效的 ChatResult 如下所示：

return ChatResult(
    generations=[ChatGeneration(
        message=AIMessage(content="Output text")
    )]
)
Parameters:

模型 (BaseChatModel)

Return type:

无

test_json_mode(model: BaseChatModel) → None[源代码]#

通过JSON模式测试结构化输出。

此测试是可选的，如果模型不支持JSON模式功能（请参见下面的配置），则应跳过。

Configuration

要禁用此测试，请在您的测试类中将 supports_json_mode 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_json_mode(self) -> bool:
        return False
Troubleshooting

查看with_structured_output的示例实现：https://python.langchain.com/api_reference/_modules/langchain_openai/chat_models/base.html#BaseChatOpenAI.with_structured_output

Parameters:

模型 (BaseChatModel)

Return type:

无

test_message_with_name(model: BaseChatModel) → None[源代码]#

测试可以处理带有name字段值的HumanMessage。

这些消息可能采取以下形式：

HumanMessage("hello", name="example_user")

如果可能，name 字段应该被解析并适当地传递给模型。否则，它应该被忽略。

Troubleshooting

如果此测试失败，请检查name字段在HumanMessage对象上是否被忽略或适当地传递给模型。

Parameters:

模型 (BaseChatModel)

Return type:

无

test_stop_sequence(model: BaseChatModel) → None[source]#

测试模型在调用stop参数时不会失败， 这是一个用于在某个标记处停止生成的标准参数。

更多关于标准参数的信息在这里：https://python.langchain.com/docs/concepts/chat_models/#standard-parameters

这应该适用于所有集成。

Troubleshooting

如果此测试失败，请检查_generate的函数签名（以及_stream和异步变体）是否接受stop参数：

def _generate(
    self,
    messages: List[BaseMessage],
    stop: Optional[List[str]] = None,
    run_manager: Optional[CallbackManagerForLLMRun] = None,
    **kwargs: Any,
) -> ChatResult:
Parameters:

模型 (BaseChatModel)

Return type:

无

test_stream(model: BaseChatModel) → None[source]#

测试以验证model.stream(simple_message)是否有效。

这应该适用于所有集成。通过此测试并不表示“流式”实现，而是表示该模型可以在流式上下文中使用。

Troubleshooting

首先，调试 test_invoke()。 因为 stream 有一个默认实现，它调用 invoke 并将结果作为一个单独的块生成。

如果那个测试通过了但这个没有通过，你应该确保你的 _stream 方法不会引发任何异常，并且它生成了有效的 ChatGenerationChunk 对象，如下所示：

yield ChatGenerationChunk(
    message=AIMessageChunk(content="chunk text")
)
Parameters:

模型 (BaseChatModel)

Return type:

无

test_structured_few_shot_examples(model: BaseChatModel, my_adder_tool: BaseTool) → None[source]#

测试模型是否能够处理带有工具调用的少样本示例。

这些表示为以下形式的消息序列：

  • HumanMessage 带有字符串内容;

  • AIMessage 带有填充的 tool_calls 属性；

  • ToolMessage 带有字符串内容；

  • AIMessage 包含字符串内容（一个答案）；

  • HuamnMessage 带有字符串内容（一个后续问题）。

如果模型不支持工具调用，则应跳过此测试（请参阅下面的配置）。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

此测试使用langchain_core中的一个实用函数来生成一系列表示“few-shot”示例的消息：https://python.langchain.com/api_reference/core/utils/langchain_core.utils.function_calling.tool_example_to_messages.html

如果此测试失败，请检查模型是否能正确处理此消息序列。

如果工具调用已实现但不支持此格式，您可以将测试标记为xfail。

@pytest.mark.xfail(reason=("Not implemented."))
def test_structured_few_shot_examples(self, *args: Any) -> None:
    super().test_structured_few_shot_examples(*args)
Parameters:
Return type:

无

test_structured_output(model: BaseChatModel) → None[source]#

测试以验证在调用和流式传输时是否生成了结构化输出。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请确保模型的bind_tools方法 正确处理了JSON Schema和Pydantic V2模型。 langchain_core实现了一个实用函数，可以适应 大多数格式：https://python.langchain.com/api_reference/core/utils/langchain_core.utils.function_calling.convert_to_openai_tool.html

查看with_structured_output的示例实现：https://python.langchain.com/api_reference/_modules/langchain_openai/chat_models/base.html#BaseChatOpenAI.with_structured_output

Parameters:

模型 (BaseChatModel)

Return type:

无

async test_structured_output_async(model: BaseChatModel) → None[source]#

测试以验证在调用和流式传输时是否生成了结构化输出。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请确保模型的 bind_tools 方法 正确处理了 JSON Schema 和 Pydantic V2 模型。 langchain_core 实现了一个实用函数，可以适应 大多数格式：https://python.langchain.com/api_reference/core/utils/langchain_core.utils.function_calling.convert_to_openai_tool.html

查看with_structured_output的示例实现：https://python.langchain.com/api_reference/_modules/langchain_openai/chat_models/base.html#BaseChatOpenAI.with_structured_output

Parameters:

模型 (BaseChatModel)

Return type:

无

test_structured_output_optional_param(model: BaseChatModel) → None[source]#

测试以验证我们可以生成包含可选参数的结构化输出。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请确保模型的bind_tools方法 正确处理带有可选参数的Pydantic V2模型。 langchain_core实现了一个实用函数，可以适应 大多数格式：https://python.langchain.com/api_reference/core/utils/langchain_core.utils.function_calling.convert_to_openai_tool.html

查看with_structured_output的示例实现：https://python.langchain.com/api_reference/_modules/langchain_openai/chat_models/base.html#BaseChatOpenAI.with_structured_output

Parameters:

模型 (BaseChatModel)

Return type:

无

test_structured_output_pydantic_2_v1(model: BaseChatModel) → None[source]#

测试验证我们可以使用 pydantic.v1.BaseModel 生成结构化输出。

pydantic.v1.BaseModel 在 pydantic 2 包中可用。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请确保模型的bind_tools方法 正确处理了JSON Schema和Pydantic V1模型。 langchain_core实现了一个实用函数，可以适应 大多数格式：https://python.langchain.com/api_reference/core/utils/langchain_core.utils.function_calling.convert_to_openai_tool.html

查看with_structured_output的示例实现：https://python.langchain.com/api_reference/_modules/langchain_openai/chat_models/base.html#BaseChatOpenAI.with_structured_output

Parameters:

模型 (BaseChatModel)

Return type:

无

test_tool_calling(model: BaseChatModel) → None[source]#

测试模型是否生成工具调用。如果测试类上的has_tool_calling属性设置为False，则跳过此测试。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查bind_tools是否已正确实现，将LangChain工具对象转换为适合您的聊天模型的相应模式。

如果聊天模型不支持tool_choice参数，此测试可能会失败。此参数可用于强制工具调用。如果不支持tool_choice并且模型始终无法通过此测试，您可以将测试标记为xfail：

@pytest.mark.xfail(reason=("Does not support tool_choice."))
def test_tool_calling(self, model: BaseChatModel) -> None:
    super().test_tool_calling(model)

否则，请确保在测试类上正确指定了tool_choice_value属性。

Parameters:

模型 (BaseChatModel)

Return type:

无

async test_tool_calling_async(model: BaseChatModel) → None[source]#

测试模型是否生成工具调用。如果测试类上的has_tool_calling属性设置为False，则跳过此测试。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查bind_tools是否已正确实现，将LangChain工具对象转换为适合您的聊天模型的相应模式。

如果聊天模型不支持tool_choice参数，此测试可能会失败。此参数可用于强制工具调用。如果不支持tool_choice并且模型始终无法通过此测试，您可以将测试标记为xfail：

@pytest.mark.xfail(reason=("Does not support tool_choice."))
async def test_tool_calling_async(self, model: BaseChatModel) -> None:
    await super().test_tool_calling_async(model)

否则，请确保在测试类上正确指定了tool_choice_value属性。

Parameters:

模型 (BaseChatModel)

Return type:

无

test_tool_calling_with_no_arguments(model: BaseChatModel) → None[source]#

测试模型是否为没有参数的生成工具调用。 如果测试类上的has_tool_calling属性设置为False，则跳过此测试。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查bind_tools是否已正确实现，将LangChain工具对象转换为适合您的聊天模型的模式。它应正确处理工具没有参数的情况。

如果聊天模型不支持tool_choice参数，此测试可能会失败。此参数可用于强制工具调用。如果提供者不支持这种形式的工具，也可能会失败。在这些情况下，您可以将测试标记为xfail：

@pytest.mark.xfail(reason=("Does not support tool_choice."))
def test_tool_calling_with_no_arguments(self, model: BaseChatModel) -> None:
    super().test_tool_calling_with_no_arguments(model)

否则，请确保在测试类上正确指定了tool_choice_value属性。

Parameters:

模型 (BaseChatModel)

Return type:

无

test_tool_message_error_status(model: BaseChatModel, my_adder_tool: BaseTool) → None[source]#

测试可以处理带有status="error"的ToolMessage。

这些消息可能采取以下形式：

ToolMessage(
    "Error: Missing required argument 'b'.",
    name="my_adder_tool",
    tool_call_id="abc123",
    status="error",
)

如果可能，应该解析status字段并适当地传递给模型。

此测试是可选的，如果模型不支持工具调用（请参阅下面的配置），则应跳过。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查status字段在ToolMessage对象上是否被忽略或适当地传递给模型。

否则，请确保在测试类上正确指定了tool_choice_value属性。

Parameters:
Return type:

无

test_tool_message_histories_list_content(model: BaseChatModel, my_adder_tool: BaseTool) → None[source]#

测试消息历史记录是否与列表工具内容兼容 （例如Anthropic格式）。

这些消息历史将包括带有“工具使用”和内容块的AIMessage对象，例如，

[
    {"type": "text", "text": "Hmm let me think about that"},
    {
        "type": "tool_use",
        "input": {"fav_color": "green"},
        "id": "foo",
        "name": "color_picker",
    },
]

如果模型不支持工具调用，则应跳过此测试（请参阅下面的配置）。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查：

  1. 模型能够正确处理包含带有列表内容的AIMessage对象的消息历史。

  2. AIMessage 对象上的 tool_calls 属性被正确处理并以适当的格式传递给模型。

  3. 模型可以正确处理带有字符串内容的ToolMessage对象，并且可以为tool_call_id处理任意字符串值。

如果工具调用已实现但不支持此格式，您可以将测试标记为xfail。

@pytest.mark.xfail(reason=("Not implemented."))
def test_tool_message_histories_list_content(self, *args: Any) -> None:
    super().test_tool_message_histories_list_content(*args)
Parameters:
Return type:

无

test_tool_message_histories_string_content(model: BaseChatModel, my_adder_tool: BaseTool) → None[source]#

测试消息历史记录是否与字符串工具内容兼容（例如，OpenAI格式）。如果模型通过此测试，它应该与遵循OpenAI格式的提供者生成的消息兼容。

如果模型不支持工具调用，则应跳过此测试（请参阅下面的配置）。

Configuration

要禁用工具调用测试，请在您的测试类中将 has_tool_calling 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False
Troubleshooting

如果此测试失败，请检查：

  1. 模型可以正确处理包含AIMessage对象的消息历史记录，这些对象的""内容。

  2. AIMessage 对象上的 tool_calls 属性被正确处理并以适当的格式传递给模型。

  3. 模型可以正确处理带有字符串内容的ToolMessage对象，并且可以为tool_call_id处理任意字符串值。

如果工具调用已实现但不支持此格式，您可以将测试标记为xfail。

@pytest.mark.xfail(reason=("Not implemented."))
def test_tool_message_histories_string_content(self, *args: Any) -> None:
    super().test_tool_message_histories_string_content(*args)
Parameters:
Return type:

无

test_usage_metadata(model: BaseChatModel) → None[源代码]#

测试以验证模型返回正确的使用元数据。

此测试是可选的，如果模型未返回使用元数据（请参阅下面的配置），则应跳过。

Configuration

默认情况下，此测试会运行。 要禁用此功能，请在您的测试类中将 returns_usage_metadata 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def returns_usage_metadata(self) -> bool:
        return False

此测试还可以根据supported_usage_metadata_details属性检查特定类型使用元数据的格式。此属性应按以下方式配置，包含模型支持跟踪的令牌类型：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supported_usage_metadata_details(self) -> dict:
        return {
            "invoke": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
            "stream": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
        }
Troubleshooting

如果此测试失败，首先请验证您的模型是否返回了附加到_generate中返回的AIMessage对象的UsageMetadata字典：

return ChatResult(
    generations=[ChatGeneration(
        message=AIMessage(
            content="Output text",
            usage_metadata={
                "input_tokens": 350,
                "output_tokens": 240,
                "total_tokens": 590,
                "input_token_details": {
                    "audio": 10,
                    "cache_creation": 200,
                    "cache_read": 100,
                },
                "output_token_details": {
                    "audio": 10,
                    "reasoning": 200,
                }
            }
        )
    )]
)
Parameters:

模型 (BaseChatModel)

Return type:

无

test_usage_metadata_streaming(model: BaseChatModel) → None[source]#

测试以验证模型在流模式下返回正确的使用元数据。

Configuration

默认情况下，此测试会运行。 要禁用此功能，请在您的测试类中将 returns_usage_metadata 设置为 False：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def returns_usage_metadata(self) -> bool:
        return False

此测试还可以根据supported_usage_metadata_details属性检查特定类型使用元数据的格式。此属性应按如下方式配置，包含模型支持跟踪的令牌类型：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supported_usage_metadata_details(self) -> dict:
        return {
            "invoke": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
            "stream": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
        }
Troubleshooting

如果此测试失败，首先请验证您的模型是否生成了附加到返回的AIMessage对象中的_stream的UsageMetadata字典，这些字典汇总了总的使用元数据。

请注意，input_tokens 应该只包含在一个块中（通常是第一个或最后一个块），其余的块应该为 0 或 None，以避免多次计算输入令牌。

output_tokens 通常计算每个块中的令牌数量，而不是总和。只要所有块中的 output_tokens 的总和不为0，此测试将通过。

yield ChatResult(
    generations=[ChatGeneration(
        message=AIMessage(
            content="Output text",
            usage_metadata={
                "input_tokens": (
                    num_input_tokens if is_first_chunk else 0
                ),
                "output_tokens": 11,
                "total_tokens": (
                    11+num_input_tokens if is_first_chunk else 11
                ),
                "input_token_details": {
                    "audio": 10,
                    "cache_creation": 200,
                    "cache_read": 100,
                },
                "output_token_details": {
                    "audio": 10,
                    "reasoning": 200,
                }
            }
        )
    )]
)
Parameters:

模型 (BaseChatModel)

Return type:

无