1. Chuẩn bị ban đầu

1.1. Tạo dự án và cấu hình 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.5.0</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>spring-ai-integration</artifactId>
    <version>1.0.0</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- Thư viện cốt lõi LangChain4j -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
            <version>1.9.1</version>
        </dependency>
        <!-- Phụ thuộc cho AiService -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
            <version>1.0.1-beta6</version>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-core</artifactId>
            <version>1.9.1</version>
        </dependency>
        <!-- Hỗ trợ OpenAI cho LangChain4j (có thể dùng với giao thức tương thích OpenAI của các nhà cung cấp khác) -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
            <version>1.9.1-beta17</version>
        </dependency>
        <!-- Thư viện lập trình phản ứng -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
            <version>1.9.1-beta17</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>
    </dependencies>
</project>

1.2. File cấu hình

spring:
  application:
    name: spring-ai-integration
  main:
    allow-bean-definition-overriding: true
    
langchain4j:
  open-ai:
    chat-model:
      api-key: ******
      model-name: qwen-plus
      base-url: https://dashscope.aliyuncs.com/compatible-mode/v1

1.3. Lớp yêu cầu prompt

@Data
public class ChatPromptRequest {
    private String content;
    private long requesterId;
}

2. Định nghĩa chức năng API LLM nâng cao

• Ba khả năng sau được tập trung trong giao diện có tên AIAssistant, các khả năng này được hỗ trợ thực hiện bởi các annotation
• Lợi ích của API LLM nâng cao là chỉ cần xác định rõ giao diện, LangChain4j sẽ đảm nhận phần triển khai cụ thể thông qua AiServices.create

public interface ChatAIAssistant {
    
    /**
     * Trò chuyện đơn giản nhất, chỉ trả lời từ trợ lý mà không chứa thông tin bổ sung
     * @param userInput Thông điệp từ người dùng
     * @return Trả lời được tạo bởi trợ lý
     */
    String basicChat(String userInput);

    /**
     * Sử dụng mẫu để trò chuyện, trả lời từ trợ lý
     * @param parameter Tham số trong mẫu
     * @return Trả lời được tạo bởi trợ lý
     */
    @UserMessage("Giới thiệu ngắn gọn về {{parameter}}")
    String templateChat(@V("parameter") String parameter);

    /**
     * Thiết lập hệ thống message, định nghĩa vai trò của mô hình lớn, trả lời từ trợ lý
     * @param parameter Tham số trong mẫu
     * @return Trả lời được tạo bởi trợ lý
     */
    @SystemMessage("Câu trả lời của bạn không vượt quá 100 chữ Hán")
    @UserMessage("Giới thiệu ngắn gọn về {{parameter}}")
    String templateChatWithSystemMessage(@V("parameter") String parameter);
}

3. Lớp cấu hình

• Ứng dụng sẽ tạo hai thể thông qua lớp LangChain4jConfiguration: openAiChatModel chịu trách nhiệm API LLM cấp thấp, assistant chịu trách nhiệm API LLM nâng cao

@Data
@Configuration
@ConfigurationProperties(prefix = "langchain4j.open-ai.chat-model")
public class LangChain4jConfiguration {

    private String apiKey;

    private String modelName;

    private String baseUrl;

    /**
     * Tạo và cấu hình thể hiện OpenAiChatModel (sử dụng giao thức tương thích OpenAI)
     */
    @Bean
    public OpenAiChatModel openAiChatModel() {
        return OpenAiChatModel.builder()
                .apiKey(apiKey)
                .modelName(modelName)
                .baseUrl(baseUrl)
                .build();
    }

    @Bean
    public ChatAIAssistant aiAssistant(@Qualifier("openAiChatModel") OpenAiChatModel chatModel) {
        return AiServices.create(ChatAIAssistant.class, chatModel);
    }
}

4. Lớp dịch vụ

package com.example.ai.service.impl;

import com.example.ai.service.ChatAIAssistant;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.request.ChatRequest;
import dev.langchain4j.model.openai.OpenAiChatModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


/**
 * Tích hợp với Spring Boot
 */
@Service
@Slf4j
public class AIChatService {

    @Autowired
    private OpenAiChatModel openAiChatModel;

    /**
     * Nhận phản hồi từ mô hình AI (dùng cho gọi API)
     *
     * @param prompt Prompt từ người dùng
     * @return Trả lời được tạo bởi AI
     */
    public String getAIResponse(String prompt) {
        return openAiChatModel.chat(prompt);
    }

    @Autowired
    private ChatAIAssistant assistant;

