Java对接AI大模型（一）【Langchain4j】

随着AI大模型技术的升起,人们越来越感觉到生活上的便捷以及人机对话照进现实.什么是大模型呢?

大模型（Large Model），通常是指参数量非常庞大的深度学习模型，特别是在自然语言处理（NLP）、计算机视觉（CV）等领域中，模型参数数量达到数十亿甚至数千亿的规模。

为了弥补Java在AI领域的工具短板,现在市面上出现了几款针对Java的AI开发工具.

一. AI开发工具

1.1 LangChain4J

  • 提供标准化API，支持超过15个主流大模型提供商和嵌入存储，
  • 提供工具箱，从低级提示词模板到高级AI服务，适合构建聊天机器人和检索增强生成(RAG)管道。
  • 社区支持活跃，能够快速整合最新的AI技术，便于Java开发者将AI功能集成到现有项目中

1.2 Spring Al

  • 深度集成到Spring框架中，Java开发者可以轻松将AI功能嵌入到现有Spring项目中。
  • 尽管Spring Al仍处于发展阶段，尚未发布正式版本，但其凭借Spring生态系统，具备了极强的扩展 性和集成能力。

1.3 Spring AI Alibaba

  • 提供多种大模型服务对接能力，包括主流开源与阿里云通义大模型服务（百炼）等 支持的模型类型包括聊天、文生图、音频转录、文生语音等

本文详解Langchain4j的使用.

二. 基本使用

由于现在Java开发都是基于SpringBoot整合开发,所以langchain4j也提供了对应的依赖包.除此我们也需要引入web的依赖

  1. <dependencies>
  2.     
  3.     <dependency>
  4.             <groupId>dev.langchain4jgroupId>
  5.             <artifactId>langchain4j-spring-boot-starterartifactId>
  6.     dependency>
  7.     
  8.     <dependency>
  9.         <groupId>dev.langchain4jgroupId>
  10.         <artifactId>langchain4j-open-ai-spring-boot-starterartifactId>
  11.     dependency>
  12.     <dependency>
  13.         <groupId>org.springframework.bootgroupId>
  14.         <artifactId>spring-boot-starter-webartifactId>
  15.     dependency>
  16. dependencies>

版本管理

  1. <properties>
  2.     <maven.compiler.source>17maven.compiler.source>
  3.     <maven.compiler.target>17maven.compiler.target>
  4.     <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
  5.     <spring-boot.version>3.3.4spring-boot.version>
  6. properties>
  7.  
  8. <dependencyManagement>
  9.     <dependencies>
  10.         <dependency>
  11.             <groupId>dev.langchain4jgroupId>
  12.             <artifactId>langchain4j-bomartifactId>
  13.             <version>0.35.0version>
  14.             <type>pomtype>
  15.             <scope>importscope>
  16.         dependency>
  17.         <dependency>
  18.             <groupId>org.springframework.bootgroupId>
  19.             <artifactId>spring-boot-dependenciesartifactId>
  20.             <version>${spring-boot.version}version>
  21.             <type>pomtype>
  22.             <scope>importscope>
  23.         dependency>
  24.     dependencies>
  25. dependencyManagement>

接下来我们需要注入对话服务的模型,这列我们以阿里百炼的模型作为基础模型.

2.1 环境准备

在引入百炼的大模型前,我们需要配置一些环境.访问百炼大模型的官网.

阿里云登录 - 欢迎登录阿里云，安全稳定的云计算服务平台

我们需要获取一个API-KEY

然后这里可能需要你去充值,不用充值多了,几块就够啦.然后我们去到模型广场

点击查看详情.获取到model-name和baseUrl

获取到,去SpringBoot的application.yml配置文件配置

  1. langchain4j:
  2.     open-ai:
  3.         chat-model:
  4.             api-key: 你的api-key
  5.             model-name: qwen-max
  6.             base-url: 对应的url

LangChain4j本身提供了一个语言模型(ChatLanguageModel),我们注入使用即可,创建一个Controller类测试

  1. @RestController
  2. public class ChatController {
  3.  
  4.     ChatLanguageModel chatLanguageModel;
  5.  
  6.     public ChatController(ChatLanguageModel chatLanguageModel) {
  7.         this.chatLanguageModel = chatLanguageModel;
  8.     }
  9.  
  10.     @GetMapping("/chat")
  11.     public String model(@RequestParam(value = "message", defaultValue = "Hello") String message) {
  12.         return chatLanguageModel.generate(message);
  13.     }
  14. }

调用Postman或者其他测试工具测试

完成基本的模型对接使用.

三.常规使用

3.1 配置类配置

