Java学习之-SpringAI

文章目录

一、SpringAI是什么
二、准备工作
- 1.GPT-API-free
- 2.AiCore
- 3.eylink
三、对话案例实现
- 1.创建项目
- 2.实现简单的对话
四、聊天客户端ChatClient
- 1.角色预设
- 2.流式响应
五、聊天模型
六、图像模型(文生图)
七、语音模型
- 1.文字转语音(文生语音)
- 2.语音转文字
八、多模态
九、函数调用

一、SpringAI是什么

SpringAI是一个AI工程应用框架，旨在将Spring生态系统的设计原则（如可移植性和模块化设计）应用于AI领域。它推广使用Plain Old Java Object（POJO）作为AI应用程序的构建块，从而为Java开发者提供了一种更简洁的方式与人工智能进行交互。SpringAI的推出被认为是Java开发领域的一大福音，因为它结合了Spring生态系统的设计原则和模块化的概念，降低了接入大型语言模型（LLM）的学习成本。SpringInitializr是SpringAI上架的平台，使得Java开发者能够利用SpringAI构建自己的应用程序。

简单而言，Spring AI 是AI工程师所使用的一种应用性框架，通过提供出来的API和API key来进行开发应用，所用在于使用AI应用来简化开发工序流程。

名称	地址
SpringAI官网	https://spring.io/projects/spring-ai
SpringAI API官网	https://docs.spring.io/spring-ai/reference/api/chatclient.html

二、准备工作

我们需要准备OpenAI的key秘钥和API地址。以下是我整理的获取途径：

1.GPT-API-free

访问：https://gitcode.com/chatanywhere/GPT_API_free/overview

点击申请内测免费Key

在这里插入图片描述

免费版支持gpt-3.5-turbo, embedding,gpt-4。其中gpt-4由于价格过高，每天限制3次调用（0点刷新）。需要更稳定快速的gpt-4请使用付费版。
免费版gpt-4由gpt-4o提供服务，支持识图等付费版API全部功能。
转发Host1:https://api.chatanywhere.tech (国内中转，延时更低，host1和host2二选一)
转发Host2:https://api.chatanywhere.com.cn (国内中转，延时更低，host1和host2二选一)
转发Host3:https://api.chatanywhere.cn (国外使用,国内需要全局代理)

2.AiCore

访问地址：https://api.xty.app
注册登录后可以创建令牌
注意：不是纯免费
接口地址/BaseURL/密钥地址/代理地址（不同软件配置方式不同，请用下面的地址逐一测试）：
https://api.xty.app，备用加速地址: https://hk.xty.app
https://api.xty.app/v1，备用加速地址: https://hk.xty.app/v1

淘宝搜： open ai key也可以直接购买

3.eylink

访问地址：https://eylink.cn/

三、对话案例实现

版本依赖：JDK17+SpringBoot3.3+SpringAI1.0.0-M1

1.创建项目

使用IDEA创建Springboot项目，一定要使用JDK17，看其他博主说的非17会出现版本错误(本人未测试)。
在这里插入图片描述

这里我们选择Maven，JDK和Java版本选择17.
在这里插入图片描述

在这里插入图片描述
按照自己需求引入依赖。Spring Web和OpenAI为必须引入

pom文件依赖如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cheryl</groupId>
    <artifactId>springai-learn</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springai-learn</name>
    <description>springai-learn</description>
    <properties>
        <java.version>17</java.version>
        <spring-ai.version>1.0.0-M1</spring-ai.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.ai</groupId>
                <artifactId>spring-ai-bom</artifactId>
                <version>${spring-ai.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

</project>

更改配置文件：

spring:
  application:
    name: Spring-Ai-Demo
  ai:
    openai:
      api-key: sk-XdZSQDaRxxxxxx #此次是获取的API-key
      base-url: https://apixxxxxxxxx.tech # 这里是请求代理地址

如果想直接访问OpenAI不想使用以上配置的代理地址，则需要在代码中进行配置代理，代码如下：

@SpringBootApplication
public class SpringaiLearnApplication {

    public static void main(String[] args) {
        // 设置代理
        String proxy = "127.0.0.1";  // 如果代理在你本机就127.0.0.1如果代理是其他服务器相应设置
        int port = 7890;   //设置科学上网代理的端口，
        System.setProperty("proxyType", "4");
        System.setProperty("proxyPort", Integer.toString(port));
        System.setProperty("proxyHost", proxy);
        System.setProperty("proxySet", "true");
        SpringApplication.run(SpringaiLearnApplication.class, args);
    }
}

2.实现简单的对话

新建AIController，实现下列代码：

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/ai")
class AIController {

    private final ChatClient chatClient;

    public AIController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg",defaultValue = "给我讲个笑话") String message) {
        //prompt:提示词
        return this.chatClient.prompt()
                //用户输入的信息
                .user(message)
                //请求大模型
                .call()
                //返回文本
                .content();
    }
}