    /**
     * Gọi AiService để trò chuyện đơn giản
     *
     * @param prompt Prompt từ người dùng
     * @return Trả lời được tạo bởi trợ lý
     */
    public String executeBasicChat(String prompt) {
        return assistant.basicChat(prompt) + "[từ aiservice basicChat]";
    }

    /**
     * Gọi AiService để trò chuyện với mẫu
     *
     * @param parameter Tham số trong mẫu
     * @return Trả lời được tạo bởi trợ lý
     */
    public String executeTemplateChat(String parameter) {
        return assistant.templateChat(parameter) + "[từ aiservice templateChat]";
    }

    /**
     * Gọi AiService để trò chuyện với mẫu, bao gồm hệ thống message
     *
     * @param parameter Tham số trong mẫu
     * @return Trả lời được tạo bởi trợ lý
     */
    public String executeTemplateChatWithSystemMessage(String parameter) {
        return assistant.templateChatWithSystemMessage(parameter) + "[từ aiservice templateChatWithSystemMessage]";
    }

    /**
     * Mô phỏng trò chuyện đa vòng
     *
     * @param prompt Tham số trong mẫu
     * @return Trả lời được tạo bởi trợ lý
     */
    public String simulateMultiTurnChat(String prompt) {
        List<ChatMessage> conversationHistory = List.of(
                SystemMessage.from("Bạn là nhà sử học, hãy trả lời câu hỏi theo phong cách ngắn gọn"),
                UserMessage.from("Giới thiệu về Tào Tháo"),
                AiMessage.from("Tào Tháo (155-220), nhà chính trị, quân sự, văn học lỗi lạc cuối thời Đông Hán, người sáng lập nhà Ngụy. Ông thống nhất phương Bắc, thực hiện chính sách điền địa, trọng dụng nhân tài, giỏi binh pháp, đồng thời là đại diện của văn học Kiến An, tác phẩm tiêu biểu là thơ 'Quan Thải Hải'."),
                UserMessage.from(prompt));

        AiMessage response = openAiChatModel.chat(conversationHistory).aiMessage();

        return response.text() + "[từ simulateMultiTurnChat]";
    }

    public String utilizeChatRequest(String prompt) {
        List<ChatMessage> messages = List.of(
                SystemMessage.from("Bạn là lập trình viên Java, hãy trả lời câu hỏi theo phong cách ngắn gọn"),
                UserMessage.from(prompt));

        ChatRequest request = ChatRequest.builder()
                .messages(messages)
                .temperature(0.7)
                .maxOutputTokens(100)
                .build();

        return openAiChatModel.chat(request).aiMessage().text() + "[từ utilizeChatRequest]";
    }
}

5. Controller

@RestController
@RequestMapping("/api/aiChat")
public class AIChatController {

    @Autowired
    private AIChatService aiChatService;

    @PostMapping("/chat")
    public ResponseEntity<String> chat(@RequestBody ChatPromptRequest request) {
        // Kiểm tra yêu cầu có hợp lệ không
        if (request == null || request.getContent() == null || request.getContent().trim().isEmpty()) {
            return ResponseEntity.badRequest().body("Nội dung prompt không được để trống");
        }
        try {
            // Gọi aiChatService để nhận phản hồi từ mô hình
            String response = aiChatService.getAIResponse(request.getContent());
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            // Bắt lỗi và trả về thông báo lỗi
            return ResponseEntity.status(500).body("Yêu cầu xử lý thất bại: " + e.getMessage());
        }
    }

    @PostMapping("/basicChat")
    public ResponseEntity<String> basicChat(@RequestBody ChatPromptRequest request) {
        String response = aiChatService.executeBasicChat(request.getContent());
        return ResponseEntity.ok(response);
    }

    @PostMapping("/templateChat")
    public ResponseEntity<String> templateChat(@RequestBody ChatPromptRequest request) {
        String response = aiChatService.executeTemplateChat(request.getContent());
        return ResponseEntity.ok(response);
    }

    @PostMapping("/templateChatWithSystemMessage")
    public ResponseEntity<String> templateChatWithSystemMessage(@RequestBody ChatPromptRequest request) {
        String response = aiChatService.executeTemplateChatWithSystemMessage(request.getContent());
        return ResponseEntity.ok(response);
    }

    @PostMapping("/simulateMultiTurnChat")
    public ResponseEntity<String> simulateMultiTurnChat(@RequestBody ChatPromptRequest request) {
        String response = aiChatService.simulateMultiTurnChat(request.getContent());
        return ResponseEntity.ok(response);
    }

    @PostMapping("/utilizeChatRequest")
    public ResponseEntity<String> utilizeChatRequest(@RequestBody ChatPromptRequest request) {
        String response = aiChatService.utilizeChatRequest(request.getContent());
        return ResponseEntity.ok(response);
    }
}