聊天记忆

大语言模型（LLM）是无状态的，意味着它们不会保留关于先前交互的信息。当你希望在多次交互之间维持上下文或状态时，这会成为一个限制。为解决这一点，Spring AI 提供了聊天记忆功能，让你能够在与 LLM 的多次交互之间存储并检索信息。

ChatMemory 抽象允许你实现多种类型的记忆以支持不同的用例。消息的底层存储由 ChatMemoryRepository 处理，它唯一的职责就是存储和检索消息。由 ChatMemory 实现来决定保留哪些消息、何时移除它们。策略的例子可以包括：保留最近 N 条消息、在某个时间段内保留消息、或保留到某个令牌上限为止。

在选择记忆类型之前，理解聊天记忆（chat memory）与聊天历史（chat history）之间的区别至关重要。

聊天记忆（Chat Memory）。大语言模型在整个对话过程中保留并使用、以维持上下文感知的信息。
聊天历史（Chat History）。完整的对话历史，包括用户与模型之间交换的所有消息。

ChatMemory 抽象专为管理聊天记忆而设计。它允许你存储和检索与当前对话上下文相关的消息。然而，它并不适合用来存储聊天历史。如果你需要维护所有交换消息的完整记录，应考虑使用另一种方法，比如借助 Spring Data 来高效存储和检索完整的聊天历史。

快速开始

Spring AI 会自动配置一个可直接在应用中使用的 ChatMemory bean。默认情况下，它使用一个内存仓库来存储消息（InMemoryChatMemoryRepository），并使用 MessageWindowChatMemory 实现来管理对话历史。如果已配置了其他仓库（例如 Cassandra、JDBC 或 Neo4j），Spring AI 将改用那个。

java

@Autowired
ChatMemory chatMemory;

接下来的各节将进一步介绍 Spring AI 中提供的不同记忆类型与仓库。

使用对话 ID

每一次聊天记忆操作都以对话 ID 作为键。 ChatMemory 与 ChatMemoryRepository 抽象使用该标识符来决定读取、追加或删除哪个对话，并且它必须始终显式提供。

对话 ID 是唯一界定对话范围的东西。消息针对所提供的那个对话 ID 精确地存取，因此这些 ID 如何分配，决定了交互是被归到一起还是彼此分开。

在多用户应用中，让对话 ID 按用户唯一（若一个用户可以拥有多个对话，也按对话唯一），从而让每个用户的消息都留在自己的对话中。一种常见做法是在服务端由当前用户或会话派生出 ID，而不是使用固定或共享的值：

java

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

随着应用增长，有几项实践有助于保持对话井然有序：

为每个用户分配一个不同的对话 ID，并在单个用户可拥有多个对话时按对话区分。
在服务端由用户或会话派生对话 ID，而不是跨用户复用固定值。
在列出或删除对话时，只针对属于当前用户的对话 ID 操作，而非在所有对话 ID 上操作。

记忆类型

ChatMemory 抽象允许你实现多种类型的记忆以适应不同用例。记忆类型的选择会显著影响应用的性能与行为。本节介绍 Spring AI 提供的内置记忆类型及其特性。

消息窗口聊天记忆

MessageWindowChatMemory 维护一个滑动消息窗口，至多到指定的最大数量。当消息数超过最大值时，较旧的消息会被驱逐，同时始终保留 SystemMessage 实例。默认窗口大小为 20 条消息。

java

MessageWindowChatMemory memory = MessageWindowChatMemory.builder()
    .maxMessages(10)
    .build();

这是 Spring AI 用于自动配置 ChatMemory bean 的默认消息类型。

按回合边界驱逐

当需要驱逐时，MessageWindowChatMemory 总是移除整个回合，而不会在一回合中间截断。一个回合从一个 UserMessage 开始，包含后续的所有助手回复、工具调用和工具响应，直到下一个 UserMessage。如果原始的驱逐落点落在非用户消息上（例如工具调用交换中间的一条助手回复），截断点会前移到下一个 UserMessage，从而让保留的窗口总是始于一个完整的回合。

这意味着 maxMessages 是所存消息数的上限——当需要对齐到下一个回合边界时，实际数量可能略低。

NOTE

如果 maxMessages 小于一个完整回合（例如一个超出窗口大小的多步工具调用交换），那么所有非系统消息可能都被驱逐，直到新添加一个 UserMessage。请为你的用例把 maxMessages 设置得足够大，以至少容纳一个有代表性的回合。

记忆存储

Spring AI 提供用于存储聊天记忆的 ChatMemoryRepository 抽象。本节介绍 Spring AI 提供的内置仓库及其用法，如有需要你也可以实现自己的仓库。

