利用Spring Boot以及Spring AI构建生成式人工智能应用_spring-ai-openai-spring-boot-starter

Spring AI，作为行业领导者，通过其强大、灵活的API和先进的功能，为各种行业提供了颠覆性的解决方案。在本专题中，我们将深入探讨Spring AI在各领域的应用示例，每个案例都将展示Spring AI如何满足特定需求，实现目标，并将这些LESSONS LEARNED扩展到更广泛的应用。希望这个专题能对你有所启发，更深入地理解和利用Spring AI的无限可能。

Spring框架在软件开发领域已经有超过20年的历史，自Spring Boot 1.0版本发布以来已有10年。现在，无人会质疑，Spring创造了一种独特的风格，使开发者从重复任务中解放出来，专注于提供业务价值。随着时间的推移，Spring的技术深度不断增强，涵盖了广泛的开发领域和技术。另一方面，随着更多的专用解决方案得到尝试，概念的验证被创建，并最终在项目的保护下得到推广，其技术广度不断扩大。

Spring AI 项目就是一个实例，根据其参考文档，该项目旨在简化当生成式人工智能层需要被引入应用时的开发过程。开发者再次从重复任务中解放出来，可以直接通过简单的接口与预先训练的模型（包含实际处理算法）进行交互。

通过直接或者通过 Spring AI 以编程方式与生成式预训练的转换器（GPTs）交互，用户（开发者）不需要拥有广泛的机器学习知识。但作为一名工程师，我强烈认为，即使这些开发者工具可以方便快捷地使用并产生结果，我建议我们需要克制自己，警觉观察，尝试首先理解基本概念。此外，通过遵循这条路径，产出的结果可能会更有价值。

目的

本文介绍了如何将 Spring AI 集成到Spring Boot应用，与OpenAI进行编程交互。我们假定prompt设计一般来说是一种最先进的活动。因此，在实验过程中使用的prompt非常有教导性，但应用性不大。此处的重点是通讯接口，即 Spring AI API。

实施前

首先要明确自身使用GPT解决方案的理由，除了希望提供更好的质量，节省时间和降低成本。

生成式人工智能据说擅长执行大量耗时的任务，速度更快，效率更高，生成结果。此外，如果这些结果进一步经过经验丰富且智慧的人类验证，获得有用结果的可能性会增加。

接下来，应抵制立即跳入实施的诱惑，至少要花一些时间熟悉一下一般概念。对生成式人工智能概念的深入探索远远超出了本文的范围。然而，出现在交互中的“主要角色”在下面简要概述。

舞台 - 生成式人工智能是人工智能的一部分
输入 - 提供的数据（输入）
输出 - 计算结果（输出）
大型语言模型（LLM）- 根据解释的输入产生输出的微调算法
提示词- 一种最先进的接口，通过它将输入传入模型
提示词模板 - 允许构造结构化参数化提示的组件
令牌 - 算法在内部将输入转换为令牌，然后使用这些令牌来编译结果，并最终从中构造输出
模型的环境窗口 - 模型限制每次调用的令牌数量的阈值（通常，使用的令牌越多，操作就越昂贵）

最后，可以开始实施，但随着实施的进行，建议回顾和优化前两个步骤。

提示词

在本次练习中，我们请求如下：

Write {count = three} reasons why people in {location = Romania} should consider a {job = software architect} job.
These reasons need to be short, so they fit on a poster.
For instance, "{job} jobs are rewarding."

上面内容代表了提示词模板。按照建议，应作为提示词的一部分提供清晰的主题，清晰的任务含义以及额外的有用信息，以提高结果的准确性。

提示词包含三个参数

count - 希望作为输出的原因数量
job - 感兴趣的领域或工作
location - 工作申请者所在的国家，城镇，地区等

概念验证

在这篇文章中，简单的概念验证目标如下：

将 Spring AI 集成到Spring Boot应用程序并使用它
允许客户端通过应用程序与 Open AI 进行通信
客户端向应用程序发出参数化的HTTP请求
应用程序使用一个提示词来创建输入，发送给 Open AI 并获取输出
应用程序将响应发送给客户端

项目设置

Java 21
Maven 3.9.2
Spring Boot – v. 3.2.2
Spring AI – v. 0.8.0-SNAPSHOT (仍在开发，实验性)

代码实现

Spring AI 集成

