Spring AI Java步伐员的AI之Spring AI（二）

历史Spring AI文章

Spring AI Java步伐员的AI之Spring AI（一）
一丶Spring AI 函数调用

定义工具函数Function

在Spring AI中，如果一个Bean实现了Function接口，那么它就是一个工具函数，并且通过@Description注解可以形貌该工具的作用是什么，如果工具有需要吸收参数，也可以通过@Schema注解来对参数进行定义，好比以下工具是用来获取指定地点的当前时间的，并且address参数用来吸收详细的地点：

1. package com.qjc.demo.service;
3. import io.swagger.v3.oas.annotations.media.Schema;
4. import org.springframework.context.annotation.Description;
5. import org.springframework.stereotype.Component;
7. import java.time.LocalDateTime;
8. import java.util.function.Function;
10. /***
11. * @projectName spring-ai-demo
12. * @packageName com.qjc.demo.service
13. * @author qjc
14. * @description TODO
15. * @Email qjc1024@aliyun.com
16. * @date 2024-10-16 09:50
17. **/
18. @Component
19. @Description("获取指定地点的当前时间")
20. public class DateService implements Function<DateService.Request, DateService.Response> {
22.     public record Request(@Schema(description = "地点") String address) { }
24.     public record Response(String date) { }
26.     @Override
27.     public Response apply(Request request) {
28.         System.out.println(request.address);
29.         return new Response(String.format("%s的当前时间是%s", request.address, LocalDateTime.now()));
30.     }
31. }

复制代码

工具函数调用

当向大模型提问时，需要指定所要调用的工具函数，使用OpenAiChatOptions指定对应的beanName就可以了，好比：

1. @GetMapping("/function")
2. public String function(@RequestParam String message) {
3.     Prompt prompt = new Prompt(message, OpenAiChatOptions.builder().withFunction("dateService").build());
4.     Generation generation = chatClient.call(prompt).getResult();
5.     return (generation != null) ? generation.getOutput().getContent() : "";
6. }

复制代码

FunctionCallback工具函数

还可以直接在提问时直接定义并调用工具，好比：

1. @GetMapping("/functionCallback")
2. public String functionCallback(@RequestParam String message) {
3.     Prompt prompt = new Prompt(message, OpenAiChatOptions.builder().withFunctionCallbacks(
4.         List.of(FunctionCallbackWrapper.builder(new DateService())
5.                 .withName("dateService")
6.                 .withDescription("获取指定地点的当前时间").build())
7.     ).build());
8.     Generation generation = chatClient.call(prompt).getResult();
9.     return (generation != null) ? generation.getOutput().getContent() : "";
10. }

复制代码

通过这种方式，就不需要将DateService定义为Bean了，固然这样定义的工具只能functionCallback接口单独使用了，而定义Bean则可以让多个接口共享使用。
不过有时候，大模型给你的答案或工具参数可能是英文的
那么可以使用SystemMessage来设置系统提示词，好比：

1. @GetMapping("/functionCallback")
2. public String functionCallback(@RequestParam String message) {
4.     SystemMessage systemMessage = new SystemMessage("请用中文回答我");
5.     UserMessage userMessage = new UserMessage(message);
7.     Prompt prompt = new Prompt(List.of(systemMessage, userMessage), OpenAiChatOptions.builder().withFunctionCallbacks(
8.         List.of(FunctionCallbackWrapper.builder(new DateService())
9.                 .withName("dateService")
10.                 .withDescription("获取指定地点的当前时间").build())
11.     ).build());
12.     Generation generation = chatClient.call(prompt).getResult();
13.     return (generation != null) ? generation.getOutput().getContent() : "";
14. }

复制代码

这样就能控制答案了。
二丶 Spring AI 函数调用源码解析

在OpenAiChatClient的call()方法中，会进行：

• 哀求的处理
  
• 工具的调用
  
• 相应的处理
  
• 重试机制
  

好比call()方法的大要代码为：

1. @Override
2. public ChatResponse call(Prompt prompt) {
3.     // 请求处理
4.     ChatCompletionRequest request = createRequest(prompt, false);
6.     // 重试机制
7.     return this.retryTemplate.execute(ctx -> {
8.    
9.         // 请求调用
10.         ResponseEntity<ChatCompletion> completionEntity = this.callWithFunctionSupport(request);
11.    
12.         // 返回响应
13.         return new ChatResponse(...);
14.     });
15. }

