跳到主要内容
版本:2.0.1

Chat Memory

QWen Max 中英对照 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,它们可以正确持久化所有消息类型。

首先,将以下依赖添加到你的项目中:

<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-jdbc</artifactId>
</dependency>

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,首先将依赖项添加到你的项目中:

<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-cassandra</artifactId>
</dependency>

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.keyspaceCassandra keyspacespringframework
spring.ai.chat.memory.cassandra.messages-column消息对应的 Cassandra 列名springframework
spring.ai.chat.memory.cassandra.tableCassandra 表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 对话历史的预期格式。

首先,向你的项目添加以下依赖:

<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-neo4j</artifactId>
</dependency>

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,它们可以正确持久化所有消息类型。

首先,向你的项目添加以下依赖:

<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-mongodb</artifactId>
</dependency>

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 对话历史的预期格式。

首先,将以下依赖添加到你的项目中:

<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-chat-memory-repository-redis</artifactId>
</dependency>

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();

配置属性​

PropertyDescriptionDefault Value
spring.ai.chat.memory.repository.redis.hostRedis 服务器主机localhost
spring.ai.chat.memory.repository.redis.portRedis 服务器端口6379
spring.ai.chat.memory.repository.redis.usernameRedis ACL 用户名无
spring.ai.chat.memory.repository.redis.passwordRedis 服务器密码无
spring.ai.chat.memory.repository.redis.index-nameRedis 搜索索引的名称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 从记忆中检索。

important

对于所有 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"