模型选择

本地模型

ollama安装

 https://ollama.com/download

下载好安装模型  量力而安装 我安装的是 https://ollama.com/library/qwen2.5:1.5b

ollama run qwen2.5:1.5b

测试

在线模型

可选择去阿里百炼获取

https://bailian.console.aliyun.com/cn-beijing/?tab=model#/model-market

调用模型

依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.5.8</version>
        </dependency>

        <!-- Spring AI Alibaba Agent Framework -->
        <dependency>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-agent-framework</artifactId>
            <version>1.1.2.0</version>
        </dependency>

        <!-- DashScope ChatModel 支持（如果使用其他模型，请跳转 Spring AI 文档选择对应的 starter） -->
        <dependency>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
            <version>1.1.2.0</version>
        </dependency>

配置

server:
  port: 8080
spring:
  ai:
    dashscope:
      api-key: ${apiKey}

编写controller

package com.cyz.controller;

import org.springframework.ai.chat.model.ChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

@RestController
public class ChatController {
    @Autowired
    private ChatModel chatModel;

    @GetMapping("/chat")
    public String chat(@RequestParam("input") String input) {
        return chatModel.call(input);
    }

    @GetMapping("/stream")
    public Flux<String> stream(@RequestParam("input") String input) {
        return chatModel.stream(input);
    }
}

测试

阻塞式

流式

源码分析

查找自动配置类

我们使用的是对话模型，所以看 DashScopeChatAutoConfiguration 就行了

这边spring会为我们创建一个对话模型

查看DashScopeChatModel对话模型使用的是哪个模型

查看配置类

是qwen-plus

查看所有模型名称  DashScopeModel

如何自定义模型

改成 deepseek-r1

server:
  port: 8080
spring:
  ai:
    dashscope:
      api-key: ${apiKey}
      chat:
        options:
          model: deepseek-r1

为什么不需要配置baseUrl

由此可知不配就取默认的

类的继承关系

以对话模型为例

其他类型模型是类似的，都继承model类

每种模型都有对应的DashScopeXXXModel，如下

模型名称	作用
DashScopeChatModel	对话模型
EmbeddingModel	向量模型
DashScopeImageModel	图片模型
DashScopeVideoModel	视频模型
DashScopeAudioSpeechModel	文本to语音

Messages 消息

Messages 是 Spring AI Alibaba 中模型交互的基本单元。它们代表模型的输入和输出，携带在与 LLM 交互时表示对话状态所需的内容和元数据。

Messages 是包含以下内容的对象：

• Role（角色） - 标识消息类型（如 system、user、assistant）
• Content（内容） - 表示消息的实际内容（如文本、图像、音频、文档等）
• Metadata（元数据） - 可选字段，如响应信息、消息 ID 和 token 使用情况

Spring AI Alibaba 提供了一个标准的消息类型系统，可在所有模型提供商之间工作，确保无论调用哪个模型都具有一致的行为。

基础使用

文本类型

@GetMapping("/chat")
    public String chat(@RequestParam("input") String input) {
        return chatModel.call(input);
    }

系统角色+用户角色

    @GetMapping("/chat")
    public String chat(@RequestParam("input") String input) {
        SystemMessage systemMsg = new SystemMessage("你是编程助手,名字叫小编");
        UserMessage userMsg = new UserMessage(input);
        Prompt prompt=new Prompt(List.of(systemMsg,userMsg));
        return chatModel.call(prompt).getResult().getOutput().getText();
    }

系统角色+用户角色+辅助角色

    @GetMapping("/chat")
    public String chat(@RequestParam("input") String input) {
        SystemMessage systemMsg = new SystemMessage("你是编程助手,名字叫小编");
        UserMessage userMsg = new UserMessage(input);
        AssistantMessage assistantMessage = new AssistantMessage("你是个java程序员");
        Prompt prompt=new Prompt(List.of(systemMsg,userMsg,assistantMessage));
        return chatModel.call(prompt).getResult().getOutput().getText();
    }

  会用java语言回答

消息类型