复制代码

哀求处理

哀求处理焦点是把Prompt对象转换成ChatCompletionRequest对象，包罗Prompt中设置的SystemMessage、UserMessage和工具函数。
如果接纳Bean的方式来使用工具函数，其底层实在对应的仍然是FunctionCallback，在OpenAiAutoConfiguration主动设置中，定义了一个FunctionCallbackContext的Bean，该Bean提供了一个getFunctionCallback()方法，用来生成beanName对应的FunctionCallback对象，源码为：

1. public FunctionCallback getFunctionCallback(@NonNull String beanName, @Nullable String defaultDescription) {
3.     // 获取Bean类型
4.     Type beanType = FunctionContextUtils.findType(this.applicationContext.getBeanFactory(), beanName);
6.     if (beanType == null) {
7.         throw new IllegalArgumentException(
8.             "Functional bean with name: " + beanName + " does not exist in the context.");
9.     }
11.     // Bean类型必须是Function类型
12.     if (!Function.class.isAssignableFrom(FunctionTypeUtils.getRawType(beanType))) {
13.         throw new IllegalArgumentException(
14.             "Function call Bean must be of type Function. Found: " + beanType.getTypeName());
15.     }
17.     // 获取Function的第一个泛型的类型，比如Request
18.     Type functionInputType = TypeResolverHelper.getFunctionArgumentType(beanType, 0);
19.     Class<?> functionInputClass = FunctionTypeUtils.getRawType(functionInputType);
20.    
21.     String functionName = beanName;
22.     String functionDescription = defaultDescription;
24.     if (!StringUtils.hasText(functionDescription)) {
26.         // 获取@Description设置的描述信息
27.         // Look for a Description annotation on the bean
28.         Description descriptionAnnotation = applicationContext.findAnnotationOnBean(beanName, Description.class);
30.         if (descriptionAnnotation != null) {
31.             functionDescription = descriptionAnnotation.value();
32.         }
34.         // 获取Request参数前的@JsonClassDescription设置的描述信息
35.         if (!StringUtils.hasText(functionDescription)) {
36.             // Look for a JsonClassDescription annotation on the input class
37.             JsonClassDescription jsonClassDescriptionAnnotation = functionInputClass
38.             .getAnnotation(JsonClassDescription.class);
39.             if (jsonClassDescriptionAnnotation != null) {
40.                 functionDescription = jsonClassDescriptionAnnotation.value();
41.             }
42.         }
44.         if (!StringUtils.hasText(functionDescription)) {
45.             throw new IllegalStateException("Could not determine function description."
46.                                             + "Please provide a description either as a default parameter, via @Description annotation on the bean "
47.                                             + "or @JsonClassDescription annotation on the input class.");
48.         }
49.     }
51.     // 获取Bean对象
52.     Object bean = this.applicationContext.getBean(beanName);
54.     // 构建为FunctionCallback对象
55.     if (bean instanceof Function<?, ?> function) {
56.         return FunctionCallbackWrapper.builder(function)
57.         .withName(functionName)
58.         .withSchemaType(this.schemaType)
59.         .withDescription(functionDescription)
60.         .withInputType(functionInputClass)
61.         .build();
62.     }
63.     else {
64.         throw new IllegalArgumentException("Bean must be of type Function");
65.     }
66. }

复制代码

以上代码的焦点逻辑为：

• 获取Bean类型
  
• 获取Function的第一个泛型的类型，好比Request
  
• 获取@Description设置的形貌信息
  
• 构造FunctionCallback对象
  

在OpenAiChatClient就会注入FunctionCallbackContext这个Bean对象，从而使得OpenAiChatClient可以通过Prompt中指定的beanName获取到对应的FunctionCallback对象。
以是，在createRequest()方法中，就可以得到从FunctionCallbackContext找到的或者直接在Prompt对象中设置的FunctionCallback对象，然后将FunctionCallback对象转成OpenAiApi.FunctionTool对象，最终将FunctionTool设置到ChatCompletionRequest中。
哀求调用

