记忆模块离不开上下文，通常会是在某个Agent场景（namespace）、某个会话、某个用户的Agent交互信息，Agent的复杂，体现在通过上下文信息理解用户、以及懂用户的复杂，主要体现在：

其中交互的复杂性，主要体现在：

Agent的上下文交互，通过记忆存储，能够分析准确性（不一定要feedback通过点赞、点踩方式，相似的问题用户问了2次证明第一次处理没有准确），通过分析与强化学习、让Agent越来越聪明。其次也可以沉淀用户画像，让Agent更懂你。把上下文进行记忆存储，进行后期用户画像沉淀、准确度或体验提升很关键。

<spring-ai.version>1.1.2</spring-ai.version>
 <spring-ai-alibaba.version>1.1.0.0-RC2</spring-ai-alibaba.version>
<spring-boot.version>3.4.8</spring-boot.version>

import com.alibaba.cloud.ai.graph.OverAllState;

import com.alibaba.cloud.ai.graph.agent.ReactAgent;
import com.alibaba.cloud.ai.graph.RunnableConfig;
import com.alibaba.cloud.ai.graph.agent.hook.HookPosition;
import com.alibaba.cloud.ai.graph.agent.hook.ModelHook;
import com.alibaba.cloud.ai.graph.checkpoint.savers.MemorySaver;
import com.alibaba.cloud.ai.graph.exception.GraphRunnerException;

import com.alibaba.cloud.ai.graph.store.Store;
import com.alibaba.cloud.ai.graph.store.StoreSearchRequest;
import com.alibaba.cloud.ai.graph.store.StoreSearchResult;
import com.alibaba.cloud.ai.graph.store.stores.MemoryStore;
import com.alibaba.cloud.ai.graph.store.StoreItem;
import com.am.utils.LLmsUtils;
import org.springframework.ai.chat.model.ToolContext;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.deepseek.DeepSeekChatModel;
import org.springframework.ai.tool.ToolCallback;
import org.springframework.ai.tool.function.FunctionToolCallback;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiFunction;
// MemoryStore 将数据保存到内存字典中。在生产环境中请使用基于数据库的存储实现
    private MemoryStore store = new MemoryStore();
    private Map<String, Object> profileData = new HashMap<>();

    String userId = "user_001";
    String userKey = "key_"+userId;
    List<String> namespace = List.of("user_profiles");



    // 定义请求和响应记录
    public record GetMemoryRequest(List<String> namespace, String key) {}
    public record MemoryResponse(String message, Map<String, Object> value) {}

    //保存记忆

    @Test
    public void setMemoryData() throws GraphRunnerException {
        // 保存记忆
        profileData.put("name", "王小明");
        profileData.put("age", 28);
        profileData.put("email", "wang@example.com");

        profileData.put("preferences", List.of("喜欢咖啡", "喜欢阅读"));
        profileData.put("rules", List.of(
                "用户喜欢简短直接的语言",
                "用户只说中文和Java"
        ));

        profileData.put("language", "中文");

        StoreItem userItem = StoreItem.of(namespace, userKey, profileData);
        store.putItem(userItem);

        // 通过ID获取记忆
        Optional<StoreItem> retrievedItem = store.getItem(namespace, userKey);
        System.out.println(retrievedItem.get().getKey() + " ==== "  + retrievedItem.get().getValue());

        // 通过命名空间内搜索记忆，通过内容等价性过滤，按向量相似度排序
        StoreSearchRequest request = new StoreSearchRequest();
        request.setNamespace(namespace);
//        request.setFilter(Map.of("my-key", "my-value"));

        StoreSearchResult result = store.searchItems(request);
        List<StoreItem> items  = result.getItems();
//        List<StoreItem> items = store.searchItems(namespace, Map.of("my-key", "my-value"));
//        System.out.println(items);


//        ==================  通过工具读取记忆
        // 运行Agent的 config
        RunnableConfig config = RunnableConfig.builder()
                .threadId("session_001")
                .addMetadata("user_id", userId)
                .store(store)
                .build();

        // 创建获取用户信息的工具
        BiFunction<GetMemoryRequest, ToolContext, MemoryResponse> getUserInfoFunction =
                (memoryRequest, context) -> {
                    RunnableConfig runnableConfig = (RunnableConfig) context.getContext().get("config");
                    Store store = runnableConfig.store();
                    Optional<StoreItem> itemOpt = store.getItem(memoryRequest.namespace(), memoryRequest.key());
                    if (itemOpt.isPresent()) {
                        Map<String, Object> value = itemOpt.get().getValue();
                        return new MemoryResponse("找到用户信息", value);
                    }
                    return new MemoryResponse("未找到用户", Map.of());
                };

        ToolCallback getUserInfoTool = FunctionToolCallback.builder("getUserInfo", getUserInfoFunction)
                .description("查询用户信息")
                .inputType(GetMemoryRequest.class)
                .build();

        DeepSeekChatModel chatModel = LLmsUtils.getDeepSeekChatModel(LLmsUtils.getDeepSeek(), LLmsUtils.getDeepSeekOptions());

//        // 创建Agent
        ReactAgent agent = ReactAgent.builder()
                .name("memory_agent")
                .model(chatModel)
                .tools(getUserInfoTool)
                .saver(new MemorySaver())
                .toolContext(Map.of("config", config))
                .build();


        Optional<OverAllState> invoke = agent.invoke("查询用户信息，namespace=['user_profiles'], key='key_user_001'", config);
        OverAllState overAllState = invoke.get();
        Map<String, Object> data = overAllState.data();
        for (Map.Entry<String, Object> entry : data.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }


        //通过拦截器在调用前后，自动获取与保存记忆
        ReactAgent interceptorAgent = ReactAgent.builder()
                .name("interceptor_agent")
                .model(chatModel)
                .hooks(memoryInterceptor)
                .tools(getUserInfoTool)
                .saver(new MemorySaver())
                .toolContext(Map.of("config", config))
                .build();

//        Optional<OverAllState> invoked = interceptorAgent.invoke("请介绍一下我的信息", config);
        Optional<OverAllState> invoked = interceptorAgent.invoke("请介绍一下我的信息，namespace=['user_profiles'], key='key_user_001'", config);
        OverAllState overAll = invoked.get();
        Map<String, Object> map = overAll.data();
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }

  Agent hook方式，通过拦截器在agent使用前查询，交互过程存储更新逻辑

