LangChain 整合 SpringBoot

下述代码均使用 阿里云百炼平台 提供的模型。

创建项目，引入依赖

1. 通过 IDEA 创建 SpringBoot 项目，并引入 Spring Web 依赖，SpringBoot 推荐使用 3.x 版本。
   
   
2. 引入 LangChain4j 和 WebFlux 依赖

<!--阿里云 DashScope API（通义大模型）的 Spring Boot Starter 依赖-->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-community-dashscope-spring-boot-starter</artifactId>
    <version>1.0.0-beta2</version>
</dependency>
<!--LangChain4j 的核心库-->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j</artifactId>
    <version>1.0.0-beta2</version>
</dependency>
<!--Spring WebFlux 依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

案例一 — 普通对话

该示例为整体返回，即等待模型回复完成后，一起进行返回。

1. 配置 yaml

langchain4j:
  community:
    dashscope:
      chat-model:
        api-key: 个人 api-key
        model-name: qwen-max

2. 创建 ChatController，并编写相关接口

@RestController
@RequestMapping("/chat")
public class ChatController {

    @Autowired
    private ChatLanguageModel chatLanguageModel;

    @RequestMapping("/test1")
    public String test1(@RequestParam(defaultValue = "你好") String message) {
        String response = chatLanguageModel.chat(message);
        return response;
    }
}

3. 测试接口响应

浏览器中访问：http://localhost:8080/chat/test1?message=你好，你是谁，如果有响应类似下述内容，则说明成功。

案例二 — 流式对话

上述示例用户体验并不好，本示例采用流式返回

1. 配置 yaml

langchain4j:
  community:
    dashscope:
      streaming-chat-model:
        model-name: qwen-max
        api-key: 个人 api-key

2. 编写相关接口

@Autowired
private StreamingChatLanguageModel streamingChatLanguageModel;

// 指定 produces，否则会出现乱码情况
@RequestMapping(value = "/test2", produces = "text/stream;charset=UTF-8")
public Flux<String> test2(@RequestParam(defaultValue = "你好") String message) {
    Flux<String> flux = Flux.create(sink -> {
        streamingChatLanguageModel.chat(message, new StreamingChatResponseHandler() {

            @Override
            public void onPartialResponse(String partialResponse) {
                sink.next(partialResponse);
            }

            @Override
            public void onCompleteResponse(ChatResponse completeResponse) {
                sink.complete();
            }

            @Override
            public void onError(Throwable error) {
                sink.error(error);
            }
        });
    });
    return flux;
}

3. 测试接口响应

浏览器中访问：http://localhost:8080/chat/test2?message=你好，你是谁，如果有响应类似下述内容，则说明成功。

本案例与案例一的区别为输出方式不同，一种是整体输出，一种是流式输出。

案例三 — 图片生成

百炼平台提供500张图片的免费额度用于学习。
本案例采用同步的方式获取图片，也可以按照官方文档采用异步方式进行图片获取。

1. 配置yaml

gen-img:
  api-key: 个人 api-key
  model-name: wanx2.1-t2i-turbo

2. 配置 WanxImageModel，编写相关接口

@Configuration
public class AIConfig {

    @Value("${gen-img.api-key}")
    private String genImgApiKey;
    @Value("${gen-img.model-name}")
    private String genImgModelName;

    @Bean
    /**
     * 图片绘制模型
     */
    public WanxImageModel wanxImageModel() {
        return WanxImageModel.builder()
                .apiKey(genImgApiKey)
                .modelName(genImgModelName)
                .build();
    }
}

@Autowired
private WanxImageModel wanxImageModel;

@RequestMapping("/test3")
public String test3(@RequestParam(defaultValue = "午后的公园") String message) {
    Response<Image> generate = wanxImageModel.generate(message);
    // 具体返回结构可查看官方定义，这里只获取图片的 url
    return generate.content().url().toString();
}

3. 测试接口响应

在浏览器中输入：http://localhost:8080/chat/test3?message=雨后的公园
下图中返回数据为生成图片的 url，使用浏览器访问该 url，可以在浏览器中下载生成后的图片。

生成的图片如下：

案例四 — 记忆对话

1. 配置 AiService 相关对象

// 定义聊天助手接口
public interface MyAssistant {
    String chat(String message);