调用结果如下：
在这里插入图片描述
在这个简单示例中，用户输入设置用户消息的内容。 call 方法向 AI 模型发送请求，context 方法以 String 形式返回 AI 模型的响应。

四、聊天客户端ChatClient

ChatClient提供了一个流畅的 API，用于与 AI 模型进行通信。它支持同步编程模型和响应式编程模型。

1.角色预设

创建AIConfig文件配置默认角色

@Configuration
public class AIConfig {

    @Bean
    public ChatClient chatClient(ChatClient.Builder builder) {
        return builder.defaultSystem("你是考拉教育的一名老师，你精通Java开发，你的名字叫考拉AI。").build();
    }
}

修改controller如下：

@RestController
@RequestMapping("/ai")
@RequiredArgsConstructor
class AIController {

    private final ChatClient chatClient;

    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg") String message) {
        return chatClient.prompt().user(message).call().content();
    }
}

请求结果如下：
在这里插入图片描述

2.流式响应

注意要配置编码格式

    @GetMapping(value = "/chat/stream",produces="text/html;charset=UTF-8")
    public Flux<String> chatStream(@RequestParam(value = "msg") String message) {
        return chatClient.prompt().user(message).stream().content();
    }

在这里插入图片描述

五、聊天模型

聊天模型 API 使开发人员能够将 AI 驱动的聊天完成功能集成到他们的应用程序中。它利用预训练的语言模型，如GPT（生成式预训练转换器），以自然语言生成类似人类的用户输入响应。

API 通常通过向 AI 模型发送提示或部分对话来工作，然后 AI 模型根据其训练数据和对自然语言模式的理解生成对话的完成或延续。然后，完成的响应将返回给应用程序，应用程序可以将其呈现给用户或将其用于进一步处理。

它被设计成一个简单且可移植的界面，用于与各种 AI 模型进行交互，允许开发人员以最少的代码更改在不同模型之间切换。这种设计符合Spring的模块化和可互换性理念。Spring AI Chat Model API

此外，在输入封装和输出处理等配套类的帮助下，聊天模型 API 统一了与 AI 模型的通信。它管理请求准备和响应解析的复杂性，提供直接和简化的 API 交互。PromptChatResponse

本文只展示使用OpenAI的方式，更多方式请查看官方文档

Spring AI 支持 OpenAI 的 AI 语言模型 ChatGPT。ChatGPT 在激发人们对 AI 驱动的文本生成的兴趣方面发挥了重要作用，这要归功于它创建了行业领先的文本生成模型和嵌入。

官网地址：https://docs.spring.io/spring-ai/reference/api/chat/openai-chat.html

package com.cheryl.springailearn.controller;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.messages.Media;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.ai.openai.api.OpenAiApi;
import org.springframework.core.io.ClassPathResource;
import org.springframework.util.MimeTypeUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

import java.io.IOException;
import java.net.URL;
import java.util.List;

@RequestMapping("/chat/model")
@RequiredArgsConstructor
@RestController
public class ChatModelController {
    private final ChatModel chatModel;

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

    /**
     * Spring AI 支持 OpenAI 的 AI 语言模型 ChatGPT
     * @param msg
     * @return
     */
    @GetMapping("/openai")
    public String openai(@RequestParam("msg")String msg) {
        ChatResponse call = chatModel.call(
                new Prompt(
                        msg,
                        OpenAiChatOptions.builder()//可以更换成其他大模型，如Anthropic3ChatOptions亚马逊
                                .withModel("gpt-3.5-turbo")
                                .withTemperature(0.8F)
                                .build()
                )
        );
        return call.getResult().getOutput().getContent();
    }
    /**
     * 流式响应
     * @param msg
     * @return
     */
    @GetMapping(value = "/openai/stream",produces="text/html;charset=UTF-8")
    public Flux<ChatResponse> stream(@RequestParam("msg")String msg) {
        return chatModel.stream(
                new Prompt(
                        msg,
                        OpenAiChatOptions.builder()//可以更换成其他大模型，如Anthropic3ChatOptions亚马逊
                                .withModel("gpt-3.5-turbo")
                                .withTemperature(0.8F)
                                .build()
                )
        );
    }
}

六、图像模型(文生图)