• System Message（系统消息） - 告诉模型如何行为并为交互提供上下文
• User Message（用户消息） - 表示用户输入和与模型的交互
• Assistant Message（助手消息） - 模型生成的响应，包括文本内容、工具调用和元数据
• Tool Response Message（工具响应消息） - 表示工具调用的输出

System Message

SystemMessage 表示一组初始指令，用于引导模型的行为。你可以使用系统消息来设置语气、定义模型的角色并建立响应指南。

SystemMessage 基础指令示例

// 基础指令
SystemMessage systemMsg = new SystemMessage("你是一个有帮助的编程助手。");

List<org.springframework.ai.chat.messages.Message> messages = List.of(
systemMsg,
new UserMessage("如何创建 REST API？")
);
ChatResponse response = chatModel.call(new Prompt(messages));

SystemMessage 详细角色设定示例

// 详细的角色设定
SystemMessage systemMsg = new SystemMessage("""
你是一位资深的 Java 开发者，擅长 Web 框架。
始终提供代码示例并解释你的推理。
在解释中要简洁但透彻。
""");

List<org.springframework.ai.chat.messages.Message> messages = List.of(
systemMsg,
new UserMessage("如何创建 REST API？")
);
ChatResponse response = chatModel.call(new Prompt(messages));

User Message

UserMessage 表示用户输入和交互。它们可以包含文本、图像、音频、文件和任何其他数量的多模态内容。

文本内容

// 使用消息对象
ChatResponse response = chatModel.call(
new Prompt(List.of(new UserMessage("什么是机器学习？")))
);

// 使用字符串快捷方式
// 使用字符串是单个 UserMessage 的快捷方式
String response = chatModel.call("什么是机器学习？");

消息元数据

import java.util.Map;

UserMessage userMsg = UserMessage.builder()
.text("你好！")
.metadata(Map.of(
"user_id", "alice", // 可选：识别不同用户
"session_id", "sess_123" // 可选：会话标识符
))
.build();

注意：元数据字段的行为因提供商而异 - 有些用于用户识别，有些则忽略它。要检查，请参考模型提供商的文档。

多模态内容

UserMessage 可以包含多模态内容，如图像：

import org.springframework.ai.content.Media;
import org.springframework.util.MimeTypeUtils;
import java.net.URL;

// 从 URL 创建图像
UserMessage userMsg = UserMessage.builder()
.text("描述这张图片的内容。")
.media(Media.builder()
.mimeType(MimeTypeUtils.IMAGE_JPEG)
.data(new URL("https://example.com/image.jpg"))
.build())
.build();

Assistant Message

AssistantMessage 表示模型调用的输出。它们可以包括多模态数据、工具调用以及你稍后可以访问的提供商特定元数据。

AssistantMessage 基础使用示例

ChatResponse response = chatModel.call(new Prompt("解释 AI"));
AssistantMessage aiMessage = response.getResult().getOutput();
System.out.println(aiMessage.getText());

AssistantMessage 对象由模型调用返回，其中包含响应中的所有相关元数据。

提供商对消息类型的权重/上下文化方式不同，这意味着有时手动创建新的 AssistantMessage 对象并将其插入消息历史中（就像它来自模型一样）会很有帮助。

手动创建 AssistantMessage 示例

import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.messages.UserMessage;

// 手动创建 AI 消息（例如，用于对话历史）
AssistantMessage aiMsg = new AssistantMessage("我很乐意帮助你回答这个问题！");

// 添加到对话历史
List<org.springframework.ai.chat.messages.Message> messages = List.of(
new SystemMessage("你是一个有帮助的助手"),
new UserMessage("你能帮我吗？"),
aiMsg, // 插入，就像它来自模型一样
new UserMessage("太好了！2+2 等于多少？")
);

ChatResponse response = chatModel.call(new Prompt(messages));

AssistantMessage 属性：

• text: 消息的文本内容
• metadata: 消息的元数据映射
• toolCalls: 模型进行的工具调用列表
• media: 媒体内容列表（如果有）

工具调用

当模型进行工具调用时，它们包含在 AssistantMessage 中：

import org.springframework.ai.chat.messages.AssistantMessage.ToolCall;

ChatResponse response = chatModel.call(prompt);
AssistantMessage aiMessage = response.getResult().getOutput();