// 创建记忆拦截器
ModelHook memoryInterceptor = new ModelHook() {
    @Override
    public String getName() {
        return "memory_interceptor";
    }


    @Override
    public HookPosition[] getHookPositions() {
        return new HookPosition[]{HookPosition.BEFORE_MODEL, HookPosition.AFTER_MODEL};
    }

    @Override
    public CompletableFuture<Map<String, Object>> beforeModel(OverAllState state, RunnableConfig config) {
        // 从配置中获取用户ID
        String userId = (String) config.metadata("user_id").orElse(null);
        if (userId == null) {
            return CompletableFuture.completedFuture(Map.of());
        }

        Store store = config.store();
        // 从记忆存储中加载用户画像
        Optional<StoreItem> itemOpt = store.getItem(List.of("user_profiles"), userId);
        if (itemOpt.isPresent()) {
            Map<String, Object> profile = itemOpt.get().getValue();

            // 将用户上下文注入系统消息
            String userContext = String.format(
                    "用户信息：姓名=%s, 年龄=%s, 邮箱=%s, 偏好=%s",
                    profile.get("name"),
                    profile.get("age"),
                    profile.get("email"),
                    profile.get("preferences")
            );

            // 获取消息列表
            List<Message> messages = (List<Message>) state.value("messages").orElse(new ArrayList<>());
            List<Message> newMessages = new ArrayList<>();

            // 查找是否已存在 SystemMessage
            SystemMessage existingSystemMessage = null;
            int systemMessageIndex = -1;
            for (int i = 0; i < messages.size(); i++) {
                Message msg = messages.get(i);
                if (msg instanceof SystemMessage) {
                    existingSystemMessage = (SystemMessage) msg;
                    systemMessageIndex = i;
                    break;
                }
            }

            // 如果找到 SystemMessage，更新它；否则创建新的
            SystemMessage enhancedSystemMessage;
            if (existingSystemMessage != null) {
                // 更新现有的 SystemMessage
                enhancedSystemMessage = new SystemMessage(
                        existingSystemMessage.getText() + " " + userContext
                );
            } else {
                // 创建新的 SystemMessage
                enhancedSystemMessage = new SystemMessage(userContext);
            }

            // 构建新的消息列表
            if (systemMessageIndex >= 0) {
                // 如果找到了 SystemMessage，替换它
                for (int i = 0; i < messages.size(); i++) {
                    if (i == systemMessageIndex) {
                        newMessages.add(enhancedSystemMessage);
                    } else {
                        newMessages.add(messages.get(i));
                    }
                }
            } else {
                // 如果没有找到 SystemMessage，在开头添加新的
                newMessages.add(enhancedSystemMessage);
                newMessages.addAll(messages);
            }

            return CompletableFuture.completedFuture(Map.of("messages", newMessages));
        }

        return CompletableFuture.completedFuture(Map.of());
    }

    @Override
    public CompletableFuture<Map<String, Object>> afterModel(OverAllState state, RunnableConfig config) {
        // 可以在这里实现对话后的记忆保存逻辑
        return CompletableFuture.completedFuture(Map.of());
    }
};