属性配置官网：https://docs.spring.io/spring-ai/reference/api/image/openai-image.html

import lombok.RequiredArgsConstructor;
import org.springframework.ai.image.ImagePrompt;
import org.springframework.ai.image.ImageResponse;
import org.springframework.ai.openai.OpenAiImageModel;
import org.springframework.ai.openai.OpenAiImageOptions;
import org.springframework.ai.openai.api.OpenAiImageApi;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/image")
@RestController
@RequiredArgsConstructor
public class ImageModelController {

    private final OpenAiImageModel openaiImageModel;

    @GetMapping
    public String getImage(@RequestParam(value = "msg",defaultValue = "生成一直小猫")String msg) {
        ImageResponse response = openaiImageModel.call(
                new ImagePrompt(
                        msg,
                        OpenAiImageOptions.builder()
                                .withQuality("hd")//将生成的图像的质量。HD 创建的图像具有更精细的细节和更高的图像一致性。只有 dall-e-3 支持此参数。
                                .withModel(OpenAiImageApi.DEFAULT_IMAGE_MODEL)
                                .withN(1)//要生成的图像数。必须介于 1 和 10 之间。对于 dall-e-3，仅支持 n=1。
                                .withHeight(1024)//生成的图像的高宽度。必须是 dall-e-2 的 256、512 或 1024 之一。
                                .withWidth(1024).build())
        );
        return response.getResult().getOutput().getUrl();
    }

}

七、语音模型

1.文字转语音(文生语音)

import lombok.RequiredArgsConstructor;
import org.springframework.ai.openai.OpenAiAudioSpeechModel;
import org.springframework.ai.openai.OpenAiAudioSpeechOptions;
import org.springframework.ai.openai.api.OpenAiAudioApi;
import org.springframework.ai.openai.audio.speech.SpeechPrompt;
import org.springframework.ai.openai.audio.speech.SpeechResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.FileOutputStream;
import java.io.IOException;

@RequestMapping("/audio")
@RequiredArgsConstructor
@RestController
public class AudioModelController {

    private final OpenAiAudioSpeechModel openAiAudioSpeechModel;

    @GetMapping
    public void text2audio() throws IOException {
        OpenAiAudioSpeechOptions speechOptions = OpenAiAudioSpeechOptions.builder()
                .withModel("tts-1")//要使用的模型的 ID。目前只有 tts-1 可用。
                .withVoice(OpenAiAudioApi.SpeechRequest.Voice.ALLOY)//用于 TTS 输出的语音。可用选项包括：alloy, echo, fable, onyx, nova, and shimmer.
                .withResponseFormat(OpenAiAudioApi.SpeechRequest.AudioResponseFormat.MP3)//音频输出的格式。支持的格式包括 mp3、opus、aac、flac、wav 和 pcm。
                .withSpeed(1.0f)//语音合成的速度。可接受的范围是从 0.0（最慢）到 1.0（最快）
                .build();

        //要转换的语音内容
        SpeechPrompt speechPrompt = new SpeechPrompt("你好，这是一个文本到语音的例子。", speechOptions);
        SpeechResponse response = openAiAudioSpeechModel.call(speechPrompt);
        byte[] output = response.getResult().getOutput();
        //将文件输出到指定位置
        writeByteArrayToMp3(output,"/Users/mac/Desktop/project/java");
    }

    public static void writeByteArrayToMp3(byte[] audioBytes, String outputFilePath) throws IOException {
        // 创建FileOutputStream实例
        FileOutputStream fos = new FileOutputStream(outputFilePath+"/audio_demo.mp3");

        // 将字节数组写入文件
        fos.write(audioBytes);

        // 关闭文件输出流
        fos.close();
    }
}

2.语音转文字

import lombok.RequiredArgsConstructor;
import org.springframework.ai.openai.OpenAiAudioTranscriptionModel;
import org.springframework.ai.openai.OpenAiAudioTranscriptionOptions;
import org.springframework.ai.openai.api.OpenAiAudioApi;
import org.springframework.ai.openai.audio.transcription.AudioTranscriptionPrompt;
import org.springframework.ai.openai.audio.transcription.AudioTranscriptionResponse;
import org.springframework.core.io.ClassPathResource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RequestMapping("/audio")
@RequiredArgsConstructor
@RestController
public class AudioModelController {

    private final OpenAiAudioTranscriptionModel openAiTranscriptionModel;