通常，这是一个基本步骤，不一定值得一提。然而，因为 Spring AI 目前以快照形式发布，为了能够集成 Open AI 自动配置依赖，你需要添加一个引用到 Spring 快照仓库。

<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
<repository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>https://repo.spring.io/snapshot</url>
<releases>
<enabled>false</enabled>
</releases>
</repository>
</repositories>

下一步是添加 spring-ai-openai-spring-boot-starter Maven 依赖项。

<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-openai-spring-boot-starter</artifactId>
<version>0.8.0-SNAPSHOT</version>
</dependency>

Open AI ChatClient 现在是应用程序类路径的一部分。它是用来向 Open AI 发送输入并获取输出的组件。

为了能够连接到AI模型，需要在 application.properties 文件中设置 spring.ai.openai.api-key 属性。

spring.ai.openai.api-key = api-key-value

它的值代表了用户的有效API密钥，用户将通过此密钥进行通信。通过访问[资源2]，可以注册或登录并生成一个。

客户端 - Spring Boot应用程序通信

概念验证的第一部分是客户端应用程序（例如浏览器，curl等）与开发的应用程序之间的通信。这是通过一个 REST 控制器实现的，可以通过HTTP GET请求访问。

URL路径是 /job-reasons，还有之前在定义提示时概述的三个参数，这将导致如下格式：

/job-reasons?count={count}&job={job}&locatinotallow={location}

和相应的控制器：

@RestController
public class OpenAiController {

@GetMapping("/job-reasons")
public ResponseEntity<String> jobReasons(@RequestParam(value = "count", required = false, defaultValue = "3") int count,
@RequestParam("job") String job,
@RequestParam("location") String location) {
return ResponseEntity.ok().build();
}
}

由于来自 Open AI 的响应将是一个字符串，因此控制器返回一个封装了字符串的ResponseEntity。如果我们运行应用程序并发出请求，当前响应体部分没有返回任何内容。

客户端 - Open AI 通信

Spring AI 目前主要关注处理语言并产生语言或数字的AI模型。在前一类别中， Open AI 模型的例子包括GPT4-openai或GPT3.5-openai。

为了与这些AI模型（实际上是指 Open AI 算法）进行交互， Spring AI 提供了一个统一的接口。

ChatClient接口目前支持文本输入和输出，并具有简单的契约。

@FunctionalInterface
public interface ChatClient extends ModelClient<Prompt, ChatResponse> {
default String call(String message) {
Prompt prompt = new Prompt(new UserMessage(message));
return call(prompt).getResult().getOutput().getContent();
}

ChatResponse call(Prompt prompt);
}

确实如此，功能接口的实际方法通常是被使用的方法。

在我们的概念验证中，这正是我们所需要的，一种调用 Open AI 并发送目标参数化 Prompt 作为参数的方式。我们定义了以下的OpenAiService，在其中注入了一个 ChatClient 的实例。

@Service
public class OpenAiService {

private final ChatClient client;

public OpenAiService(OpenAiChatClient aiClient) {
this.client = aiClient;
}

public String jobReasons(int count, String domain, String location) {
final String promptText = """
Write {count} reasons why people in {location} should consider a {job} job.
These reasons need to be short, so they fit on a poster.
For instance, "{job} jobs are rewarding."
""";

final PromptTemplate promptTemplate = new PromptTemplate(promptText);
promptTemplate.add("count", count);
promptTemplate.add("job", domain);
promptTemplate.add("location", location);

ChatResponse response = client.call(promptTemplate.create());
return response.getResult().getOutput().getContent();
}
}

如果应用程序正在运行，那么可以从浏览器执行以下请求：

http://localhost:8080/gen-ai/job-reasons?count=3&job=software%20architect&locatinotallow=Romania

这下面的结果被检索出来的结果：

利润丰裕的职业：软件架构师的工作提供了有竞争力的薪酬和出色的增长机会，确保在罗马尼亚的财务稳定和成功。
热门职业：随着技术需求的持续增长，软件架构师在罗马尼亚和全世界都备受追捧，提供了丰富的就业前景和就业保障。
创造性问题解决：软件架构师在设计和开发创新软件解决方案中扮演着至关重要的角色，使他们可以释放他们的创造力，并对各种行业产生重大影响。

这就是我们所期望的——一个简易的接口，通过它，可以要求 Open AI GPT模型写出一些原因，解释为何在特定地点的特定工作具有吸引力。