    TokenStream stream(String message);
}

@Bean
public MyAssistant assistant(ChatLanguageModel qwenChatModel, StreamingChatLanguageModel qwenStreamingChatModel) {
    MyAssistant assistant = AiServices.builder(MyAssistant.class)
            .chatLanguageModel(qwenChatModel)
            .streamingChatLanguageModel(qwenStreamingChatModel)
            .chatMemory(MessageWindowChatMemory.withMaxMessages(20))
            // 自定义对话存储方式
//                .chatMemoryProvider(memoryId -> MessageWindowChatMemory
//                        .builder()
//                        .chatMemoryStore(new ChatMemoryStore() {
//                            @Override
//                            public List<ChatMessage> getMessages(Object memoryId) {
//                                return null;
//                            }
//
//                            @Override
//                            public void updateMessages(Object memoryId, List<ChatMessage> messages) {
//
//                            }
//
//                            @Override
//                            public void deleteMessages(Object memoryId) {
//
//                            }
//                        }
//                ).build())
            .build();

    return assistant;
}

2. 编写接口，采用流式返回

@Autowired
private AIConfig.MyAssistant assistant;

@RequestMapping(value = "/test4", produces = "text/stream;charset=UTF-8")
public Flux<String> test4(@RequestParam(defaultValue = "你好") String message) {
    TokenStream stream = assistant.stream(message);

    return Flux.create(sink -> {
        stream.onPartialResponse(sink::next)
                .onCompleteResponse(c -> sink.complete())
                .onError(sink::error)
                .start();
    });
}

3. 测试接口响应

   1. 直接进行询问
      

   2. 通过接口给模型写入记忆

   3. 根据写入记忆，进行对话
      

上述聊天信息默认存储在内存中，程序重启后会丢失记忆，可以重写被注释掉的内容，将信息存储到 mysql、redis等存储容器中。

案例五 — 记忆对话，数据隔离

上述案例中，所有的问答都是混合到一起的，即 A 对模型输入的信息，B 也可以读取到，本案例将通过 memoryId 对记忆数据进行隔离。

1. 配置 AiService 相关对象

public interface MyAssistantIsolate {

    String chat(@MemoryId String memoryId, @UserMessage String message);

    TokenStream stream(@MemoryId String memoryId, @UserMessage String message);
}

@Bean
public MyAssistantIsolate myAssistantMemory(ChatLanguageModel qwenChatModel, StreamingChatLanguageModel qwenStreamingChatModel) {

    ChatMemoryProvider chatMemoryProvider = memoryId -> MessageWindowChatMemory
            .builder()
            .id(memoryId)
            .maxMessages(20)
            // 自定义对话存储方式
//                .chatMemoryStore(new ChatMemoryStore() {
//                    @Override
//                    public List<ChatMessage> getMessages(Object memoryId) {
//                        return null;
//                    }
//
//                    @Override
//                    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
//
//                    }
//
//                    @Override
//                    public void deleteMessages(Object memoryId) {
//
//                    }
//                })
            .build();


    MyAssistantIsolate assistant = AiServices.builder(MyAssistantIsolate.class)
            .chatLanguageModel(qwenChatModel)
            .streamingChatLanguageModel(qwenStreamingChatModel)
            .chatMemoryProvider(chatMemoryProvider)
            .build();

    return assistant;
}

2. 编写接口

@Autowired
private AIConfig.MyAssistantIsolate myAssistantIsolate;

@RequestMapping(value = "/test5", produces = "text/stream;charset=UTF-8")
// 通过不同的 memoryId 对记忆进行分割，memoryId 可以使用 userId 或 uuid
public Flux<String> test5(String memoryId, String message) {
    TokenStream stream = myAssistantIsolate.stream(memoryId, message);

    return Flux.create(sink -> {
        stream.onPartialResponse(sink::next)
                .onCompleteResponse(c -> sink.complete())
                .onError(sink::error)
                .start();
    });
}

3. 测试接口响应
   1. 给 memoryId = 1，设置记忆信息
      
   2. 通过 memoryId = 1，查询记忆信息
      
   3. 通过 memoryId = 2，查询记忆信息
      

上述内容为 LangChain4j 整合 SpringBoot 的基本示例。