if (aiMessage.hasToolCalls()) {
  for (ToolCall toolCall : aiMessage.getToolCalls()) {
      System.out.println("Tool: " + toolCall.name());
      System.out.println("Args: " + toolCall.arguments());
      System.out.println("ID: " + toolCall.id());
  }
}

Token 使用

Spring AI Alibaba 的 ChatResponse 可以在其元数据中保存 token 计数和其他使用元数据：

ChatResponse response = chatModel.call(new Prompt("你好！"));
ChatResponseMetadata metadata = response.getMetadata();

// 访问使用信息
if (metadata != null && metadata.getUsage() != null) {
  System.out.println("Input tokens: " + metadata.getUsage().getPromptTokens());
  System.out.println("Output tokens: " + metadata.getUsage().getCompletionTokens());
  System.out.println("Total tokens: " + metadata.getUsage().getTotalTokens());
}

流式和块

在流式传输期间，你将收到可以组合成完整消息对象的块：

import reactor.core.publisher.Flux;

Flux<ChatResponse> responseStream = chatModel.stream(new Prompt("你好"));

StringBuilder fullResponse = new StringBuilder();
responseStream.subscribe(
  chunk -> {
      String content = chunk.getResult().getOutput().getText();
      fullResponse.append(content);
      System.out.print(content);
  }
);

Tool Response Message

对于支持工具调用的模型，AI 消息可以包含工具调用。工具消息用于将单个工具执行的结果传回模型。

import org.springframework.ai.chat.messages.ToolResponseMessage;
import org.springframework.ai.chat.messages.ToolResponseMessage.ToolResponse;

// 在模型进行工具调用后
AssistantMessage aiMessage = AssistantMessage.builder()
  .content("")
  .toolCalls(List.of(
      new AssistantMessage.ToolCall(
          "call_123",
          "tool",
          "get_weather",
          "{"location": "San Francisco"}"
      )
  ))
  .build();

// 执行工具并创建结果消息
String weatherResult = "晴朗，22°C";
ToolResponseMessage toolMessage = ToolResponseMessage.builder()
  .responses(List.of(
      new ToolResponse("call_123", "get_weather", weatherResult)
  ))
  .build();

// 继续对话
List<org.springframework.ai.chat.messages.Message> messages = List.of(
  new UserMessage("旧金山的天气怎么样？"),
  aiMessage,      // 模型的工具调用
  toolMessage     // 工具执行结果
);
ChatResponse response = chatModel.call(new Prompt(messages));

ToolResponseMessage 属性：

• responses: ToolResponse 对象列表，每个包含：
  • id: 工具调用 ID（必须与 AIMessage 中的工具调用 ID 匹配）
  • name: 调用的工具名称
  • responseData: 工具调用的字符串化输出

多模态内容

多模态性指的是处理不同形式数据的能力，如文本、音频、图像和视频。Spring AI Alibaba 包含这些数据的标准类型，可以跨提供商使用。

聊天模型可以接受多模态数据作为输入并生成它作为输出。下面我们展示包含多模态数据的输入消息的简短示例。

图像输入

import org.springframework.ai.content.Media;
import org.springframework.util.MimeTypeUtils;
import java.net.URL;

// 从 URL
UserMessage message = UserMessage.builder()
  .text("描述这张图片的内容。")
  .media(Media.builder()
      .mimeType(MimeTypeUtils.IMAGE_JPEG)
      .data(new URL("https://example.com/image.jpg"))
      .build())
  .build();

// 从本地文件
import org.springframework.core.io.ClassPathResource;

UserMessage message = UserMessage.builder()
  .text("描述这张图片的内容。")
  .media(new Media(
      MimeTypeUtils.IMAGE_JPEG,
      new ClassPathResource("images/photo.jpg")
  ))
  .build();

音频输入

import org.springframework.ai.content.Media;
import org.springframework.util.MimeTypeUtils;

UserMessage message = UserMessage.builder()
  .text("描述这段音频的内容。")
  .media(new Media(
      MimeTypeUtils.parseMimeType("audio/wav"),
      new ClassPathResource("audio/recording.wav")
  ))
  .build();

视频输入