哀求调用源码如下：

1. protected Resp callWithFunctionSupport(Req request) {
2.     Resp response = this.doChatCompletion(request);
3.     return this.handleFunctionCallOrReturn(request, response);
4. }

复制代码

• 先发送哀求得到相应
  
• 解析相应是否需要调用工具还是直接返回
  

doChatCompletion()方法比较简单，就是直接把哀求发送给OpenAi，紧张的是handleFunctionCallOrReturn()方法。
handleFunctionCallOrReturn()方法需要解析相应，好比判定OpenAi返回的相应中是否需要调用工具，好比：

1. if (!this.isToolFunctionCall(response)) {
2.     return response;
3. }

复制代码

OpenAi中，如果一个相应的finishReason为TOOL_CALLS则表示，当前相应实在是OpenAi的一个工具调用哀求。
然后就去执行工具：

1. protected ChatCompletionRequest doCreateToolResponseRequest(ChatCompletionRequest previousRequest,
2.                                                             ChatCompletionMessage responseMessage, List<ChatCompletionMessage> conversationHistory) {
4.     // 遍历每个要调用的工具
5.     // Every tool-call item requires a separate function call and a response (TOOL)
6.     // message.
7.     for (ToolCall toolCall : responseMessage.toolCalls()) {
9.         // 工具名和参数
10.         var functionName = toolCall.function().name();
11.         String functionArguments = toolCall.function().arguments();
13.         if (!this.functionCallbackRegister.containsKey(functionName)) {
14.             throw new IllegalStateException("No function callback found for function name: " + functionName);
15.         }
17.         // 找到FunctionCallback并进行调用，得到工具执行结果
18.         String functionResponse = this.functionCallbackRegister.get(functionName)
19.             .call(functionArguments);
21.         // 将工具执行结果添加到对话历史
22.         // Add the function response to the conversation.
23.         conversationHistory
24.         .add(new ChatCompletionMessage(functionResponse, Role.TOOL, functionName, toolCall.id(), null));
25.     }
27.     // 构造新的请求，将工具执行结果传递给OpenAi
28.     // Recursively call chatCompletionWithTools until the model doesn't call a
29.     // functions anymore.
30.     ChatCompletionRequest newRequest = new ChatCompletionRequest(conversationHistory, false);
31.     newRequest = ModelOptionsUtils.merge(newRequest, previousRequest, ChatCompletionRequest.class);
33.     return newRequest;
34. }

复制代码

以上源码的焦点流程为：

• 遍历每个要调用的工具
  
• 根据工具名找到FunctionCallback并进行调用，得到工具执行结果
  
• 将工具执行结果添加到对话历史
  
• 构造新的哀求，将工具执行结果转达给OpenAi
  

得到新的哀求对象后，又会调用callWithFunctionSupport()方法，以是这里出现了递归调用。
函数调用

当调用FunctionCallback的call方法时，就是在执行函数调用：

1. @Override
2. public String call(String functionArguments) {
4.     // 将OpenAi给的请求参数转成指定类，比如Request
5.     // Convert the tool calls JSON arguments into a Java function request object.
6.     I request = fromJson(functionArguments, inputType);
8.     // 然后执行apply方法
9.     // extend conversation with function response.
10.     return this.andThen(this.responseConverter).apply(request);
11. }

复制代码

从这里可以发现，对于工具执行结果，还可以设置responseConverter来进行处理，好比：

1. @GetMapping("/functionCallback")
2. public String functionCallback(@RequestParam String message) {
4.     SystemMessage systemMessage = new SystemMessage("请用中文回答我");
5.     UserMessage userMessage = new UserMessage(message);
7.     Prompt prompt = new Prompt(List.of(systemMessage, userMessage), OpenAiChatOptions.builder().withFunctionCallbacks(
8.         List.of(FunctionCallbackWrapper.builder(new DateService())
9.                 .withName("dateService")
10.                 .withDescription("获取指定地点的当前时间")
11.                 .withResponseConverter(response -> "2024年10月16日09:22")
12.                 .build())
13.     ).build());
14.     Generation generation = chatClient.call(prompt).getResult();
15.     return (generation != null) ? generation.getOutput().getContent() : "";
16. }