内存仓库

InMemoryChatMemoryRepository 使用 ConcurrentHashMap 在内存中存储消息。

默认情况下，若尚未配置其他仓库，Spring AI 会自动配置一个 InMemoryChatMemoryRepository 类型的 ChatMemoryRepository bean，可直接在应用中使用。

java

@Autowired
ChatMemoryRepository chatMemoryRepository;

如果你更想手动创建 InMemoryChatMemoryRepository，可以像下面这样做：

java

ChatMemoryRepository repository = new InMemoryChatMemoryRepository();

JdbcChatMemoryRepository

JdbcChatMemoryRepository 是一个内置实现，使用 JDBC 把消息存储在关系数据库中。它开箱即用地支持多种数据库，适合需要持久化存储聊天记忆的应用。

消息以升序（从旧到新）检索，这是 LLM 对话历史所期望的格式。顺序由一个 sequence_id 列维持，它记录每条消息在其对话中的位置。每条消息还存储一个创建 timestamp，在消息元数据中以 JdbcChatMemoryRepository.CONVERSATION_TS 键、作为 java.time.Instant 暴露，以便应用显示消息的创建时间。

DANGER

JdbcChatMemoryRepository 不支持工具调用消息。 包含工具调用的 AssistantMessage 实例和 ToolResponseMessage 实例在保存时会被静默过滤，不会出现在检索到的对话历史中。如果你的应用使用工具调用，请考虑 Spring AI Session 项目及 JDBC 会话存储，它们能正确持久化所有消息类型。

首先，将以下依赖添加到你的项目：

xml

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

Spring AI 为 JdbcChatMemoryRepository 提供自动配置，可直接在应用中使用。

java

@Autowired
JdbcChatMemoryRepository chatMemoryRepository;

ChatMemory chatMemory = MessageWindowChatMemory.builder()
    .chatMemoryRepository(chatMemoryRepository)
    .maxMessages(10)
    .build();

如果你更想手动创建 JdbcChatMemoryRepository，可以通过提供一个 JdbcTemplate 实例和一个 JdbcChatMemoryRepositoryDialect 来实现：

java

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 中显示消息时间：

java

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`	控制何时初始化模式。取值：`embedded`（默认）、`always`、`never`。	`embedded`
`spring.ai.chat.memory.repository.jdbc.schema`	用于初始化的模式脚本位置。支持 `classpath:` URL 与平台占位符。	`classpath:org/springframework/ai/chat/memory/repository/jdbc/schema-@@platform@@.sql`
`spring.ai.chat.memory.repository.jdbc.platform`	当使用 @@platform@@ 占位符时，初始化脚本所采用的平台。	auto-detected

模式初始化

自动配置会在启动时，为你的数据库使用一个厂商特定的 SQL 脚本自动创建 SPRING_AI_CHAT_MEMORY 表。默认情况下，模式初始化仅对内嵌数据库（H2、HSQL、Derby 等）运行。

NOTE

自 2.0.0 起，模式新增了一个用于决定消息顺序的 sequence_id 列，与既有的 timestamp 列并存（后者现经消息元数据暴露）。升级既有应用需要添加新列；迁移步骤参见 upgrade-notes。

你可以使用 spring.ai.chat.memory.repository.jdbc.initialize-schema 属性来控制模式初始化：

properties

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)

要覆盖模式脚本位置，使用：

properties

spring.ai.chat.memory.repository.jdbc.schema=classpath:/custom/path/schema-mysql.sql

扩展方言

要为某个新数据库添加支持，请实现 JdbcChatMemoryRepositoryDialect 接口并提供用于选择、插入和删除消息的 SQL。然后把你自定义的方言传给仓库构建器。

java

ChatMemoryRepository chatMemoryRepository = JdbcChatMemoryRepository.builder()
    .jdbcTemplate(jdbcTemplate)
    .dialect(new MyCustomDbDialect())
    .build();

CassandraChatMemoryRepository

CassandraChatMemoryRepository 使用 Apache Cassandra 存储消息。它适合需要持久化存储聊天记忆的应用，尤其是在可用性、耐久性、可扩展性方面，以及利用存活时间（TTL）特性时。

CassandraChatMemoryRepository 采用时间序列模式，保留所有历史聊天窗口的记录，这对治理与审计很有价值。建议把存活时间设为某个值，例如三年。

消息按时间戳升序（从旧到新）检索，这是 LLM 对话历史所期望的格式。

要使用 CassandraChatMemoryRepository，首先将依赖添加到你的项目：

xml

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

Spring AI 为 CassandraChatMemoryRepository 提供自动配置，可直接在应用中使用。

java

@Autowired
CassandraChatMemoryRepository chatMemoryRepository;

ChatMemory chatMemory = MessageWindowChatMemory.builder()
    .chatMemoryRepository(chatMemoryRepository)
    .maxMessages(10)
    .build();

如果你更想手动创建 CassandraChatMemoryRepository，可以通过提供一个 CassandraChatMemoryRepositoryConfig 实例来实现：

java

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 键空间	`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`
是否在启动时初始化模式。	`true`

模式初始化

自动配置会自动创建 ai_chat_memory 表。

你可以通过把属性 spring.ai.chat.memory.repository.cassandra.initialize-schema 设为 false 来禁用模式初始化。

DANGER

CassandraChatMemoryRepository 不支持工具调用消息。 包含工具调用的 AssistantMessage 实例和 ToolResponseMessage 实例在保存时会被静默过滤，不会出现在检索到的对话历史中。如果你的应用使用工具调用，请考虑 Spring AI Session 项目及 JDBC 会话存储，它们能正确持久化所有消息类型。

Neo4j ChatMemoryRepository

Neo4jChatMemoryRepository 是一个内置实现，使用 Neo4j 把聊天消息作为属性图数据库中的节点和关系来存储。它适合希望借助 Neo4j 图能力做聊天记忆持久化的应用。

消息按消息索引升序（从旧到新）检索，这是 LLM 对话历史所期望的格式。

首先，将以下依赖添加到你的项目：

xml

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

Spring AI 为 Neo4jChatMemoryRepository 提供自动配置，可直接在应用中使用。

java

@Autowired
Neo4jChatMemoryRepository chatMemoryRepository;

ChatMemory chatMemory = MessageWindowChatMemory.builder()
    .chatMemoryRepository(chatMemoryRepository)
    .maxMessages(10)
    .build();

如果你更想手动创建 Neo4jChatMemoryRepository，可以通过提供一个 Neo4j Driver 实例来实现：

java

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`	存储工具调用（例如在助手消息中）的节点的标签	`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`