import org.springframework.ai.content.Media;
import org.springframework.util.MimeTypeUtils;

UserMessage message = UserMessage.builder()
  .text("描述这段视频的内容。")
  .media(Media.builder()
      .mimeType(MimeTypeUtils.parseMimeType("video/mp4"))
      .data(new URL("https://example.com/path/to/video.mp4"))
      .build())
  .build();

与 Chat Models 一起使用

Chat models 接受消息对象序列作为输入并返回 ChatResponse（包含 AssistantMessage）作为输出。交互通常是无状态的，因此简单的对话循环涉及使用不断增长的消息列表调用模型。

基础对话示例

import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.ai.chat.prompt.Prompt;
import java.util.ArrayList;
import java.util.List;

ChatModel chatModel = // ... 初始化

List<Message> conversationHistory = new ArrayList<>();

// 第一轮对话
conversationHistory.add(new UserMessage("你好！"));
ChatResponse response1 = chatModel.call(new Prompt(conversationHistory));
conversationHistory.add(response1.getResult().getOutput());

// 第二轮对话
conversationHistory.add(new UserMessage("你能帮我学习 Java 吗？"));
ChatResponse response2 = chatModel.call(new Prompt(conversationHistory));
conversationHistory.add(response2.getResult().getOutput());

// 第三轮对话
conversationHistory.add(new UserMessage("从哪里开始？"));
ChatResponse response3 = chatModel.call(new Prompt(conversationHistory));

使用 Builder 模式

Spring AI Alibaba 的消息类提供了 builder 模式以便于构建：

// UserMessage with builder
UserMessage userMsg = UserMessage.builder()
  .text("你好，我想学习 Spring AI Alibaba")
  .metadata(Map.of("user_id", "user_123"))
  .build();

// SystemMessage with builder
SystemMessage systemMsg = SystemMessage.builder()
  .text("你是一个 Spring 框架专家")
  .metadata(Map.of("version", "1.0"))
  .build();

// AssistantMessage with builder
AssistantMessage assistantMsg = AssistantMessage.builder()
  .content("我很乐意帮助你学习 Spring AI Alibaba！")
  .build();

消息复制和修改

// 复制消息
UserMessage original = new UserMessage("原始消息");
UserMessage copy = original.copy();

// 使用 mutate 创建修改的副本
UserMessage modified = original.mutate()
  .text("修改后的消息")
  .metadata(Map.of("modified", true))
  .build();

在 ReactAgent 中使用

ReactAgent 自动管理消息历史，但你也可以直接使用消息：

import com.alibaba.cloud.ai.graph.agent.ReactAgent;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.messages.AssistantMessage;

ReactAgent agent = ReactAgent.builder()
  .name("my_agent")
  .model(chatModel)
  .systemPrompt("你是一个有帮助的助手")
  .build();

// 使用字符串
AssistantMessage response1 = agent.call("你好");

// 使用 UserMessage
UserMessage userMsg = new UserMessage("帮我写一首诗");
AssistantMessage response2 = agent.call(userMsg);

// 使用消息列表
List<Message> messages = List.of(
  new UserMessage("我喜欢春天"),
  new UserMessage("写一首关于春天的诗")
);
AssistantMessage response3 = agent.call(messages);

Tools

许多 AI 应用程序通过自然语言与用户交互。然而，某些业务场景需要模型使用结构化输入直接与外部系统（如 API、数据库或文件系统）进行交互。

Tools 是 agents 调用来执行操作的组件。它们通过定义良好的输入和输出让模型与外部世界交互，从而扩展模型的能力。Tools 封装了一个可调用的函数及其输入模式。我们可以把工具定义传递给兼容的 models，允许模型决定是否调用工具以及使用什么参数。在这些场景中，工具调用使模型能够生成符合指定输入模式的请求。

快速开始

让我们看看如何在 Spring AI 中开始使用 tool calling。我们将实现两个简单的 tools：一个用于信息检索，一个用于执行操作。

信息检索

AI model 无法访问实时信息。任何假设了解当前日期或天气预报等信息的问题都无法由 model 回答。但是，我们可以提供一个可以检索此信息的 tool，并让 model 在需要访问实时信息时调用此 tool。

