代码解析：逻辑非常直接——fullHistory列表保存所有消息，buildContext()把它们全部拼接成字符串。没有任何优化。

优点：

• 信息零损失，完美保留每句话

  
  

• 实现极简单，5分钟写完

  
  

缺点：

• token消耗随轮数线性增长，100轮可能几万token

  
  

• 达到模型上下文上限后（比如8K/128K），旧消息会被截断

  
  

• 响应时间越来越慢，账单越来越高

  
  

适用场景：只适合Demo演示、调试测试，或者保证对话不超过10轮的极短场景。

生产环境慎用。

三、方案二：滑动窗口

省token，但记性差。

滑动窗口只保留最近N轮对话，超出窗口的直接丢弃。

public class SummaryMemory {
    private String summary = "";                    // 历史摘要
    private List<Message> recentMessages = new ArrayList<>();  // 未压缩的新消息
    private final int compressThreshold;             // 触发压缩的token阈值
    private final LLMClient llm;                     // 大模型客户端
    
    public SummaryMemory(LLMClient llm, int compressThreshold) {
        this.llm = llm;
        this.compressThreshold = compressThreshold;
    }
    
    public void addTurn(String userMsg, String assistantMsg) {
        recentMessages.add(new Message("user", userMsg));
        recentMessages.add(new Message("assistant", assistantMsg));
        
        // 估算当前token数，超过阈值则触发压缩
        if (estimateTokenCount() > compressThreshold) {
            compress();
        }
    }
    
    private void compress() {
        // 构建待压缩的内容：旧摘要 + 新消息
        String toCompress = summary + "\n" + formatMessages(recentMessages);
        String prompt = """
            请将以下对话历史压缩成一段简洁的摘要，保留：
            1. 用户的关键信息（姓名、偏好、身份、已做出的决定）
            2. 重要的任务状态和上下文
            3. 任何后续对话可能需要的事实
            原始对话：
            %s
            摘要：
            """.formatted(toCompress);
        
        // 调用大模型生成摘要
        String newSummary = llm.chat(prompt);
        this.summary = newSummary;
        // 压缩后清空近期消息，但可以保留最后一轮作为锚点（防止断层）
        this.recentMessages.clear();
    }
    
    public String buildContext() {
        // 上下文 = 摘要 + 最近未压缩的消息
        if (summary.isEmpty()) {
            return formatMessages(recentMessages);
        }
        return "【历史摘要】\n" + summary + "\n\n【最近对话】\n" + formatMessages(recentMessages);
    }
    
    private int estimateTokenCount() {
        // 简单估算：中文1字≈2token，英文1词≈1.3token，这里粗略用字符数/2
        int totalChars = summary.length() + formatMessages(recentMessages).length();
        return totalChars / 2;
    }
    
    private String formatMessages(List<Message> msgs) {
        return msgs.stream()
            .map(m -> m.getRole() + ": " + m.getContent())
            .collect(Collectors.joining("\n"));
    }
}

public class VectorMemory {
    private final EmbeddingClient embeddingClient;  // 向量化模型，如OpenAI embedding
    private final VectorDatabase vectorDb;           // 向量数据库，如Milvus、Chroma
    private final int topK = 5;                      // 每次检索几条最相关的历史
    
    public VectorMemory(EmbeddingClient embeddingClient, VectorDatabase vectorDb) {
        this.embeddingClient = embeddingClient;
        this.vectorDb = vectorDb;
    }
    
    // 存储一条历史消息（每个消息单独存储，带上元数据）
    public void saveMessage(String role, String content, Map<String, Object> metadata) {
        // 1. 调用embedding接口，将文本转为向量
        float[] vector = embeddingClient.embed(content);
        // 2. 存入向量数据库
        VectorRecord record = new VectorRecord(vector, content, metadata);
        vectorDb.insert(record);
    }
    
    // 检索与当前问题最相关的历史记忆
    public List<Message> retrieveRelevantHistory(String currentQuestion) {
        // 将当前问题向量化
        float[] queryVector = embeddingClient.embed(currentQuestion);
        // 在数据库中做相似度搜索，返回topK条最相似的历史消息
        List<VectorRecord> results = vectorDb.search(queryVector, topK);
        // 转换成Message对象
        return results.stream()
            .map(r -> new Message((String)r.getMetadata().get("role"), r.getContent()))
            .collect(Collectors.toList());
    }
    
    // 构建上下文：检索结果 + 最近几轮（可选）
    public String buildContext(String userQuestion) {
        List<Message> relevantHistory = retrieveRelevantHistory(userQuestion);
        StringBuilder context = new StringBuilder("相关历史记忆：\n");
        for (Message msg : relevantHistory) {
            context.append(msg.getRole()).append(": ").append(msg.getContent()).append("\n");
        }
        return context.toString();
    }
}

public class StateVariableMemory {
    private Map<String, Object> state = new HashMap<>();  // 核心状态
    
    // 通过LLM从对话中提取结构化状态
    public void updateState(String userMsg, String assistantMsg, LLMClient llm) {
        String extractPrompt = """
            从以下对话中提取关键状态变量，以JSON格式输出。
            当前已有状态：%s
            用户最新消息：%s
            AI回复：%s
            请更新状态，只输出JSON，不要其他内容。
            """.formatted(toJson(state), userMsg, assistantMsg);
        
        String jsonResponse = llm.chat(extractPrompt);
        Map<String, Object> newState = parseJson(jsonResponse);
        state.putAll(newState);  // 合并更新
    }
    
    public String buildContext() {
        // 上下文只需要展示当前状态，而不是历史对话
        return "当前会话状态：" + toJson(state);
    }
}

public class ToolBasedMemory {
    // 定义两个工具函数
    @Tool(name = "save_memory", description = "保存一条重要信息到长期记忆")
    public void saveMemory(String key, String value) {
        externalDB.put(key, value);
    }
    
    @Tool(name = "recall_memory", description = "根据关键词回忆之前保存的信息")
    public String recallMemory(String key) {
        return externalDB.get(key);
    }
    
    // 在对话循环中，让模型自主决定何时调用这些工具
}