Chat Memory
大型语言模型 (LLMs) 是无状态的,这意味着它们不会保留先前交互的信息。当你希望在多次交互之间维护上下文或状态时,这可能会成为限制。为了解决这个问题,Spring AI 提供了 chat memory 功能,允许你在与 LLM 的多次交互之间存储和检索信息。
ChatMemory 抽象允许你实现各种类型的 memory,以支持不同的使用场景。消息的底层存储由 ChatMemoryRepository 处理,它的唯一职责是存储和检索消息。由 ChatMemory 的实现来决定保留哪些消息以及何时移除它们。策略示例可以包括保留最后 N 条消息、在特定时间段内保留消息,或保留不超过特定 token 限制的消息。
在选择 memory 类型之前,有必要了解 chat memory 和 chat history 之间的区别。
-
Chat Memory。大型语言模型在整个对话过程中保留并用于维持上下文感知的信息。
-
Chat History。完整的对话历史,包括用户与模型之间交换的所有消息。
ChatMemory 抽象旨在管理 聊天记忆。它允许你存储和检索与当前会话上下文相关的消息。然而,它并不适合存储 聊天历史。如果你需要维护所有交换消息的完整记录,应考虑使用其他方式,例如依赖 Spring Data 来高效存储和检索完整的聊天历史。
快速开始
Spring AI 自动配置一个 ChatMemory bean,你可以直接在应用中使用。默认情况下,它使用内存存储库来存储消息(InMemoryChatMemoryRepository),并使用 MessageWindowChatMemory 实现来管理对话历史。如果已经配置了其他存储库(例如 Cassandra、JDBC 或 Neo4j),Spring AI 将改为使用该存储库。
@Autowired
ChatMemory chatMemory;
以下各节将进一步描述 Spring AI 中可用的不同 memory 类型和 repositories。
使用 Conversation IDs
每个 chat memory 操作都以 conversation ID 作为键。ChatMemory 和 ChatMemoryRepository 抽象使用该标识符来决定要读取、追加或删除哪个 conversation,并且必须始终显式提供该标识符。
conversation ID 是唯一限定会话范围的因素。消息会严格按照所提供的 conversation ID 进行存储和读取,因此,这些 ID 的分配方式决定了交互是被归组在一起,还是彼此隔离。
在多用户应用程序中,使 conversation ID 对每个用户唯一(如果用户可以有多个对话,则对每个对话也唯一),以便每个用户的消息都保留在自己的对话中。一种常见做法是在服务器端从当前用户或 session 派生 ID,而不是使用固定或共享的值:
// Build the conversation ID from the current user/session so each
// user's messages are kept in their own conversation.
String conversationId = currentUser.getId() + ":" + httpSession.getId();
chatClient.prompt()
.user(userInput)
.advisors(a -> a.param(ChatMemory.CONVERSATION_ID, conversationId))
.call()
.content();
一些实践有助于随着应用的增长保持会话的条理性:
-
为每个用户分配一个唯一的 conversation ID;当单个用户可以持有多个 conversation 时,为每个 conversation 分配唯一的 conversation ID。
-
在服务器端从用户或 session 派生 conversation ID,而不是跨用户复用固定值。
-
在列出或删除 conversation 时,对属于当前用户的 conversation ID 进行操作,而不是对所有 conversation ID 进行操作。
内存类型
ChatMemory 抽象允许你实现各种类型的 memory,以适应不同的使用场景。memory 类型的选择可能会显著影响应用的性能和行为。本节介绍 Spring AI 提供的内置 memory 类型及其特性。
消息窗口聊天记忆
MessageWindowChatMemory 维护一个消息滑动窗口,最多可达指定的最大大小。当消息数量超过最大值时,较早的消息会被移除,但始终保留 SystemMessage 实例。默认窗口大小为 20 条消息。
MessageWindowChatMemory memory = MessageWindowChatMemory.builder()
.maxMessages(10)
.build();
这是 Spring AI 用于自动配置 ChatMemory Bean 的默认消息类型。
轮次边界驱逐
当需要驱逐时,MessageWindowChatMemory 总是移除完整轮次,而不是在轮次中途截断。一个轮次从 UserMessage 开始,包括之后所有的助手回复、工具调用和工具响应,直到下一个 UserMessage。如果原始驱逐点落在非用户消息上(例如,工具调用交互中间的助手回复),截断点会向前推进到下一个 UserMessage,以使保留的窗口始终从一个完整轮次开始。
这意味着 maxMessages 是存储消息数量的上限 —— 当需要进行对齐以找到下一个轮次边界时,实际数量可能会略低一些。
如果 maxMessages 小于单个完整轮次(例如,超过窗口大小的多步 tool-calling 交互),所有非 system 消息都可能被移除,直到添加新的 UserMessage 为止。请将 maxMessages 设置得足够大,以至少容纳你的用例中的一个代表性轮次。
内存存储
Spring AI 提供了 ChatMemoryRepository 抽象,用于存储聊天记忆。本节介绍 Spring AI 提供的内置 repository 及其使用方式,但你也可以根据需要实现自己的 repository。
In-Memory Repository
InMemoryChatMemoryRepository 使用 ConcurrentHashMap 在内存中存储消息。
默认情况下,如果尚未配置其他仓库,Spring AI 会自动配置一个类型为 InMemoryChatMemoryRepository 的 ChatMemoryRepository bean,你可以直接在应用程序中使用它。
@Autowired
ChatMemoryRepository chatMemoryRepository;
如果你更愿意手动创建 InMemoryChatMemoryRepository,可以按如下方式操作:
ChatMemoryRepository repository = new InMemoryChatMemoryRepository();
JdbcChatMemoryRepository
JdbcChatMemoryRepository 是一个内置实现,使用 JDBC 将消息存储在关系数据库中。它开箱即用支持多种数据库,适用于需要持久化存储聊天记忆的应用。
消息按升序(从旧到新)检索,这是 LLM 会话历史的预期格式。顺序由 sequence_id 列维护,该列记录每条消息在其会话中的位置。每条消息还存储创建 timestamp,并在消息元数据中以 JdbcChatMemoryRepository.CONVERSATION_TS 键作为 java.time.Instant 公开,因此应用程序可以显示消息的创建时间。
JdbcChatMemoryRepository 不支持工具调用消息。 包含工具调用的 AssistantMessage 实例和 ToolResponseMessage 实例会在保存时被静默过滤,并且不会出现在检索到的对话历史中。如果你的应用程序使用工具调用,请考虑 Spring AI Session 项目和 JDBC session store,它们可以正确持久化所有消息类型。
首先,将以下依赖添加到你的项目中:
- Maven
- Gradle
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-jdbc</artifactId>
</dependency>
dependencies {
implementation 'org.springframework.ai:spring-ai-starter-model-chat-memory-repository-jdbc'
}
Spring AI 为 JdbcChatMemoryRepository 提供了自动配置,你可以直接在应用程序中使用。
@Autowired
JdbcChatMemoryRepository chatMemoryRepository;
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
如果你更愿意手动创建 JdbcChatMemoryRepository,可以通过提供 JdbcTemplate 实例和 JdbcChatMemoryRepositoryDialect 来实现:
ChatMemoryRepository chatMemoryRepository = JdbcChatMemoryRepository.builder()
.jdbcTemplate(jdbcTemplate)
.dialect(new PostgresChatMemoryRepositoryDialect())
.build();
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
读取消息时间戳
每条存储的消息都会记录其创建时间。该时间戳可在消息元数据中通过 JdbcChatMemoryRepository.CONVERSATION_TS 键获取,其类型为 java.time.Instant,这对于在 UI 中显示消息时间非常有用:
List<Message> messages = chatMemory.get(conversationId);
for (Message message : messages) {
Instant createdAt = (Instant) message.getMetadata().get(JdbcChatMemoryRepository.CONVERSATION_TS);
}
当会话再次保存时,时间戳会被保留,因此消息在会话的生命周期内会保留其原始创建时间。
支持的数据库和方言抽象
Spring AI 通过方言抽象支持多种关系型数据库。以下数据库开箱即用:
-
PostgreSQL
-
MySQL / MariaDB
-
SQL Server
-
HSQLDB
-
Oracle Database
在使用 JdbcChatMemoryRepositoryDialect.from(DataSource) 时,可以从 JDBC URL 自动检测正确的方言。可以通过实现 JdbcChatMemoryRepositoryDialect 接口来扩展对其他数据库的支持。
配置属性
| 属性 | 描述 | 默认值 |
|---|---|---|
spring.ai.chat.memory.repository.jdbc.initialize-schema | 控制何时初始化 schema。值:embedded (默认)、always、never。 | embedded |
spring.ai.chat.memory.repository.jdbc.schema | 用于初始化的 schema 脚本位置。支持 classpath: URL 和 platform 占位符。 | classpath:org/springframework/ai/chat/memory/repository/jdbc/schema-@@platform@@.sql |
spring.ai.chat.memory.repository.jdbc.platform | 如果使用 @@platform@@ 占位符,则初始化脚本中要使用的 platform。 | 自动检测 |
Schema 初始化
自动配置将在启动时自动创建 SPRING_AI_CHAT_MEMORY 表,并使用特定于你的数据库厂商的 SQL 脚本。默认情况下,schema 初始化仅对嵌入式数据库(H2、HSQL、Derby 等)执行。
自 2.0.0 起,schema 新增了用于决定消息排序的 sequence_id 列,同时保留了现有的 timestamp 列(现在通过消息元数据暴露)。升级现有应用程序需要添加新列;迁移步骤请参见 升级说明。
你可以使用 spring.ai.chat.memory.repository.jdbc.initialize-schema 属性来控制 schema 初始化:
spring.ai.chat.memory.repository.jdbc.initialize-schema=embedded # Only for embedded DBs (default)
spring.ai.chat.memory.repository.jdbc.initialize-schema=always # Always initialize
spring.ai.chat.memory.repository.jdbc.initialize-schema=never # Never initialize (useful with Flyway/Liquibase)
要覆盖 schema 脚本位置,请使用:
spring.ai.chat.memory.repository.jdbc.schema=classpath:/custom/path/schema-mysql.sql
扩展 Dialects
要为新的数据库添加支持,请实现 JdbcChatMemoryRepositoryDialect 接口,并提供用于查询、插入和删除消息的 SQL。然后,你可以将自定义 dialect 传递给 repository builder。
ChatMemoryRepository chatMemoryRepository = JdbcChatMemoryRepository.builder()
.jdbcTemplate(jdbcTemplate)
.dialect(new MyCustomDbDialect())
.build();
CassandraChatMemoryRepository
CassandraChatMemoryRepository 使用 Apache Cassandra 存储消息。它适用于需要持久化存储聊天记忆的应用,尤其适用于对可用性、持久性、规模有要求,以及需要利用 time-to-live(TTL)特性的场景。
CassandraChatMemoryRepository 具有 time-series schema,可记录所有过去的聊天窗口,对治理和审计很有价值。建议将 time-to-live 设置为某个值,例如 3 年。
消息按时间戳升序(从最旧到最新)检索,这是 LLM 对话历史的预期格式。
要使用 CassandraChatMemoryRepository,首先将依赖项添加到你的项目中:
- Maven
- Gradle
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-cassandra</artifactId>
</dependency>
dependencies {
implementation 'org.springframework.ai:spring-ai-starter-model-chat-memory-repository-cassandra'
}
Spring AI 为 CassandraChatMemoryRepository 提供了自动配置,你可以直接在应用程序中使用。
@Autowired
CassandraChatMemoryRepository chatMemoryRepository;
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
如果你希望手动创建 CassandraChatMemoryRepository,可以通过提供一个 CassandraChatMemoryRepositoryConfig 实例来实现:
ChatMemoryRepository chatMemoryRepository = CassandraChatMemoryRepository
.create(CassandraChatMemoryRepositoryConfig.builder().withCqlSession(cqlSession));
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
配置属性
| 属性 | 描述 | 默认值 |
|---|---|---|
spring.cassandra.contactPoints | 用于启动集群发现的宿主节点 | 127.0.0.1 |
spring.cassandra.port | 要连接的 Cassandra 原生协议端口 | 9042 |
spring.cassandra.localDatacenter | 要连接的 Cassandra 数据中心 | datacenter1 |
spring.ai.chat.memory.cassandra.time-to-live | 写入 Cassandra 的消息的存活时间(TTL) | |
spring.ai.chat.memory.cassandra.keyspace | Cassandra keyspace | springframework |
spring.ai.chat.memory.cassandra.messages-column | 消息对应的 Cassandra 列名 | springframework |
spring.ai.chat.memory.cassandra.table | Cassandra 表 | ai_chat_memory |
spring.ai.chat.memory.cassandra.initialize-schema | 是否在启动时初始化 schema。 | true |
Schema 初始化
自动配置将自动创建 ai_chat_memory 表。
你可以通过将属性 spring.ai.chat.memory.repository.cassandra.initialize-schema 设置为 false 来禁用 schema 初始化。
CassandraChatMemoryRepository 不支持 tool call 消息。 包含 tool call 的 AssistantMessage 实例和 ToolResponseMessage 实例会在保存时被静默过滤,不会出现在检索到的对话历史中。如果您的应用使用 tool calling,请考虑 Spring AI Session 项目和 JDBC session store,它们可以正确持久化所有消息类型。
Neo4j ChatMemoryRepository
Neo4jChatMemoryRepository 是一个内置实现,使用 Neo4j 将聊天消息作为节点和关系存储在属性图数据库中。它适合希望利用 Neo4j 的图能力来实现聊天记忆持久化的应用。
消息按消息索引升序(从旧到新)检索,这是 LLM 对话历史的预期格式。
首先,向你的项目添加以下依赖:
- Maven
- Gradle
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-neo4j</artifactId>
</dependency>
dependencies {
implementation 'org.springframework.ai:spring-ai-starter-model-chat-memory-repository-neo4j'
}
Spring AI 为 Neo4jChatMemoryRepository 提供了自动配置,你可以直接在应用程序中使用。
@Autowired
Neo4jChatMemoryRepository chatMemoryRepository;
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
如果你更愿意手动创建 Neo4jChatMemoryRepository,可以通过提供 Neo4j Driver 实例来实现:
ChatMemoryRepository chatMemoryRepository = Neo4jChatMemoryRepository.builder()
.driver(driver)
.build();
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
配置属性
| 属性 | 描述 | 默认值 |
|---|---|---|
spring.ai.chat.memory.repository.neo4j.session-label | 存储会话的节点标签 | Session |
spring.ai.chat.memory.repository.neo4j.message-label | 存储消息的节点标签 | Message |
spring.ai.chat.memory.repository.neo4j.tool-call-label | 存储工具调用(例如 Assistant Messages 中)的节点标签 | ToolCall |
spring.ai.chat.memory.repository.neo4j.metadata-label | 存储消息元数据的节点标签 | Metadata |
spring.ai.chat.memory.repository.neo4j.tool-response-label | 存储工具响应的节点标签 | ToolResponse |
spring.ai.chat.memory.repository.neo4j.media-label | 存储与消息关联的媒体的节点标签 | Media |
标签值必须是有效的 Neo4j 标识符:它们必须以字母或下划线开头,并且只能包含字母、数字或下划线。提供不符合这些要求的值将导致在应用启动时抛出 IllegalArgumentException。
索引初始化
Neo4j 存储库会自动确保为会话 ID 和消息索引创建索引,以优化性能。如果你使用自定义标签,也会为这些标签创建索引。无需进行 schema 初始化,但你应确保你的应用程序可以访问 Neo4j 实例。
CosmosDBChatMemoryRepository
CosmosDBChatMemoryRepository chat memory repository 支持作为由 Azure Cosmos DB 团队维护的外部模块提供。更多信息请参见 相关文档。
MongoChatMemoryRepository
MongoChatMemoryRepository 是一个内置实现,使用 MongoDB 存储消息。它适用于需要灵活的文档型数据库来持久化聊天记忆的应用程序。
消息按时间戳升序(从旧到新)检索,这是 LLM 对话历史的预期格式。此排序在所有聊天记忆存储库实现中保持一致。
MongoChatMemoryRepository 不支持工具调用消息。 包含工具调用的 AssistantMessage 实例和 ToolResponseMessage 实例会在保存时被静默过滤,不会出现在检索到的对话历史中。如果你的应用使用工具调用,请考虑使用 Spring AI Session 项目和 JDBC session store,它们可以正确持久化所有消息类型。
首先,向你的项目添加以下依赖:
- Maven
- Gradle
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-mongodb</artifactId>
</dependency>
dependencies {
implementation 'org.springframework.ai:spring-ai-starter-model-chat-memory-repository-mongodb'
}
Spring AI 为 MongoChatMemoryRepository 提供了自动配置,你可以直接在应用程序中使用。
@Autowired
MongoChatMemoryRepository chatMemoryRepository;
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
如果你更愿意手动创建 MongoChatMemoryRepository,可以通过提供 MongoTemplate 实例来实现:
ChatMemoryRepository chatMemoryRepository = MongoChatMemoryRepository.builder()
.mongoTemplate(mongoTemplate)
.build();
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
配置属性
| 属性 | 描述 | 默认值 |
|---|---|---|
spring.ai.chat.memory.repository.mongo.create-indices | 启动时是否应自动创建或重新创建索引。注意:更改 * TTL 值将删除并重新创建 TTL 索引 | false |
spring.ai.chat.memory.repository.mongo.ttl | 写入 MongoDB 的消息的生存时间(TTL),以秒为单位。如果未设置,消息将无限期存储。 | 0 |
集合初始化
自动配置会在启动时自动创建 ai_chat_memory 集合(如果该集合尚不存在)。
RedisChatMemoryRepository
RedisChatMemoryRepository 是一个内置实现,使用 Redis Stack(包含 Redis Query Engine 和 RedisJSON)来存储聊天消息。它适用于需要高性能、低延迟聊天记忆持久化,并支持可选 TTL(time-to-live)和高级查询能力的应用程序。
该 repository 将消息存储为 JSON 文档,并创建搜索索引以实现高效查询。它还通过 AdvancedRedisChatMemoryRepository 接口提供扩展查询能力,支持按内容、类型、时间范围和元数据搜索消息。
消息按时间戳升序(从旧到新)检索,这是 LLM 对话历史的预期格式。
首先,将以下依赖添加到你的项目中:
- Maven
- Gradle
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-redis</artifactId>
</dependency>
dependencies {
implementation 'org.springframework.ai:spring-ai-starter-model-chat-memory-repository-redis'
}
Spring AI 为 RedisChatMemoryRepository 提供了自动配置,你可以在应用程序中直接使用。
@Autowired
RedisChatMemoryRepository chatMemoryRepository;
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
如果你更愿意手动创建 RedisChatMemoryRepository,可以通过提供 RedisClient 客户端来实现:
RedisClient jedisClient = RedisClient.builder().hostAndPort("localhost", 6379).build();
ChatMemoryRepository chatMemoryRepository = RedisChatMemoryRepository.builder()
.jedisClient(jedisClient)
.indexName("my-chat-index")
.keyPrefix("my-chat:")
.timeToLive(Duration.ofHours(24))
.build();
ChatMemory chatMemory = MessageWindowChatMemory.builder()
.chatMemoryRepository(chatMemoryRepository)
.maxMessages(10)
.build();
配置属性
| Property | Description | Default Value |
|---|---|---|
spring.ai.chat.memory.repository.redis.host | Redis 服务器主机 | localhost |
spring.ai.chat.memory.repository.redis.port | Redis 服务器端口 | 6379 |
spring.ai.chat.memory.repository.redis.username | Redis ACL 用户名 | 无 |
spring.ai.chat.memory.repository.redis.password | Redis 服务器密码 | 无 |
spring.ai.chat.memory.repository.redis.index-name | Redis 搜索索引的名称 | chat-memory-idx |
spring.ai.chat.memory.repository.redis.key-prefix | 聊天记忆条目的键前缀 | chat-memory: |
spring.ai.chat.memory.repository.redis.time-to-live | 聊天记忆条目的存活时间(例如 24h、30d) | 无过期时间 |
spring.ai.chat.memory.repository.redis.initialize-schema | 是否在启动时初始化 Redis 模式 | true |
spring.ai.chat.memory.repository.redis.max-conversation-ids | 要返回的最大会话 ID 数量 | 1000 |
spring.ai.chat.memory.repository.redis.max-messages-per-conversation | 每个会话要返回的最大消息数量 | 1000 |
高级查询
RedisChatMemoryRepository 还实现了 AdvancedRedisChatMemoryRepository,其提供扩展查询能力:
// Cast to access advanced features
AdvancedRedisChatMemoryRepository advancedRepo = (AdvancedRedisChatMemoryRepository) chatMemoryRepository;
// Find messages by type across all conversations
List<MessageWithConversation> userMessages = advancedRepo.findByType(MessageType.USER, 100);
// Find messages containing specific content
List<MessageWithConversation> results = advancedRepo.findByContent("Spring AI", 50);
// Find messages within a time range
List<MessageWithConversation> recentMessages = advancedRepo.findByTimeRange(
conversationId,
Instant.now().minus(Duration.ofHours(1)),
Instant.now(),
100
);
// Find messages by metadata
List<MessageWithConversation> priorityMessages = advancedRepo.findByMetadata("priority", "high", 50);
// Execute custom Redis queries
List<MessageWithConversation> customResults = advancedRepo.executeQuery("@type:USER @content:Redis", 100);
元数据字段索引
为了支持对自定义元数据字段的高效查询,你可以配置元数据字段定义:
spring.ai.chat.memory.repository.redis.metadata-fields[0].name=priority
spring.ai.chat.memory.repository.redis.metadata-fields[0].type=tag
spring.ai.chat.memory.repository.redis.metadata-fields[1].name=score
spring.ai.chat.memory.repository.redis.metadata-fields[1].type=numeric
spring.ai.chat.memory.repository.redis.metadata-fields[2].name=category
spring.ai.chat.memory.repository.redis.metadata-fields[2].type=tag
支持的字段类型包括:tag(用于精确匹配过滤)、text(用于全文搜索)和 numeric(用于范围查询)。
Schema 初始化
自动配置会在启动时自动创建 Redis 搜索索引(如果尚不存在)。你可以通过设置 spring.ai.chat.memory.repository.redis.initialize-schema=false 来禁用此行为。
要求
-
Redis Stack 7.0 或更高版本(包含 Redis Query Engine 和 RedisJSON 模块)
-
Jedis 客户端库(作为依赖项包含)
聊天客户端中的 Memory
在使用 ChatClient API 时,你可以提供一个 ChatMemory 实现,以便在多次交互中维护对话上下文。
Spring AI 提供了一些内置 Advisors,你可以根据需要使用它们来配置 ChatClient 的记忆行为。
目前,执行工具调用时与大语言模型交换的中间消息不会存储在内存中。这是当前实现的一个限制,将在未来版本中解决。如果需要存储这些消息,请参阅 用户控制的工具执行 中的说明。
-
MessageChatMemoryAdvisor。该 advisor 使用提供的ChatMemory实现来管理对话记忆。在每次交互时,它会从记忆中检索对话历史,并将其作为消息集合包含在 prompt 中。 -
VectorStoreChatMemoryAdvisor。该 advisor 使用提供的VectorStore实现来管理对话记忆。在每次交互时,它会从向量存储中检索对话历史,并将其作为纯文本追加到 system message 中。
例如,如果你想将 MessageWindowChatMemory 与 MessageChatMemoryAdvisor 一起使用,可以按如下方式配置:
ChatMemory chatMemory = MessageWindowChatMemory.builder().build();
ChatClient chatClient = ChatClient.builder(chatModel)
.defaultAdvisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
.build();
在对 ChatClient 执行调用时,记忆将由 MessageChatMemoryAdvisor 自动管理。会话历史将根据指定的会话 ID 从记忆中检索。
对于所有 memory advisors,ChatMemory.CONVERSATION_ID 参数是必需的。省略此参数的调用将在运行时抛出 IllegalArgumentException。没有默认的 conversation ID。
String conversationId = "007";
chatClient.prompt()
.user("Do I have license to code?")
.advisors(a -> a.param(ChatMemory.CONVERSATION_ID, conversationId))
.call()
.content();
VectorStoreChatMemoryAdvisor
自定义模板
VectorStoreChatMemoryAdvisor 使用默认模板,通过检索到的对话记忆来增强系统消息。你可以通过 .promptTemplate() builder 方法提供自己的 PromptTemplate 对象来自定义此行为。
此处提供的 PromptTemplate 自定义了 advisor 如何将检索到的 memory 与 system message 合并。这与在 ChatClient 本身配置 TemplateRenderer(使用 .templateRenderer())不同,后者会影响 advisor 运行 之前 初始 user/system prompt 内容的渲染。有关客户端级模板渲染的更多详细信息,请参见 ChatClient Prompt Templates。
自定义 PromptTemplate 可以使用任何 TemplateRenderer 实现(默认使用基于 StringTemplate 引擎的 StPromptTemplate)。重要要求是模板必须包含以下两个占位符:
-
一个
instructions占位符,用于接收原始系统消息。 -
一个
long_term_memory占位符,用于接收检索到的对话记忆。
聊天模型中的记忆
如果你直接使用 ChatModel 而不是 ChatClient,可以显式管理 memory:
// Create a memory instance
ChatMemory chatMemory = MessageWindowChatMemory.builder().build();
String conversationId = "007";
// First interaction
UserMessage userMessage1 = new UserMessage("My name is James Bond");
chatMemory.add(conversationId, userMessage1);
ChatResponse response1 = chatModel.call(new Prompt(chatMemory.get(conversationId)));
chatMemory.add(conversationId, response1.getResult().getOutput());
// Second interaction
UserMessage userMessage2 = new UserMessage("What is my name?");
chatMemory.add(conversationId, userMessage2);
ChatResponse response2 = chatModel.call(new Prompt(chatMemory.get(conversationId)));
chatMemory.add(conversationId, response2.getResult().getOutput());
// The response will contain "James Bond"