1、人工智能服务 AIService

1、什么是AIService

AIService使用面向接口和动态代理的方式完成程序的编写，更灵活的实现高级功能。

链的概念源自 Python 中的 LangChain。其理念是针对每个常见的用例都设置一条链，比如聊天机器人、检索增强生成（RAG）等。链将多个底层组件组合起来，并协调它们之间的交互。链存在的主要问题是不灵活，我们不进行深入的研究。

AIService****可处理最常见的操作：

• 为大语言模型格式化输入内容
• 解析大语言模型的输出结果

它们还支持更高级的功能：

• 聊天记忆 Chat memory
• 工具 Tools
• 检索增强生成 RAG

2、创建AIService

引入依赖：

<!--langchain4j高级功能-->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
</dependency>

创建接口：

public interface Assistant {
String chat(String userMessage);
}

测试用例：

@SpringBootTest
public class AIServiceTest {
    @Autowired
    private QwenChatModel qwenChatModel;
    @Test
    public void testChat() {
        //创建AIService
        Assistant assistant = AiServices.create(Assistant.class, qwenChatModel);
        //调用service的接口
        String answer = assistant.chat("Hello");
        System.out.println(answer);
    }
}

3、@AiService注解

也可以在Assistant 接口上添加@AIService注解

@AiService(wiringMode = EXPLICIT, chatModel = "qwenChatModel")
public interface Assistant {
    String chat(String userMessage);
}

测试用例中，我们可以直接注入Assistant对象

@Autowired
private Assistant assistant;
@Test
public void testAssistant() {
    String answer = assistant.chat("Hello");
    System.out.println(answer);
}

4、工作原理

AiServices会组装Assistant接口以及其他组件，并使用反射机制创建一个实现Assistant接口的代理对象。

这个代理对象会处理输入和输出的所有转换工作。在这个例子中，chat方法的输入是一个字符串，但是大 模型需要一个 UserMessage 对象。所以，代理对象将这个字符串转换为 UserMessage ，并调用聊天语 言模型。chat方法的输出类型也是字符串，但是大模型返回的是 AiMessage 对象，代理对象会将其转换 为字符串。

简单理解就是：代理对象的作用是输入转换和输出转换

2、聊天记忆 Chat memory

1、测试对话是否有记忆

@SpringBootTest
public class ChatMemoryTest {
    @Autowired
    private Assistant assistant;
    @Test
    public void testChatMemory() {
        String answer1 = assistant.chat("我是环环");
        System.out.println(answer1);
        String answer2 = assistant.chat("我是谁");
        System.out.println(answer2);
    }
}

很显然，目前的接入方式，大模型是没有记忆的。

2、聊天记忆的简单实现

@Autowired
private QwenChatModel qwenChatModel;
@Test
public void testChatMemory2() {
//第二轮对话
    UserMessage userMessage2 = UserMessage.userMessage("你知道我是谁吗");
    //第一轮对话
    UserMessage userMessage1 = UserMessage.userMessage("我是环环");
    ChatResponse chatResponse1 = qwenChatModel.chat(userMessage1);
    AiMessage aiMessage1 = chatResponse1.aiMessage();
    //输出大语言模型的回复
    System.out.println(aiMessage1.text());
    ChatResponse chatResponse2 = qwenChatModel.chat(Arrays.asList(userMessage1,
    aiMessage1, userMessage2));
    AiMessage aiMessage2 = chatResponse2.aiMessage();
    //输出大语言模型的回复
    System.out.println(aiMessage2.text());
}

3、使用ChatMemory实现聊天记忆

使用AIService可以封装多轮对话的复杂性，使聊天记忆功能的实现变得简单

@Test
public void testChatMemory3() {
//创建chatMemory
    MessageWindowChatMemory chatMemory = MessageWindowChatMemory.withMaxMessages(10);
    //创建AIService
    Assistant assistant = AiServices
    .builder(Assistant.class)
    .chatLanguageModel(qwenChatModel)
    .chatMemory(chatMemory)
    .build();
    //调用service的接口
    String answer1 = assistant.chat("我是环环");
    System.out.println(answer1);
    String answer2 = assistant.chat("我是谁");
    System.out.println(answer2);
}

4、使用AIService实现聊天记忆

@AiService(
wiringMode = EXPLICIT,
chatModel = "qwenChatModel",
chatMemory = "chatMemory"
)
public interface MemoryChatAssistant {
    String chat(String message);
}

配置类进行配置：

@Configuration
public class MemoryChatAssistantConfig {
    @Bean
    ChatMemory chatMemory() {
        //设置聊天记忆记录的message数量
        return MessageWindowChatMemory.withMaxMessages(10);
    }
}

测试代码：