让我们在 DateTimeTools 类中实现一个 tool 来获取用户时区的当前日期和时间。该 tool 不接受任何参数。来自 Spring Framework 的 LocaleContextHolder 可以提供用户的时区。该 tool 将定义为用 @Tool 注解的方法。为了帮助 model 理解是否以及何时调用此 tool，我们将提供该 tool 功能的详细描述。

package com.cyz.tool;

import org.springframework.ai.tool.annotation.Tool;
import org.springframework.context.i18n.LocaleContextHolder;

import java.time.LocalDateTime;

public class DateTimeTools {
    @Tool(description = "获取当前时间")
    String getCurrentDateTime() {
        return LocalDateTime.now().atZone(LocaleContextHolder.getTimeZone().toZoneId()).toString();
    }
}

接下来，让我们使 tool 可用于 model。在此示例中，我们将使用 ChatClient 与 model 交互。我们将通过 tools() 方法传递 DateTimeTools 的实例来向 model 提供 tool。当 model 需要知道当前日期和时间时，它将请求调用 tool。在内部，ChatClient 将调用 tool 并将结果返回给 model，然后 model 将使用 tool call 结果生成对原始问题的最终响应。

    @GetMapping("/chatWithTools")
    public String chatWithTools(@RequestParam("input") String input) {
        return ChatClient.create(chatModel)
                .prompt(input)
                .tools(new DateTimeTools())
                .call().content();
    }

多个tools调用

定义tools

package com.cyz.tool;

import org.springframework.ai.tool.annotation.Tool;

import java.util.Arrays;
import java.util.List;

public class MyTools {
    @Tool(description = "查询学校中有哪些班级")
    List<String> getMyClass(String schoolName) {
        return switch (schoolName) {
            case "清华学校" -> Arrays.asList("清华一班", "清华二班");
            case "北大学校" -> Arrays.asList("北大一班", "北大二班");
            default -> List.of();
        };
    }

    @Tool(description = "查询班级人数")
    Integer getNumByClass(String className) {
        System.out.println(className);
        return switch (className) {
            case "清华一班" -> 10;
            case "清华二班" -> 20;
            case "北大一班" -> 50;
            case "北大二班" -> 100;
            default -> 0;
        };
    }

    @Tool(description = "查询每个学生一年的学费")
    String getFeel() {
        return "50元每人";
    }
}

配置controller

    @GetMapping("/chatWithTools")
    public String chatWithTools(@RequestParam("input") String input) {
        SystemMessage systemMsg = new SystemMessage("尽量调用工具获取信息,不要胡编乱造");
        UserMessage userMsg = new UserMessage(input);
        Prompt prompt=new Prompt(List.of(systemMsg,userMsg));
        return ChatClient.create(chatModel)
                .prompt(prompt)
                .tools(new MyTools())
                .call().content();
    }

测试

概述

Spring AI 通过一组灵活的抽象支持 tool calling，允许您以一致的方式定义、解析和执行 tools。本节概述了 Spring AI 中 tool calling 的主要概念和组件。

1. 当我们想要使 tool 可用于 model 时，我们在聊天请求中包含其定义。每个 tool 定义包括名称、描述和输入参数的 schema。
2. 当 model 决定调用 tool 时，它发送带有 tool 名称和根据定义 schema 建模的输入参数的响应。
3. 应用程序负责使用 tool 名称来识别并使用提供的输入参数执行 tool。
4. Tool call 的结果由应用程序处理。
5. 应用程序将 tool call 结果发送回 model。
6. Model 使用 tool call 结果作为附加上下文生成最终响应。

Tools 是 tool calling 的构建块，它们由 ToolCallback 接口建模。Spring AI 提供了从方法和函数指定 ToolCallback(s) 的内置支持，但您始终可以定义自己的 ToolCallback 实现以支持更多用例。

ChatModel 实现透明地将 tool call 请求分派到相应的 ToolCallback 实现，并将 tool call 结果发送回 model，最终生成最终响应。它们使用 ToolCallingManager 接口来执行此操作，该接口负责管理 tool 执行生命周期。