input : 请介绍一下我的信息，namespace=['user_profiles'], key='key_user_001'

messages : [UserMessage {
  content = '请介绍一下我的信息，namespace=['user_profiles '], key='key_user_001 '', metadata = { messageType = USER }, messageType = USER}, DeepSeekAssistantMessage[messageType = ASSISTANT, toolCalls = [ToolCall[id = 09852 ad0589e4b2d8f69c2fc6c923767, type = function, name = getUserInfo, arguments = {
  "key": "key_user_001",
  "namespace": ["user_profiles"]
}]], textContent = , reasoningContent = null, prefix = null, metadata = {
  finishReason = TOOL_CALLS,
  index = 0,
  role = ASSISTANT,
  id = 3422652169 d74d3aaf33a10d3e51a7c0,
  messageType = ASSISTANT
}], ToolResponseMessage {
  responses = [ToolResponse[id = 09852 ad0589e4b2d8f69c2fc6c923767, name = getUserInfo, responseData = {
    "message": "找到用户信息",
    "value": {
      "preferences": ["喜欢咖啡", "喜欢阅读"],
      "name": "王小明",
      "rules": ["用户喜欢简短直接的语言", "用户只说中文和Java"],
      "language": "中文",
      "age": 28,
      "email": "wang@example.com"
    }
  }]], messageType = TOOL, metadata = {
    messageType = TOOL
  }
}, DeepSeekAssistantMessage[messageType = ASSISTANT, toolCalls = [], textContent = 根据查询到的信息， 您的用户信息如下： ** 基本信息： ** -姓名： 王小明 - 年龄： 28 岁 - 邮箱： wang @example.com - 语言： 中文 ** 个人偏好： ** -喜欢咖啡 - 喜欢阅读 ** 沟通规则： ** -用户喜欢简短直接的语言 - 用户只能说中文和Java 如果您需要了解更多信息或有其他问题， 请随时告诉我！, reasoningContent = null, prefix = null, metadata = {
  finishReason = STOP,
  index = 0,
  role = ASSISTANT,
  id = edaf6c140ae62d3c51fc7034cfc2e254,
  messageType = ASSISTANT
}]]


Agent的记忆模块

Agent的复杂性涉及推理复杂性、工具复杂性、交互复杂性，解决这些复杂性以及让Agent越来越聪明，依赖上下文沉淀的记忆模块。

人工智能

后端

数据库

Agent智能体通过上下文记忆模块实现精准用户交互，整合多源信息推理、精确调用工具、动态追踪用户意图。基于Spring AI和Alibaba Cloud AI技术栈，提供代码示例展示如何存储用户画像、偏好数据，实现智能记忆存储与检索功能，让Agent更懂用户需求，提升交互体验。

tencentdb-catalog

dmask

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

Agent的记忆模块

Agent的记忆模块

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