@Autowired
private MemoryChatAssistant memoryChatAssistant;
@Test
public void testChatMemory4() {
    String answer1 = memoryChatAssistant.chat("我是环环");
    System.out.println(answer1);
    String answer2 = memoryChatAssistant.chat("我是谁");
    System.out.println(answer2);
}

5、隔离聊天记忆

为每个用户的新聊天或者不同的用户区分聊天记忆

@AiService(
    wiringMode = EXPLICIT,
    chatMemory = "chatMemory",
    chatMemoryProvider = "chatMemoryProvider"
)
public interface SeparateChatAssistant {
    /**
    * 分离聊天记录
    * @param memoryId 聊天id
    * @param userMessage 用户消息
    * @return
    */
    String chat(@MemoryId int memoryId, @UserMessage String userMessage);
}

配置类如下：

@Configuration
public class SeparateChatAssistantConfig {
    @Bean
    ChatMemoryProvider chatMemoryProvider() {
        return memoryId -> MessageWindowChatMemory.builder()
            .id(memoryId)
            .maxMessages(10)
            .build();
    }
}

测试用例：

@Autowired
private SeparateChatAssistant separateChatAssistant;
@Test
public void testChatMemory5() {
    String answer1 = separateChatAssistant.chat(1,"我是环环");
    System.out.println(answer1);
    String answer2 = separateChatAssistant.chat(1,"我是谁");
    System.out.println(answer2);
    String answer3 = separateChatAssistant.chat(2,"我是谁");
    System.out.println(answer3);
}

3、持久化聊天记忆 Persistence

默认情况下，聊天记忆存储在内存中。如果需要持久化存储，可以实现一个自定义的聊天记忆存储类， 以便将聊天消息存储在你选择的任何持久化存储介质中。

1、存储介质的选择

大模型中聊天记忆的存储选择哪种数据库，需要综合考虑数据特点、应用场景和性能要求等因素，以下 是一些常见的选择及其特点：

• MySQL
  • 特点：关系型数据库。支持事务处理，确保数据的一致性和完整性，适用于结构化数据的存储和查询。
  • 适用场景：如果聊天记忆数据结构较为规整，例如包含固定的字段如对话 ID、用户 ID、时间戳、消息内容等，且需要进行复杂的查询和统计分析，如按用户统计对话次数、按时间范围查 询特定对话等，MySQL 是不错的选择。
• Redis
  • 特点：内存数据库，读写速度极高。它适用于存储热点数据，并且支持多种数据结构，如字符 串、哈希表、列表等，方便对不同类型的聊天记忆数据进行处理。
  • 适用场景：对于实时性要求极高的聊天应用，如在线客服系统或即时通讯工具，Redis 可以快 速存储和获取最新的聊天记录，以提供流畅的聊天体验。
• MongoDB
  • 特点：文档型数据库，数据以 JSON - like 的文档形式存储，具有高度的灵活性和可扩展性。它 不需要预先定义严格的表结构，适合存储半结构化或非结构化的数据。
  • 适用场景：当聊天记忆中包含多样化的信息，如文本消息、图片、语音等多媒体数据，或者消 息格式可能会频繁变化时，MongoDB 能很好地适应这种灵活性。例如，一些社交应用中用户可 能会发送各种格式的消息，使用 MongoDB 可以方便地存储和管理这些不同类型的数据。
• Cassandra
  • 特点：是一种分布式的 NoSQL 数据库，具有高可扩展性和高可用性，能够处理大规模的分布 式数据存储和读写请求。适合存储海量的、时间序列相关的数据。
  • 适用场景：对于大型的聊天应用，尤其是用户量众多、聊天数据量巨大且需要分布式存储和处 理的场景，Cassandra 能够有效地应对高并发的读写操作。例如，一些面向全球用户的社交媒 体平台，其聊天数据需要在多个节点上进行分布式存储和管理，Cassandra 可以提供强大的支持。

2、持久化聊天

1、优化实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Document("chat_messages")
public class ChatMessages {
    //唯一标识，映射到 MongoDB 文档的 _id 字段
    @Id
    private ObjectId id;
    private int messageId;
    private String content; //存储当前聊天记录列表的json字符串
}

2、创建持久化类

创建一个类实现ChatMemoryStore接口

@Component
public class MongoChatMemoryStore implements ChatMemoryStore {
    @Autowired
    private MongoTemplate mongoTemplate;
    @Override
    public List<ChatMessage> getMessages(Object memoryId) {
        Criteria criteria = Criteria.where("memoryId").is(memoryId);
        Query query = new Query(criteria);
        ChatMessages chatMessages = mongoTemplate.findOne(query, ChatMessages.class);
        if(chatMessages == null) return new LinkedList<>();
        return ChatMessageDeserializer.messagesFromJson(chatMessages.getContent());
    }
    @Override
    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
        Criteria criteria = Criteria.where("memoryId").is(memoryId);
        Query query = new Query(criteria);
        Update update = new Update();
        update.set("content", ChatMessageSerializer.messagesToJson(messages));
        //根据query条件能查询出文档，则修改文档；否则新增文档
        mongoTemplate.upsert(query, update, ChatMessages.class);
    }
    @Override
    public void deleteMessages(Object memoryId) {
        Criteria criteria = Criteria.where("memoryId").is(memoryId);
        Query query = new Query(criteria);
        mongoTemplate.remove(query, ChatMessages.class);
    }
}