NOTE

标签值必须是有效的 Neo4j 标识符：必须以字母或下划线开头，且仅包含字母、数字或下划线。

提供的值若不满足这些要求，会导致在应用启动时抛出 IllegalArgumentException。

索引初始化

Neo4j 仓库会自动确保为对话 ID 和消息索引创建索引以优化性能。如果你使用自定义标签，也会为这些标签创建索引。无需模式初始化，但你应确保你的 Neo4j 实例对应用可访问。

CosmosDBChatMemoryRepository

CosmosDBChatMemoryRepository 聊天记忆仓库支持作为一个由 Azure Cosmos DB 团队维护的外部模块提供。更多信息参见相关文档。

MongoChatMemoryRepository

MongoChatMemoryRepository 是一个内置实现，使用 MongoDB 存储消息。它适合需要一个灵活的、面向文档的数据库来做聊天记忆持久化的应用。

消息按时间戳升序（从旧到新）检索，这是 LLM 对话历史所期望的格式。此顺序在所有聊天记忆仓库实现中保持一致。

DANGER

MongoChatMemoryRepository 不支持工具调用消息。 包含工具调用的 AssistantMessage 实例和 ToolResponseMessage 实例在保存时会被静默过滤，不会出现在检索到的对话历史中。如果你的应用使用工具调用，请考虑 Spring AI Session 项目及 JDBC 会话存储，它们能正确持久化所有消息类型。

首先，将以下依赖添加到你的项目：

xml

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

Spring AI 为 MongoChatMemoryRepository 提供自动配置，可直接在应用中使用。

java

@Autowired
MongoChatMemoryRepository chatMemoryRepository;

ChatMemory chatMemory = MessageWindowChatMemory.builder()
    .chatMemoryRepository(chatMemoryRepository)
    .maxMessages(10)
    .build();

如果你更想手动创建 MongoChatMemoryRepository，可以通过提供一个 MongoTemplate 实例来实现：

java

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 查询引擎与 RedisJSON）存储聊天消息。它适合需要高性能、低延迟聊天记忆持久化、可选 TTL（存活时间）支持以及高级查询能力的应用。

该仓库把消息存储为 JSON 文档，并创建一个搜索索引以实现高效查询。它还通过 AdvancedRedisChatMemoryRepository 接口提供扩展的查询能力，可按内容、类型、时间范围和元数据搜索消息。

消息按时间戳升序（从旧到新）检索，这是 LLM 对话历史所期望的格式。

首先，将以下依赖添加到你的项目：

xml

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

Spring AI 为 RedisChatMemoryRepository 提供自动配置，可直接在应用中使用。

