在前面 Spring AI 工具（Tool）调用 我们通过“获取当前日期和时间”与“设置距当前 10 分钟的闹钟”示例介绍了如何在 Spring AI 中使用工具调用，对工具调用有了一个粗浅的认识，下面将进一步进行介绍，加深对工具调用的认识。
在 Spring AI 中，通过一组灵活的抽象机制支持工具调用功能，这些抽象允许你以统一的方式定义、解析和执行工具。本节将概述 Spring AI 中工具调用的核心概念与组件构成。
Spring AI 工具调用流程图如下：
上图说明：
① 当我们想让模型使用某个工具时，我们会在聊天请求中包含该工具的定义。每个工具的定义都包括名称（name）、描述（description）和输入参数的模式（input schema）。
② 当模型决定调用工具时，它会发送包含工具名称及符合预定义模式的输入参数的响应。
③ 应用程序负责根据工具名称识别对应工具，并使用提供的输入参数执行该工具。
④ 工具调用的结果由应用程序进行处理。
⑤ 应用程序将工具调用结果返回至模型。
⑥ 模型最终利用工具调用结果作为附加上下文生成响应。
Tool 是工具调用的基础构建单元，通过 ToolCallback 接口进行建模。Spring AI 内置支持从方法和函数生成 ToolCallback，同时你还可以自定义 ToolCallback 实现以满足更多使用场景。内置支持如下图：
上述 TooCallback 实现简单说明：
FunctionToolCallback 用于将函数形式的工具能力适配到 ToolCallback 接口规范中。它可以把具体的函数封装起来，让 Spring AI 体系能够识别和调用，实现通过函数来完成工具侧的功能执行。
MethodToolCallback 针对方法进行适配。可以把某个类的特定方法封装成符合 ToolCallback 接口的形式，这样就能让 Spring AI 在需要调用工具时，通过调用该方法来完成相应功能。
AsyncMcpToolCallback 用于异步场景下与 MCP 相关的工具调用适配。它支持以异步的方式去和 MCP 进行交互，在调用工具时不会阻塞当前线程，能够非同步地执行获取结果，适合处理那些耗时较长、不需要立即拿到返回，或者希望不影响主流程执行的与 MCP 相关的工具调用任务，比如异步从 MCP 拉取数据、异步执行 MCP 相关的业务逻辑等。
SyncMcpToolCallback 和上面的 AsyncMcpToolCallback 对应，是同步方式与 MCP 相关的工具调用适配。在调用和 MCP 关联的工具功能时，会阻塞当前线程，直到从 MCP 拿到执行结果返回，适用于那些需要立即获取 MCP 交互结果，且当前流程可以等待的场景，比如同步调用 MCP 接口获取实时业务数据、同步执行 MCP 相关的关键业务逻辑并等待响应等 。
在 Spring AI 中，ChatModel 实现类会透明地将工具调用请求转发给对应的 ToolCallback 实现，并将工具调用结果返回给 AI 模型以生成最终响应。注意，工具调用过程是通过 ToolCallingManager 接口实现，该接口负责管理工具执行的完整生命周期。
ChatClient 和 ChatModel 均可接收 ToolCallback 对象列表，向 AI 模型提供可用工具集，也向最终执行这些工具的 ToolCallingManager 提供支持。
除直接传递 ToolCallback 对象外，你还可传递工具名称列表，这些名称将通过 ToolCallbackResolver 接口进行动态解析。
下面介绍 Spring AI 为工具调用提供的核心接口，以及这些接口的用途。
ToolCallback 是 Spring AI 1.0 中定义的工具回调接口，为 AI 模型与外部工具的交互提供了标准契约。其核心作用是规范工具的描述信息和调用方式，使 AI 模型能够统一地识别、调用各类外部工具。
接口主要包含以下核心内容：
工具定义信息：通过 getToolDefinition() 方法提供工具的基本信息（如名称、描述、参数规范等），帮助 AI 模型理解工具功能。
工具元数据：默认通过 getToolMetadata() 方法返回附加信息（如作者、版本等），子类可按需重写扩展。
工具调用方法：通过 call() 方法调用工具，它接收输入参数并返回工具处理结果。接口中定义了两个 call 方法，分别是 call(String toolInput) 和 call(String toolInput, @Nullable ToolContext tooContext)，唯一的区别是一个接收 ToolContext，另一个不接收。默认不支持 ToolContext（传入非空 ToolContext 会抛异常），子类可重写以实现 ToolContext 感知的工具调用。
通过实现该接口，各类工具可被 Spring AI 体系识别和调用，成为 AI 模型处理任务时的扩展能力。接口定义如下：
package org.springframework.ai.tool;
import org.springframework.ai.chat.model.ToolContext;
import org.springframework.ai.tool.definition.ToolDefinition;
import org.springframework.ai.tool.metadata.ToolMetadata;
import org.springframework.lang.Nullable;
public interface ToolCallback {
/**
* 获取工具的定义信息
* 工具定义通常包含工具名称、描述、参数信息等元数据，用于AI模型理解工具功能
*
* @return 工具定义对象，包含工具的基本信息和参数规范
*/
ToolDefinition getToolDefinition();
/**
* 获取工具的元数据信息
* 元数据可以包含更详细的工具描述、作者、版本等附加信息
* 默认实现返回一个空的元数据对象，子类可以根据需要重写
*
* @return 工具元数据对象
*/
default ToolMetadata getToolMetadata() {
return ToolMetadata.builder().build();
}
/**
* 调用工具并返回处理结果
* 这是工具执行的核心方法，接收输入参数并返回处理后的字符串结果
*
* @param toolInput 工具的输入参数，通常是符合工具定义的结构化数据（如JSON）
* @return 工具处理后的结果，以字符串形式返回
*/
String call(String toolInput);
/**
* 带上下文的工具调用方法
* 支持在调用工具时传入上下文信息，默认实现不支持上下文，如传入非空上下文会抛出异常
* 子类可以重写此方法以实现对上下文的支持
*
* @param toolInput 工具的输入参数
* @param tooContext 工具调用的上下文信息，可能包含对话历史、环境变量等
* @return 工具处理后的结果
* @throws UnsupportedOperationException 如果不支持上下文则抛出此异常
*/
default String call(String toolInput, @Nullable ToolContext tooContext) {
// 检查是否有上下文信息需要处理
if (tooContext != null && !tooContext.getContext().isEmpty()) {
throw new UnsupportedOperationException("Tool context is not supported!");
} else {
// 没有上下文时调用无参call方法
return this.call(toolInput);
}
}
}注意，Spring AI 已经为工具方法（MethodToolCallback）和工具函数（FunctionToolCallback）提供了内置实现。
ToolCallingManager 接口扮演着工具调用协调者的关键角色，主要负责管理和执行 AI 模型调用外部工具的整个流程，它让 AI 模型与外部工具之间的交互更加有序和规范。
接口定义如下：
package org.springframework.ai.model.tool;
import java.util.List;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.tool.definition.ToolDefinition;
public interface ToolCallingManager {
/**
* 该方法用于确定在当前对话上下文中，哪些工具可以被AI模型调用
*
* @param chatOptions 聊天选项，可能包含工具调用的配置参数、启用的工具列表等
* @return 可用工具的定义列表，每个定义包含工具的名称、描述、参数规范等信息
*/
List<ToolDefinition> resolveToolDefinitions(ToolCallingChatOptions chatOptions);
/**
* 执行工具调用并返回执行结果
* 当AI模型决定调用工具时，通过此方法执行实际的工具调用逻辑，并将结果返回给后续处理流程
*
* @param prompt 触发工具调用的提示词，包含用户输入和对话上下文
* @param chatResponse AI模型的响应，其中可能包含工具调用的指令（如调用哪个工具、传入什么参数）
* @return 工具执行结果对象，包含调用状态、返回数据等信息
*/
ToolExecutionResult executeToolCalls(Prompt prompt, ChatResponse chatResponse);
/**
* 创建默认工具调用管理器的构建器
* 提供了一种便捷的方式来构建 DefaultToolCallingManager 实例
*
* @return DefaultToolCallingManager 的构建器对象
*/
static DefaultToolCallingManager.Builder builder() {
return DefaultToolCallingManager.builder();
}
}ToolCallbackResolver 接口主要用于在工具调用流程中，根据工具名称来解析并获取对应的 ToolCallback 实例。在工具调用流程中，起到工具名称与实际工具实现之间的映射桥梁作用。
接口定义如下：
package org.springframework.ai.tool.resolution;
import org.springframework.ai.tool.ToolCallback;
import org.springframework.lang.Nullable;
public interface ToolCallbackResolver {
/**
* 根据工具名称解析对应的 ToolCallback 实例
* 当AI模型需要调用指定名称的工具时，通过此方法获取实际执行该工具功能的 ToolCallback 实现
*
* @param toolName 工具的名称，用于唯一标识某个工具
* @return 对应的 ToolCallback 实例；如果未找到匹配的工具，则返回 null
*/
@Nullable
ToolCallback resolve(String toolName);
}ToolDefinition 接口是工具元信息的核心定义接口，用于描述一个工具的基本信息、功能特性和参数规范，帮助 AI 模型理解工具的作用和使用方式。它是 AI 模型与工具之间的“说明书”，是工具调用流程中不可或缺的元数据载体。
接口定义如下：
package org.springframework.ai.tool.definition;
public interface ToolDefinition {
/**
* 工具的唯一名称
* 在AI模型可访问的工具集合中，该名称需保持唯一性，用于精准定位和调用工具
* @return 工具的名称字符串
*/
String name();
/**
* 详细说明工具的用途和能力，帮助AI模型判断该工具是否适用于当前任务
* @return 工具的功能描述字符串
*/
String description();
/**
* 工具输入参数的 schema 定义
* 通常以JSON Schema格式描述参数的结构、类型、约束等信息，指导AI模型正确构造调用参数
* @return 输入参数的schema字符串（一般为JSON Schema格式）
*/
String inputSchema();
/**
* 创建默认工具定义实现类的构建器
* 提供便捷的方式来构建 DefaultToolDefinition 实例，简化工具定义的创建过程
* @return DefaultToolDefinition的构建器对象
*/
static DefaultToolDefinition.Builder builder() {
return DefaultToolDefinition.builder();
}
}ToolDefinition.Builder 允许你使用默认实现（DefaultToolDefinition）构建 ToolDefinition 实例，如下：
ToolDefinition toolDefinition = ToolDefinition.builder()
.name("currentWeather")
.description("Get the weather in location")
.inputSchema("""
{
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["C", "F"]
}
},
"required": ["location", "unit"]
}
""")
.build();基于方法构建工具时，ToolDefinition 不会自动生成。需要自己创建，源码如下：
public final class MethodToolCallback implements ToolCallback {
//...
public static final class Builder {
private ToolDefinition toolDefinition;
private ToolMetadata toolMetadata;
private Method toolMethod;
private Object toolObject;
private ToolCallResultConverter toolCallResultConverter;
private Builder() {
}
// 设置自己创建的 ToolDefinition
public Builder toolDefinition(ToolDefinition toolDefinition) {
this.toolDefinition = toolDefinition;
return this;
}
//...
public MethodToolCallback build() {
// 实例化MethodToolCallback
return new MethodToolCallback(this.toolDefinition, this.toolMetadata,
this.toolMethod, this.toolObject, this.toolCallResultConverter);
}
}
}基于函数构建工具时，ToolDefinition 会自动生成。当使用 FunctionToolCallback.Builder 构建 FunctionToolCallback 实例时，可指定用于生成 ToolDefinition 的工具名称、描述及输入模式。然后，由 FunctionToolCallback 帮我们创建 ToolDefinition 对象。
源码如下：
public class FunctionToolCallback<I, O> implements ToolCallback {
//...
public static final class Builder<I, O> {
//...
public FunctionToolCallback<I, O> build() {
Assert.notNull(this.inputType, "inputType cannot be null");
// 自动帮我们创建 ToolDefinition
ToolDefinition toolDefinition = DefaultToolDefinition.builder()
.name(this.name)
.description(StringUtils.hasText(this.description) ? this.description : ToolUtils.getToolDescriptionFromName(this.name))
.inputSchema(StringUtils.hasText(this.inputSchema) ? this.inputSchema : JsonSchemaGenerator.generateForType(this.inputType, new JsonSchemaGenerator.SchemaOption[0]))
.build();
return new FunctionToolCallback(toolDefinition, this.toolMetadata, this.inputType, this.toolFunction, this.toolCallResultConverter);
}
}
}
JSON Schema 是一种用于描述和验证 JSON 数据结构的规范。它相当于 JSON 数据的 "蓝图" 或 "契约"，定义了 JSON 数据应该包含哪些字段、每个字段的数据类型（如字符串、数字、布尔值等）、字段间的关系以及其他约束条件（如是否必填、数值范围、字符串格式等）。
JSON Schema 的核心作用如下：
数据结构描述：清晰定义 JSON 数据的结构，让开发者或系统明确知道 "应该接收 / 生成什么样的 JSON"。例如，定义一个 "用户" 的 JSON Schema，可以指定必须包含 name（字符串）、age（整数，且大于 0）等字段。
数据验证：根据定义的 Schema 自动校验 JSON 数据是否符合规范，避免不合规数据导致的解析错误或业务异常。例如，若 JSON 中 age 是负数，通过 Schema 验证可直接发现该错误。
文档化：作为 JSON 数据的 "说明书"，帮助团队成员或系统间理解数据格式，减少沟通成本。
代码生成：部分工具可根据 JSON Schema 自动生成对应的数据模型类（如 Java 的 POJO、TypeScript 的 Interface 等）。
以下是一个描述 "用户" 信息的 JSON Schema 示例：
{
"$schema": "http://json-schema.org/draft-07/schema#", // 声明使用的Schema版本
"type": "object", // 根数据类型为对象
"title": "用户信息",
"description": "存储用户的基本信息",
"properties": { // 定义对象的属性
"name": {
"type": "string", // 类型为字符串
"description": "用户姓名"
},
"age": {
"type": "integer", // 类型为整数
"minimum": 0, // 最小值为0
"description": "用户年龄"
},
"email": {
"type": "string",
"format": "email", // 符合邮箱格式
"description": "用户邮箱"
}
},
"required": ["name", "age"], // 必选字段
"additionalProperties": false // 不允许出现未定义的其他字段
}我们向 AI 模型提供工具时，AI 模型需要知道工具调用时输入参数的 JSON Schema。JSON Schema 用于理解如何调用工具，及如何准备调用工具的请求。Spring AI 通过 JsonSchemaGenerator 类内置支持生成工具输入类型的 JSON Schema，该模式作为 ToolDefinition 的一部分提供。如下图：
JsonSchemaGenerator 类在底层用于生成方法工具或函数工具输入参数的 JSON Schema。JSON Schema 的生成逻辑支持一系列注解，你可在方法/函数的输入参数上使用这些注解来自定义生成的 JSON Schema。
下面将描述生成工具输入参数 JSON Schema 时可定制的两个主要选项：描述信息（description）和必选状态（required）。
描述信息除了为工具本身提供描述外，你还可为工具的输入参数添加描述。该描述可用于提供参数的关键信息，如参数格式要求、允许取值等，有助于模型理解输入模式及使用方法。Spring AI 内置支持通过以下注解生成输入参数描述：
Spring AI 的 @ToolParam(description = "…")
Jackson 的 @JsonClassDescription(description = "…")
Jackson 的 @JsonPropertyDescription(description = "…")
Swagger 的 @Schema(description = "…")
简单示例：
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;
import org.springframework.context.i18n.LocaleContextHolder;
public class DateTimeTools {
@Tool(description="为给定时间设置用户闹钟")
public void setAlarm(@ToolParam(description="ISO-8601格式的时间") String time) {
LocalDateTime alarmTime = LocalDateTime.parse(time, DateTimeFormatter.ISO_DATE_TIME);
System.out.println("闹钟设置为 " + alarmTime);
}
}默认情况下，每个输入参数都被视为必选参数，这会强制 AI 模型在调用工具时必须提供该参数值。但你可通过以下注解（按优先级顺序）将输入参数设为可选：
Spring AI 的 @ToolParam(required = false)
Jackson 的 @JsonProperty(required = false)
Swagger 的 @Schema(required = false)
Spring 的 @Nullable
简单示例：
public class CustomerTools {
// updateCustomerInfo() 工具中，id 和 name 参数是必须的，而 email 参数是可选的
@Tool(description = "更新客户信息")
public void updateCustomerInfo(Long id, String name, @ToolParam(required = false) String email) {
System.out.println("更新客户信息 id: " + id);
}
}📢注意：正确定义输入参数的必选状态对降低幻觉风险至关重要，能确保模型调用工具时提供正确的输入。在上述例子中，email 参数为可选，意味着模型可不提供该参数值直接调用工具。若参数为必选，则模型调用时必须提供参数值 —— 当不存在有效值时，模型可能会虚构参数值，从而导致幻觉。工具调用结果通过 ToolCallResultConverter 序列化后返回给 AI 模型，该接口提供将工具调用结果转换为 String 对象的能力。
接口定义如下：
@FunctionalInterface
public interface ToolCallResultConverter {
/**
* 将工具返回的对象转换为与指定类型兼容的字符串
*
* @param result 工具调用后的返回结果对象，可能为null（如工具无返回值）
* @param returnType 目标类型，用于指定转换后的字符串应兼容的数据类型，可能为null
* @return 转换后的字符串，需与returnType类型兼容，便于后续处理或传递给LLM
*/
String convert(@Nullable Object result, @Nullable Type returnType);
}注意，结果必须是可序列化类型。默认情况下，结果通过 Jackson 序列化为 JSON（使用 DefaultToolCallResultConverter），但你可通过自定义 ToolCallResultConverter 接口实现来定制序列化过程。并且，Spring AI 在方法工具和函数工具中均依赖 ToolCallResultConverter。如下图：
使用声明式方法从方法构建工具时，你可以通过设置 @Tool 注解的 toolCallResultConverter 属性来为该工具提供自定义的 ToolCallResultConverter。例如：
public class CustomerTools {
// CustomToolCallResultConverter 为自定义的转换器
@Tool(description = "Retrieve customer information", resultConverter = CustomToolCallResultConverter.class)
public Customer getCustomerInfo(Long id) {
return customerRepository.findById(id);
}
}若使用编程式方法，可通过设置 MethodToolCallback.Builder 的 resultConverter() 属性来为工具提供自定义的 ToolCallResultConverter。如下图：
使用编程式方法从函数构建工具时，你可以通过设置 FunctionToolCallback.Builder 的 toolCallResultConverter 属性来为该工具提供自定义的 ToolCallResultConverter。如下图：
Spring AI 支持通过 ToolContext API 向工具传递额外的上下文信息。此功能允许你提供用户自定义的额外数据，这些数据可与 AI 模型传递的工具参数一起在工具执行过程中使用。如下图：
上图是 Spring AI 中工具调用流程示意图，展示了从用户发起对话请求，到借助工具、AI 模型协作，最终返回响应的完整过程。其中：
① 初始输入：Chat Request 包含工具上下文（ToolContext）和定义（ToolDefinition），一起被传入 Spring AI 模块，启动工具调用流程。
ToolContext：包含工具调用所需的环境信息，比如历史对话、业务参数，告诉系统当前场景需要哪些工具辅助。
ToolDefinition：工具本身的“说明书”，比如工具能做什么、需要哪些参数、输出格式，类似函数的 入参/出参定义。
② Spring AI 向 AI 模型“咨询”：是否需要工具？Spring AI 把“用户请求 + 工具定义”传给 AI Model（大语言模型）。让 AI 判断「是否需要调用工具」，以及「调用哪个工具、传什么参数」。
③ AI 决定调用工具 → Spring AI 执行调用
步骤 3：AI Model 分析后，返回 “工具调用指令”，比如：调用天气查询工具，参数填北京、今天。
步骤 3''：Spring AI 的 Dispatch Tool Call Requests（工具调度器），根据指令实际触发工具执行，把 ToolContext 上下文和参数传给工具 Tool。
步骤 4：Tool 完成任务，返回结果，比如：北京今天晴，25℃。
④ 工具结果回传给 AI 模型，补充上下文
Spring AI 把工具返回的结果再次传给 AI Model，相当于给 AI 补充“实时信息”。此时 AI 拿到两部分内容：原始用户请求 + 工具返回的结果，可以更精准地理解问题、生成回答。
⑤ AI 生成最终回答
AI Model 结合“用户需求 + 工具结果”，组织出完整、准确的回复内容，再传给 Spring AI。
⑥ 返回对话响应：Chat Response
Spring AI 把 AI 生成的最终回复，包装成 Chat Response，返回给用户/调用方。
ToolContext 使用示例：
public class CustomerTools {
@Tool(description = "检索客户信息")
public Customer getCustomerInfo(Long id, ToolContext toolContext) {
// 从 ToolContext 中获取租户ID
return customerRepository.findById(id, toolContext.get("tenantId"));
}
}ToolContext 中的数据由用户调用 ChatClient 时提供。
ChatModel chatModel = ...
String response = ChatClient.create(chatModel)
.prompt("Tell me more about the customer with ID 42")
.tools(new CustomerTools())
// 提供工具上下文数据
// ChatClientRequestSpec toolContext(Map<String, Object> toolContext)
.toolContext(Map.of("tenantId", "acme"))
.call()
.content();
System.out.println(response);注意，ToolContext 中提供的任何数据都不会发送给 AI 模型。同样，直接调用 ChatModel 时也可定义工具上下文数据。
ChatModel chatModel = ...
ToolCallback[] customerTools = ToolCallbacks.from(new CustomerTools());
ChatOptions chatOptions = ToolCallingChatOptions.builder()
.toolCallbacks(customerTools)
.toolContext(Map.of("tenantId", "acme"))
.build();
Prompt prompt = new Prompt("Tell me more about the customer with ID 42", chatOptions);
chatModel.call(prompt);注意，如果在默认选项和运行时选项中均设置了 toolContext，最终 ToolContext 将是两者的合并结果，其中运行时选项优先于默认选项。
默认情况下，工具调用结果将作为响应返回给 AI 模型，随后模型可利用该结果继续对话。
某些场景下，你可能希望将结果直接返回调用方而非传回模型。例如：当构建依赖 RAG 工具的代理时，你可能希望直接将检索结果返回调用方，而非传回模型进行不必要的后处理；又或者某些工具应当终止代理的推理循环。
每个 ToolCallback 实现均可定义工具调用结果应直接返回调用方还是传回模型。默认结果为传回 AI 模型，但你可按工具单独修改此行为。
ToolCallingManager 负责管理工具执行生命周期，其会处理工具的 returnDirect 属性。若该属性设为 true，工具调用结果将直接返回调用方；否则结果将传回模型。如果同时请求多个工具调用，则所有工具的 returnDirect 属性必须设为 true 才能将结果直接返回调用方。否则，结果将传回 AI 模型。
工具调用流程图：
上图是 Spring AI 中工具调用的简化流程，核心特点是 returnDirect=true（工具结果直接返回调用方，跳过 AI 二次处理）。下面分步拆解逻辑：
① 输入：Chat Request 携带工具定义（含 returnDirect=true）
Chat Request：用户发起的对话请求，需借助工具解决问题。
Tool Definition：工具的“说明书”（能做什么、参数要求等），额外带 returnDirect=true（关键标记，决定流程走向，表示工具调用结果不需要回传给 AI 模型进行二次处理）。
② Spring AI 调用 AI 模型，确认工具调用逻辑
Spring AI 把“用户请求 + 工具定义”传给 AI Model（大语言模型），让 AI 判断“是否需要调用工具？调用哪个？传什么参数？”。因为有 returnDirect=true，这里 AI 主要做“工具调用的决策”（而非后续二次处理）。
③ Spring AI 执行工具调用
Dispatch Tool Call Requests（工具调度器）根据 AI 决策，实际触发 Tool 执行，把参数传给工具，工具开始干活。
④ 工具返回结果
Tool 完成任务，把结果直接回传给 Spring AI 的调度器。由于 returnDirect=true，结果不再返回给 AI 二次处理，跳过传统流程中“AI 整合结果”的步骤。
⑤ 直接返回工具结果作为响应
Spring AI 把 工具返回的原始结果包装成 Chat Response，直接返回给用户/调用方。
使用声明式方法从方法构建工具时，你可以通过将 @Tool 注解的 returnDirect 属性设为 true，将工具标记为直接向调用方返回结果。例如：
public class CustomerTools {
@Tool(description = "检索客户信息", returnDirect = true)
public Customer getCustomerInfo(Long id) {
return customerRepository.findById(id);
}
}若使用编程式方法，可通过 ToolMetadata 接口设置 returnDirect 属性，并将其传递给 MethodToolCallback.Builder。例如：
oolMetadata toolMetadata = ToolMetadata.builder() .returnDirect(true) .build(); MethodToolCallback.builder() .toolMetadata(toolMetadata).build();
使用编程式方法从函数构建工具时，你可通过 ToolMetadata 接口设置 returnDirect 属性，并将其传递给 FunctionToolCallback.Builder。例如：
ToolMetadata toolMetadata = ToolMetadata.builder()
.returnDirect(true)
.build();
FunctionToolCallback.builder("", (city, context) -> {
// 业务逻辑
return true;
})
.toolMetadata(toolMetadata).build();更多关于 Spring AI 工具调用的知识请参考官方文档，后续章节将介绍如何定义方法工具和函数工具。
川公网安备51010802032098