复制代码

这样做，最终函数执行结果被我固定成了"2024年10月16日09:22，因此最终OpenAi给我答案也是
交互流程图

为什么OpenAiChatClient不在当地先直接执行工具，然后再哀求OpenAiServer呢？
以上场景比较简单，实际上的思想是：把OpenAi当做一个大脑，通过第一次哀求告诉OpenAi我的需求使命，以及我们提供了哪些工具，然后由OpenAi：

• 先理解使命
  
• 然后制定策略，也就是OpenAi要完成使命，需要调用哪些工具，并且调用这些工具的详细参数是什么，调用工具的次序是什么，这些都由OpenAi来进行分析
  
• 然后OpenAi就向OpenAiChatClient发送工具调用哀求，并得到工具执行结果
  
• 然后OpenAi再基于使命和工具执行结果进行分析，看是否能完成使命了，还是需要继续调用工具。
  
• 如果能完成使命了，那就直接把使命的执行结果返回给OpenAiChatClient。
  

三丶 案例

需求：获取今天注册的新用户信息。
定义获取当前时间工具：

1. package com.qjc.demo.service;
3. import io.swagger.v3.oas.annotations.media.Schema;
4. import org.springframework.context.annotation.Description;
5. import org.springframework.stereotype.Component;
7. import java.time.LocalDateTime;
8. import java.util.function.Function;
10. /***
11. * @projectName spring-ai-demo
12. * @packageName com.qjc.demo.service
13. * @author qjc
14. * @description TODO
15. * @Email qjc1024@aliyun.com
16. * @date 2024-10-16 10:01
17. **/
18. @Component
19. @Description("获取当前时间")
20. public class DateService implements Function<DateService.Request, String> {
22.     public record Request(String noUse) { }
24.     @Override
25.     public String apply(Request request) {
26.         System.out.println("执行DateService工具");
27.         return LocalDateTime.now().toString();
28.     }
29. }

复制代码

定义获取用户信息服务：

1. package com.qjc.demo.service;
3. import org.springframework.context.annotation.Description;
4. import org.springframework.stereotype.Component;
6. import java.util.List;
7. import java.util.function.Function;
9. /***
10. * @projectName spring-ai-demo
11. * @packageName com.qjc.demo.service
12. * @author qjc
13. * @description TODO
14. * @Email qjc1024@aliyun.com
15. * @date 2024-10-16 10:05
16. **/
17. @Component
18. @Description("获取指定时间的注册用户")
19. public class UserService implements Function<UserService.Request, List<UserService.User>> {
21.     public record Request(String date) { }
24.     @Override
25.     public List<User> apply(Request request) {
26.         System.out.println("执行OrderService工具， 入参为：" + request.date);
27.         return List.of(new User("小齐", "2024年10月16号"), new User("宇将军", "2024年10月16号"));
28.     }
30.     class User {
31.         private String username;
32.         private String registrationDate;
34.         public User(String username, String registrationDate) {
35.             this.username = username;
36.             this.registrationDate = registrationDate;
37.         }
39.         public String getUsername() {
40.             return username;
41.         }
43.         public void setUsername(String username) {
44.             this.username = username;
45.         }
47.         public String getRegistrationDate() {
48.             return registrationDate;
49.         }
51.         public void setRegistrationDate(String registrationDate) {
52.             this.registrationDate = registrationDate;
53.         }
54.     }
57. }

复制代码

定义哀求接口：

1. @GetMapping("/user")
2. public String user(@RequestParam String message) {
3.     SystemMessage systemMessage = new SystemMessage("将结果按JSON格式返回");
4.     UserMessage userMessage = new UserMessage(message);
6.     Prompt prompt = new Prompt(List.of(systemMessage, userMessage), OpenAiChatOptions.builder()
7.                                .withFunctions(Set.of("dateService", "userService"))
8.                                .build());
9.     Generation generation = chatClient.call(prompt).getResult();
10.     return (generation != null) ? generation.getOutput().getContent() : "";
11. }

复制代码

总结

我感觉非常爽啊，我的大Spring 函数调用，没有冗余代码。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。