在SeparateChatAssistantConfig中，添加MongoChatMemoryStore对象的配置

@Configuration
public class SeparateChatAssistantConfig {
//注入持久化对象
    @Autowired
    private MongoChatMemoryStore mongoChatMemoryStore;
    @Bean
    ChatMemoryProvider chatMemoryProvider() {
    return memoryId -> MessageWindowChatMemory.builder()
        .id(memoryId)
        .maxMessages(10)
        .chatMemoryStore(mongoChatMemoryStore)//配置持久化对象
        .build();
    }
}

4、提示词 Prompt

1、系统提示词

@SystemMessage 设定角色，塑造AI助手的专业身份，明确助手的能力范围

2、配置@SystemMessage

在SeparateChatAssistant类的chat方法上添加@SystemMessage注解

@SystemMessage("你是我的好朋友，请用东北话回答问题。")//系统消息提示词
String chat(@MemoryId int memoryId, @UserMessage String userMessage);

@SystemMessage 的内容将在后台转换为 SystemMessage 对象，并与UserMessage 一起发送给大语言模型（LLM）。

SystemMessaged的内容只会发送给大模型一次。

如果你修改了SystemMessage的内容，新的SystemMessage会被发送给大模型，之前的聊天记忆会失效。

@SpringBootTest 
public class PromptTest { 
    @Autowired 
    private SeparateChatAssistant separateChatAssistant; 
    @Test 
    public void testSystemMessage() { 
        String answer = separateChatAssistant.chat(3,"今天几号"); 
        System.out.println(answer); 
    } 
} 

在Assistant中配置，如果要显示今天的日期，我们需要在提示词中添加当前日期的占位符{{current_date}}

@SystemMessage("你是我的好朋友，请用东北话回答问题。今天是{{current_date}}")//系统消息提示词 
String chat(@MemoryId int memoryId, @UserMessage String userMessage);

1、从资源中加载提示模板

@SystemMessage 注解还可以从资源中加载提示模板：

@SystemMessage(fromResource = "my-prompt-template.txt") 
String chat(@MemoryId int memoryId, @UserMessage String userMessage); 

my-prompt-template.txt文章中的内容

你是我的好朋友，请用东北话回答问题，回答问题的时候适当添加表情符号。 今天是 {{current_date}}。

3、用户提示词模板

@UserMessage：获取用户输入

1、配置@UserMessage

在 MemoryChatAssistant 的 chat 方法中添加注解

@UserMessage("你是我的好朋友，请用上海话回答问题，并且添加一些表情符号。 {{it}}") //{{it}}表示这里
唯一的参数的占位符
String chat(String message);

测试用例：

@Autowired
private MemoryChatAssistant memoryChatAssistant;
    @Test
    public void testUserMessage() {
        String answer = memoryChatAssistant.chat("我是环环");
        System.out.println(answer);
    }

指定参数名称

@V** **明确指定传递的参数名称

单参数（可以省略）：

@UserMessage("你是我的好朋友，请用上海话回答问题，并且添加一些表情符号。{{message}}")
String chat(@V("message") String userMessage);

多参数（必须加上）：

如果有两个或两个以上的参数，我们必须要用 @V ，在 SeparateChatAssistant 中定义方法 chat2

@UserMessage("你是我的好朋友，请用粤语回答问题。{{message}}")
String chat2(@MemoryId int memoryId, @V("message") String userMessage);

@UserMessage 中的内容每次都会被和用户问题组织在一起发送给大模型

@SystemMessage和@V

也可以将 @SystemMessage 和 @V 结合使用

在 SeparateChatAssistant 中添加方法chat3

@SystemMessage(fromResource = "my-prompt-template3.txt")
String chat3(
@MemoryId int memoryId,
@UserMessage String userMessage,
@V("username") String username,
@V("age") int age
);

创建提示词模板my-prompt-template3.txt，添加占位符

你是我的好朋友，我是{{username}}，我的年龄是{{age}}，请用东北话回答问题，回答问题的时候适当添加表情
符号。
今天是 {{current_date}}。

测试：

@Test
public void testUserInfo() {
    String answer = separateChatAssistant.chat3(1, "我是谁，我多大了", "翠花", 18);
    System.out.println(answer);
}