ChatClient 和 ChatModel 都接受 ToolCallback 对象列表，以使 tools 可用于 model 和最终执行它们的 ToolCallingManager。

除了直接传递 ToolCallback 对象外，您还可以传递 tool 名称列表，这些名称将使用 ToolCallbackResolver 接口动态解析。

创建工具

Spring AI 提供了两种从方法指定 tools（即 ToolCallback(s)）的内置支持：

• 声明式，使用 @Tool 注解
• 编程式，使用低级 MethodToolCallback 实现。

方法作为 Tools

声明式规范：@Tool

您可以通过用 @Tool 注解方法来将方法转换为 tool。

class DateTimeTools {

  @Tool(description = "Get the current date and time in the user's timezone")
  String getCurrentDateTime() {
      return LocalDateTime.now().atZone(LocaleContextHolder.getTimeZone().toZoneId()).toString();
  }

}

@Tool 注解允许您提供有关 tool 的关键信息：

• name：tool 的名称。如果未提供，将使用方法名称。AI model 使用此名称在调用时识别 tool。因此，不允许在同一类中有两个同名 tools。名称必须在特定聊天请求中提供给 model 的所有 tools 中唯一。
• description：tool 的描述，model 可以使用它来理解何时以及如何调用 tool。如果未提供，方法名称将用作 tool 描述。但是，强烈建议提供详细描述，因为这对于 model 理解 tool 的用途以及如何使用它至关重要。未能提供良好的描述可能导致 model 在应该使用时不使用 tool 或错误使用它。
• returnDirect：tool 结果是否应直接返回给客户端或传递回 model。有关更多详细信息，请参阅 返回直接。
• resultConverter：用于将 tool call 的结果转换为 String object 以发送回 AI model 的 ToolCallResultConverter 实现。有关更多详细信息，请参阅 结果转换。

方法可以是静态的或实例的，并且可以具有任何可见性（public、protected、package-private 或 private）。包含方法的类可以是顶级类或嵌套类，也可以具有任何可见性（只要在您计划实例化它的地方可以访问）。

NOTE: Spring AI 为 @Tool 注解方法的 AOT 编译提供内置支持，只要包含方法的类是 Spring bean（例如 @Component）。否则，您需要向 GraalVM 编译器提供必要的配置。例如，通过用 @RegisterReflection(memberCategories = MemberCategory.INVOKE_DECLARED_METHODS) 注解类。

您可以为方法定义任意数量的参数（包括无参数），支持大多数类型（基元、POJO、枚举、列表、数组、映射等）。同样，方法可以返回大多数类型，包括 void。如果方法返回值，返回类型必须是可序列化类型，因为结果将被序列化并发送回 model。

NOTE: 某些类型不受支持。有关更多详细信息，请参阅 方法 Tool 限制。

Spring AI 将自动为 @Tool 注解方法的输入参数生成 JSON schema。Schema 由 model 用于理解如何调用 tool 并准备 tool 请求。@ToolParam 注解可用于提供有关输入参数的附加信息，例如描述或参数是必需还是可选的。默认情况下，所有输入参数都被视为必需。

使用 @ToolParam 注解示例

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;

class DateTimeTools {

@Tool(description = "Set a user alarm for the given time")
void setAlarm(@ToolParam(description = "Time in ISO-8601 format") String time) {
LocalDateTime alarmTime = LocalDateTime.parse(time, DateTimeFormatter.ISO_DATE_TIME);
System.out.println("Alarm set for " + alarmTime);
}

}

@ToolParam 注解允许您提供有关 tool 参数的关键信息：

• description：参数的描述，model 可以使用它来更好地理解如何使用它。例如，参数应该是什么格式，允许什么值等。
• required：参数是必需还是可选的。默认情况下，所有参数都被视为必需。

如果参数用 @Nullable 注解，除非使用 @ToolParam 注解明确标记为必需，否则将被视为可选。

除了 @ToolParam 注解外，您还可以使用来自 Swagger 的 @Schema 注解或来自 Jackson 的 @JsonProperty。有关更多详细信息，请参阅 JSON Schema。

编程式规范：MethodToolCallback

您可以通过编程方式构建 MethodToolCallback 来将方法转换为 tool。

待更新