    @GetMapping("/audio2text")
    public String audio2text(){
        //脚本输出的格式，位于以下选项之一中：json、text、srt、verbose_json 或 vtt。
        OpenAiAudioApi.TranscriptResponseFormat responseFormat = OpenAiAudioApi.TranscriptResponseFormat.TEXT;

        OpenAiAudioTranscriptionOptions transcriptionOptions = OpenAiAudioTranscriptionOptions.builder()
                .withLanguage("en")//输入音频的语言。以 ISO-639-1 格式提供输入语言将提高准确性和延迟。
                .withPrompt("Ask not this, but ask that")//用于指导模型样式或继续上一个音频片段的可选文本。提示应与音频语言匹配。
                .withTemperature(0f)//采样温度，介于 0 和 1 之间。较高的值（如 0.8）将使输出更具随机性，而较低的值（如 0.2）将使其更加集中和确定。如果设置为 0，模型将使用对数概率自动提高温度，直到达到某些阈值。
                .withResponseFormat(responseFormat)//输出格式
                .build();
        //获取当前语音文件
        ClassPathResource audioFile = new ClassPathResource("audio_demo.mp3");
        AudioTranscriptionPrompt transcriptionRequest = new AudioTranscriptionPrompt(audioFile, transcriptionOptions);
        AudioTranscriptionResponse response = openAiTranscriptionModel.call(transcriptionRequest);
        return response.getResult().getOutput();
    }
}

八、多模态

多模态是指模型同时理解和处理来自各种来源的信息的能力，包括文本、图像、音频和其他数据格式。

	/**
     * 多模态是指模型同时理解和处理来自各种来源的信息的能力，包括文本、图像、音频和其他数据格式。 
     * 仅支持 chatGPT4.0
     * @param msg
     * @return
     */
    @GetMapping(value = "/openai/multimodal",produces="text/html;charset=UTF-8")
    public String multimodal(@RequestParam("msg")String msg) throws IOException {
        byte[] imageData = new ClassPathResource("/multimodal.test.png").getContentAsByteArray();
        var userMessage = new UserMessage(msg,
                List.of(new Media(
                        MimeTypeUtils.IMAGE_PNG,
                        new URL("https://docs.spring.io/spring-ai/reference/1.0-SNAPSHOT/_images/multimodal.test.png")
                )));

        ChatResponse response = chatModel.call(new Prompt(List.of(userMessage),
                OpenAiChatOptions.builder().withModel(OpenAiApi.ChatModel.GPT_4_O.getValue()).build()));

        return response.getResult().getOutput().getContent();
    }

九、函数调用

我们创建一个聊天机器人，通过调用我们自己的函数来回答问题。为了支持聊天机器人的响应，我们将注册我们自己的函数，该函数获取一个位置并返回该位置的当前天气。
(注意本人亲测函数调用只能在gtp4.0以上使用，注意上边说的免费版Key无法使用)
大致流程如下：
在这里插入图片描述

创建functions包，创建LocationWeatherFunction实现Function接口

package com.cheryl.springailearn.functions;

import java.util.function.Function;

public class LocationWeatherFunction implements Function <LocationWeatherFunction.Request, LocationWeatherFunction.Response>{

    // 实现apply方法
    @Override
    public Response apply(Request request) {
        System.out.println(request);
        if(request==null){
            return new Response("request is null");
        }
        if(request.location==null){
            return new Response("地址是空的");
        }
        return new Response("天气一会下雨一会晴天" );
    }

    public record Request(String location){

    }
    public record Response(String msg) {
    }
}

将函数注册为 Bean

@Description是可选的，它提供了函数描述，可帮助模型了解何时调用函数。这是一个重要的属性，可帮助 AI 模型确定要调用的客户端函数。

package com.cheryl.springailearn.config;

import com.cheryl.springailearn.functions.LocationWeatherFunction;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Description;

import java.util.function.Function;

@Configuration
public class AIConfig {
    @Bean
    @Description("某某地方天气怎么样")
    public Function<LocationWeatherFunction.Request, LocationWeatherFunction.Response> locationWeatherFunction(){
        return new LocationWeatherFunction();
    }
}

在聊天模型中调用函数

package com.cheryl.springailearn.controller;


import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RequestMapping("/function")
@RequiredArgsConstructor
@RestController
public class AIFunctionController {

    private final ChatModel chatModel;

    @GetMapping
    public String testFunction(){
        UserMessage userMessage = new UserMessage("济南天气怎么样？");
        OpenAiChatOptions options = OpenAiChatOptions.builder()
                .withFunction("locationWeatherFunction")
                .withModel("gpt-4-turbo")
                .build();
        ChatResponse call = chatModel.call(
                new Prompt(
                        List.of(userMessage),
                        options
                )
        );
        return call.getResult().getOutput().getContent();
    }

}