Agent 记忆压缩通常有哪些方法？

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.memory.chat.TokenWindowChatMemory;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.chat.request.Response;

import java.util.List;

public class AgentMemoryCompressionDemo {

    public static void main(String[] args) {

        ChatModel llm = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o")
                .build();

        // 方案 1：基于消息条数的滑动窗口（简单粗暴）
        ChatMemory messageWindow = MessageWindowChatMemory.builder()
                .maxMessages(20)              // 只保留最近 20 条消息
                .build();

        // 方案 2：基于 Token 的滑动窗口（更精准）
        ChatMemory tokenWindow = TokenWindowChatMemory.builder()
                .maxTokens(8000, new OpenAiTokenCountEstimator("gpt-4o"))
                .build();

        // 模拟一段长对话
        for (int i = 0; i < 30; i++) {
            tokenWindow.add(dev.langchain4j.data.message.UserMessage.from(
                    "第 " + i + " 轮：帮我查一下订单 " + (1000 + i) + " 的状态"));
            // ... 调用 LLM、工具等
        }

        // 关键：当窗口快满时，触发摘要压缩
        List<ChatMessage> current = tokenWindow.messages();
        if (estimateTokens(current) > 6000) {
            // 1) 取出将被截断的旧消息
            int summaryBoundary = current.size() / 2;
            List<ChatMessage> toSummarize = current.subList(0, summaryBoundary);

            // 2) 用 LLM 把它们总结成结构化摘要
            String summaryPrompt = """
                    请把以下对话历史压缩成结构化摘要，必须包含以下章节：
                    1. 会话意图
                    2. 已涉及的文件 / 订单 / 关键实体
                    3. 已做出的决策
                    4. 当前进展
                    5. 下一步计划
                    没有的章节显式标注 "无"，不要省略。

                    对话历史：
                    %s
                    """.formatted(renderMessages(toSummarize));

            AiMessage summary = llm.chat(summaryPrompt).aiMessage();

            // 3) 重置窗口：先放摘要，再保留近期消息
            tokenWindow = TokenWindowChatMemory.builder()
                    .maxTokens(8000, new OpenAiTokenCountEstimator("gpt-4o"))
                    .build();
            tokenWindow.add(dev.langchain4j.data.message.SystemMessage.from(
                    "历史会话摘要：\n" + summary.text()));
            // 重新加入近期消息
            current.subList(summaryBoundary, current.size())
                  .forEach(tokenWindow::add);
        }
    }

    /** 粗略估算 Token 数（生产环境建议用官方 tokenizer） */
    private static int estimateTokens(List<ChatMessage> msgs) {
        return msgs.stream()
                .mapToInt(m -> m.text().length() / 4)
                .sum();
    }

    private static String renderMessages(List<ChatMessage> msgs) {
        StringBuilder sb = new StringBuilder();
        msgs.forEach(m -> sb.append("- ").append(m.text()).append("\n"));
        return sb.toString();
    }
}

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.*;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.chat.messages.MessageType;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.chat.model.Response;

import org.springframework.stereotype.Service;

@Service
public class AgentWithCompression {

    private final ChatClient client;
    private final ChatModel chatModel;

    public AgentWithCompression(ChatModel chatModel) {
        this.chatModel = chatModel;

        // Spring AI 内置的滑动窗口记忆
        ChatMemory memory = MessageWindowChatMemory.builder()
                .maxMessages(20)
                .build();

        this.client = ChatClient.builder(chatModel)
                .defaultAdvisors(
                        // 对话记忆 Advisor：自动维护上下文
                        new MessageChatMemoryAdvisor(memory),
                        // 自定义摘要 Advisor：超过阈值触发压缩
                        new SummarizationAdvisor(chatModel, 6000)
                )
                .build();
    }

    public String chat(String sessionId, String userMsg) {
        return client.prompt()
                .user(userMsg)
                .advisors(a -> a.param(ChatMemory.CONVERSATION_ID, sessionId))
                .call()
                .content();
    }
}

import org.springframework.ai.chat.client.advisor.*;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.messages.*;
import org.springframework.ai.chat.client.RequestResponseSpec;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.model.ChatResponse;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 自定义摘要 Advisor：当上下文 Token 超过阈值时触发摘要压缩。
 * 采用 "结构化摘要 + 增量合并" 思路，模拟 Factory.ai 的锚定迭代方案。
 */
public class SummarizationAdvisor implements BaseAdvisor {

    private final ChatModel chatModel;
    private final int tokenThreshold;
    // 持久化的锚定摘要（跨多轮压缩保留）
    private String anchoredSummary = "";

    private static final String SUMMARY_TEMPLATE = """
            你是 Agent 的记忆压缩器。请把下面这段历史对话合并到现有摘要中，
            输出更新后的结构化摘要，必须包含以下章节（缺失章节标注 "无"）：

            ## 会话意图
            ## 涉及的关键实体（文件 / 订单 / 接口等）
            ## 已做出的决策
            ## 当前进展
            ## 下一步

            现有摘要：
            {existing}

            新增对话：
            {new}
            """;

    public SummarizationAdvisor(ChatModel chatModel, int tokenThreshold) {
        this.chatModel = chatModel;
        this.tokenThreshold = tokenThreshold;
    }

    @Override
    public AdvisedRequest before(AdvisedRequest request) {
        List<Message> messages = request.messages();
        int estTokens = messages.stream()
                .mapToInt(m -> m.getText().length() / 4)
                .sum();

        if (estTokens <= tokenThreshold) {
            return request;
        }

        // 1) 拆分：旧消息待摘要，近 6 条消息原样保留
        int keepRecent = 6;
        int splitIdx = messages.size() - keepRecent;
        List<Message> toSummarize = messages.subList(0, splitIdx);
        List<Message> toKeep = messages.subList(splitIdx, messages.size());

        // 2) 调用 LLM 做增量摘要（锚定到旧摘要）
        PromptTemplate pt = new PromptTemplate(SUMMARY_TEMPLATE);
        String newContent = toSummarize.stream()
                .map(m -> "[" + m.getMessageType() + "] " + m.getText())
                .collect(Collectors.joining("\n"));

        String updated = chatModel.call(pt.createMessage(Map.of(
                "existing", anchoredSummary.isEmpty() ? "(空)" : anchoredSummary,
                "new", newContent
        )));

        this.anchoredSummary = updated; // 更新锚

        // 3) 重组上下文：系统摘要 + 近期消息
        List<Message> compressed = new ArrayList<>();
        compressed.add(new SystemMessage("历史会话摘要：\n" + anchoredSummary));
        compressed.addAll(toKeep);

        return AdvisedRequest.from(request).withMessages(compressed).build();
    }
}