调整和观察

到目前为止，开发的简单概念验证主要使用了默认的配置。

ChatClient实例可以通过各种属性根据所需需要来配置。虽然这超出了本文的范围，但在这里举两个例子。

spring.ai.openai.chat.options.model 指定要使用的AI模型。默认为'gpt-35-turbo'，但'gpt-4'和'gpt-4-32k'指定的是最新版本。虽然这些版本都是可用的，但你可能无法使用按使用量付费的计划来访问这些版本，但 Open AI 网站上有更多的信息可以帮助你了解如何适应它。

另一个值得一提的属性是 spring.ai.openai.chat.options.temperature。根据参考文档，采样温度控制了“回应的创新性”。据说，较高的值会让输出“更随机”，而较低的值会“更专注和决定性”。默认值为0.8，如果我们将其降低到0.3，重启应用并再次使用相同的请求参数询问，下面的结果将被检索出来。

有利可图的职业机会：罗马尼亚的软件架构师工作提供有竞争力的薪水和极好的成长前景，对于寻求财务稳定和职业发展的个人来说，这是一个吸引人的职业选择。
具有挑战性和智能刺激的工作：作为一名软件架构师，你将负责设计和实现复杂的软件系统，解决复杂的技术问题，并与有才华的团队合作。这个角色提供了持续的学习机会和在尖端技术上工作的机会。
高需求和工作保障：随着对技术和数字化转型的依赖增加，各行各业对熟练软件架构师的需求在上升。选择在罗马尼亚的软件架构师工作确保了工作安全和广泛的就业选择，无论是在本地还是国际上。

可以看出，这种情况下的输出更具描述性。

最后一个考虑因素是与获取的输出的结构相关的。拥有将实际接收的有效载荷映射到Java对象（例如，类或记录）的能力将非常方便。截至目前，表示形式是文本形式，实现也是如此。输出解析器可能实现这一点，类似于Spring JDBC的映射结构。

在这个概念验证中，我们使用了一个BeanOutputParser，它允许直接将结果反序列化到Java记录中，如下所示：

public record JobReasons(String job,
String location,
List<String> reasons) {
}

通过将 {format} 作为提示文本的一部分，并将其作为指示提供给 AI 模型。

OpenAiService 方法变为：

public JobReasons formattedJobReasons(int count, String job, String location) {
final String promptText = """
Write {count} reasons why people in {location} should consider a {job} job.
These reasons need to be short, so they fit on a poster.
For instance, "{job} jobs are rewarding."
{format}
""";

BeanOutputParser<JobReasons> outputParser = new BeanOutputParser<>(JobReasons.class);

final PromptTemplate promptTemplate = new PromptTemplate(promptText);
promptTemplate.add("count", count);
promptTemplate.add("job", job);
promptTemplate.add("location", location);

promptTemplate.add("format", outputParser.getFormat());
promptTemplate.setOutputParser(outputParser);

final Prompt prompt = promptTemplate.create();

ChatResponse response = client.call(prompt);
return outputParser.parse(response.getResult().getOutput().getContent());
}

再次调用时，输出如下：

{
"job":"software architect",
"location":"Romania",
"reasons":[
"High demand",
"Competitive salary",
"Opportunities for growth"
]
}

格式符合预期，但解释的原因似乎较少，这意味着需要进行额外的调整以达到更好的可用性。然而，从概念验证的角度来看，这是可接受的，因为焦点是形式。

结论

提示设计是任务的重要部分 - 提示越清晰，输入越好，输出的质量也就越高。

```python
class BertPooler(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
        self.activation = nn.Tanh()
 
    def forward(self, hidden_states):
        # We "pool" the model by simply taking the hidden state corresponding
        # to the first token.
        first_token_tensor = hidden_states[:, 0]
        pooled_output = self.dense(first_token_tensor)
        pooled_output = self.activation(pooled_output)
        return pooled_output
from transformers.models.bert.configuration_bert import *
import torch
config = BertConfig.from_pretrained("bert-base-uncased")
bert_pooler = BertPooler(config=config)
print("input to bert pooler size: {}".format(config.hidden_size))
batch_size = 1
seq_len = 2
hidden_size = 768
x = torch.rand(batch_size, seq_len, hidden_size)
y = bert_pooler(x)
print(y.size())
```