java

@Autowired
RedisChatMemoryRepository chatMemoryRepository;

ChatMemory chatMemory = MessageWindowChatMemory.builder()
    .chatMemoryRepository(chatMemoryRepository)
    .maxMessages(10)
    .build();

如果你更想手动创建 RedisChatMemoryRepository，可以通过提供一个 RedisClient 客户端来实现：

java

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

配置属性

属性	描述	默认值
`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 用户名	none
`spring.ai.chat.memory.repository.redis.password`	Redis 服务器密码	none
`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`）	no expiration
`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，后者提供扩展的查询能力：

java

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

元数据字段索引

要对自定义元数据字段启用高效查询，你可以配置元数据字段定义：

properties

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（用于范围查询）。

模式初始化

如果 Redis 搜索索引尚不存在，自动配置会在启动时自动创建它。你可以通过设置 spring.ai.chat.memory.repository.redis.initialize-schema=false 来禁用此行为。

要求

Redis Stack 7.0 或更高（含 Redis 查询引擎与 RedisJSON 模块）
Jedis 客户端库（作为依赖引入）

在 Chat Client 中使用记忆

当使用 ChatClient API 时，你可以提供一个 ChatMemory 实现，以在多次交互之间维持对话上下文。

Spring AI 提供了几个内置顾问，你可以根据需要配置 ChatClient 的记忆行为。

DANGER

目前，在执行工具调用时与大语言模型交换的中间消息不会存储到记忆中。这是当前实现的一个限制，将在未来版本中解决。如果你需要存储这些消息，请参考用户控制工具执行的说明。

MessageChatMemoryAdvisor。该顾问使用所提供的 ChatMemory 管理对话记忆。每次交互时，它从记忆中检索对话历史，并以一组消息的形式包含进提示词。
VectorStoreChatMemoryAdvisor。该顾问使用所提供的 VectorStore 管理对话记忆。每次交互时，它从向量库检索对话历史，并以纯文本形式追加到系统消息中。

例如，如果你想把 MessageWindowChatMemory 与 MessageChatMemoryAdvisor 一起使用，可以像下面这样配置：

java

ChatMemory chatMemory = MessageWindowChatMemory.builder().build();

ChatClient chatClient = ChatClient.builder(chatModel)
    .defaultAdvisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
    .build();

在对 ChatClient 发起调用时，记忆会由 MessageChatMemoryAdvisor 自动管理。对话历史会依据所指定的对话 ID 从记忆中检索。

WARNING

ChatMemory.CONVERSATION_ID 参数对所有记忆顾问都是必需的。省略该参数的调用会在运行时抛出 IllegalArgumentException。没有默认的对话 ID。

java

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() 构建器方法提供你自己的 PromptTemplate 对象来自定义这一行为。

NOTE

这里提供的 PromptTemplate 定制的是顾问如何把检索到的记忆与系统消息合并。这不同于在 ChatClient 本身配置 TemplateRenderer（使用 .templateRenderer()），后者影响的是顾问运行之前、初始用户/系统提示词内容的渲染。关于客户端级模板渲染的更多细节，参见 ChatClient 提示词模板。

自定义的 PromptTemplate 可以使用任何 TemplateRenderer 实现（默认使用基于 StringTemplate 引擎的 StPromptTemplate）。重要的要求是，模板必须包含以下两个占位符：

一个 instructions 占位符，用于接收原始系统消息。
一个 long_term_memory 占位符，用于接收检索到的对话记忆。

在 Chat Model 中使用记忆

如果你是直接操作 ChatModel 而非 ChatClient，可以显式地管理记忆：

java

// 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"

顾问（Advisor）API

聊天模型 API

嵌入模型 API

Amazon Bedrock

VertexAI

图像模型 API

音频模型

转录 API

文本转语音（TTS）API

审核模型

MCP 服务端 Boot Starter

MCP 注解

聊天记忆

快速开始

使用对话 ID

记忆类型

消息窗口聊天记忆

按回合边界驱逐

记忆存储

内存仓库

JdbcChatMemoryRepository

读取消息时间戳

受支持的数据库与方言抽象

配置属性

模式初始化

扩展方言

CassandraChatMemoryRepository

配置属性

模式初始化

Neo4j ChatMemoryRepository

配置属性

索引初始化

CosmosDBChatMemoryRepository

MongoChatMemoryRepository

配置属性

集合初始化

RedisChatMemoryRepository

配置属性

高级查询

元数据字段索引

模式初始化

要求

在 Chat Client 中使用记忆

VectorStoreChatMemoryAdvisor

自定义模板

在 Chat Model 中使用记忆

友情链接