刚刚我们是基于yml配置文件配置的,实际上我们还可以通过配置类来完成配置.

  1. @Configuration
  2. public class LLMConfig {
  3.  
  4.     /**
  5.      * 构建 LLM 模型
  6.      * @return
  7.      */
  8.     @Bean
  9.     public ChatLanguageModel chatLanguageModel(){
  10.         return OpenAiChatModel.builder()
  11.                 .apiKey("")
  12.                 .modelName("qwen-max")
  13.                 .baseUrl("")
  14.                 .build();
  15.     }
  16. }

3.2 AI-Service

之前这种自动注入LangChain4j给我们提供的类来完成模型调用,不太灵活,我们若想不同的服务使用不同的大模型,这种方式就不太可取,实际上他还提供了AI-Service的工具类来帮助我们可以灵活更换大模型.

编写一个接口

  1. public interface IChatAssistant {
  2.     String chat(String message);
  3. }

我们修改一下我们的配置类

  1. @Configuration
  2. public class LLMConfig {
  3.     /**
  4.      * 构建 LLM 模型
  5.      * @return
  6.      */
  7.     @Bean
  8.     public ChatLanguageModel chatLanguageModel(){
  9.         return OpenAiChatModel.builder()
  10.                 .apiKey("")
  11.                 .modelName("qwen-max")
  12.                 .baseUrl("")
  13.                 .build();
  14.     }
  15.     /**
  16.      * 构建 LLM 服务,AI助手,基于配置的大模型来使用
  17.      * @return
  18.      */
  19.     @Bean
  20.     public IChatAssistant chatAssistant(){
  21.         return AiServices.builder(IChatAssistant.class)
  22.                 .chatLanguageModel(chatLanguageModel())
  23.                 .build();
  24.     }
  25. }

测试,依旧能够访问

3.3 日志打印

去执行上述测试的小伙伴应该发现了,控制台没有任何的日志输出,我们不知道用户具体输入了什么,对于排查问题来讲肯定是不友好的.Langchain4j为我们提供了日志的开关,让我们可以查看到日志的打印.

修改yml配置文件

  1. logging:
  2.     level:
  3.         dev:
  4.             langchain4j: DEBUG
  5.             ai4j:
  6.                 openai4j: DEBUG

修改配置类

  1. /**
  2.  * 构建 LLM 模型
  3.  * @return
  4.  */
  5. @Bean
  6. public ChatLanguageModel chatLanguageModel(){
  7.     return OpenAiChatModel.builder()
  8.             .apiKey("")
  9.             .modelName("qwen-max")
  10.             // 是否打印请求日志
  11.             .logRequests(true)
  12.             // 是否打印响应日志
  13.             .logResponses(true)
  14.             .baseUrl("")
  15.             .build();
  16. }

当然还有一步,Langchain4j是基于SLF4j的日志框架,所以我们需要引入logback日志框架

  1. <dependency>
  2.     <groupId>ch.qos.logbackgroupId>
  3.     <artifactId>logback-classicartifactId>
  4.     <version>1.5.8version>
  5. dependency>

测试,控制台打印

3.4 流式响应

测试过后的同学应该发现了,我们需要等待很久,最后才把输出的结果给到我们.这样对用户的体验肯定是不友好的.我们平常使用的一些ai大模型,是可以感受到他是慢慢的打印出来回复你的答案,而不是一口气讲所有的文本返回回来.

Langchain4j也为我们提供了这样的流式响应的功能.我们需要引入新的依赖

  1. <dependency>
  2.     <groupId>dev.langchain4jgroupId>
  3.     <artifactId>langchain4j-reactorartifactId>
  4.     <version>0.35.0version>
  5. dependency>

然后需要引入新的配置,Langchain4j提供了流式大模型.我们什么都不用改,只需要修改注入的类就行,其他的配置与原来的相同.以及再配置一个AI-Service.

  1. @Bean
  2. public StreamingChatLanguageModel streamingChatLanguageModel(){
  3.     return OpenAiStreamingChatModel.builder()
  4.             .apiKey("")
  5.             .modelName("qwen-max")
  6.             // 是否打印请求日志
  7.             .logRequests(true)
  8.             // 是否打印响应日志
  9.             .logResponses(true)
  10.             .baseUrl("")
  11.             .build();
  12. }
  13. @Bean
  14. public IChatStreamAssistant chatStreamAssistant(){
  15.     return  AiServices.builder(IChatStreamAssistant.class)
  16.             .streamingChatLanguageModel(streamingChatLanguageModel())
  17.             .build();
  18. }

对接的AI-Service需要修改其的返回类型.

  1. package org.kuchen.service;
  2.  
  3. import reactor.core.publisher.Flux;
  4.  
  5. /**
  6.  * @author kuchen
  7.  */
  8. public interface IChatStreamAssistant {
  9.     Flux chat(String message);
  10. }

controller层编写

我们可以去浏览器直观的感受,流式响应的效果

流式响应

注：本文转载自blog.csdn.net的Czi橙的文章"https://blog.csdn.net/m0_65013257/article/details/144174761"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！