【从0到1构建一个ClaudeAgent】内存管理-上下文压缩

对话一长，Token 烧得肉疼。那怎么办，做压缩
Java实当代码

1. public class ContextCompactSystem {
2.     // --- 配置 ---
3.     private static final Path WORKDIR = Paths.get(System.getProperty("user.dir"));
4.     private static final Path TRANSCRIPT_DIR = WORKDIR.resolve(".transcripts");  // 新增：对话存档目录
5.     private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
6.    
7.     // 压缩参数
8.     private static final int THRESHOLD_TOKENS = 50000;  // 触发自动压缩的 token 阈值
9.     private static final int KEEP_RECENT = 3;           // 保留的最近工具结果数量
10.    
11.     // --- 工具枚举 ---
12.     public enum ToolType {
13.         BASH("bash", "Run a shell command."),
14.         READ_FILE("read_file", "Read file contents."),
15.         WRITE_FILE("write_file", "Write content to file."),
16.         EDIT_FILE("edit_file", "Replace exact text in file."),
17.         COMPACT("compact", "Trigger manual conversation compression.");  // 新增：手动压缩工具
19.         public final String name;
20.         public final String description;
21.         ToolType(String name, String description) { this.name = name; this.description = description; }
22.     }
24.     // ... 省略相同的 ToolExecutor 接口和基础工具实现
25.    
26.     // --- 三层次压缩系统 ---
27.    
28.     /**
29.      * Layer 1: 微观压缩 - 静默替换旧的工具结果
30.      */
31.     private static List<Map<String, Object>> microCompact(List<Map<String, Object>> messages) {
32.         // 收集所有的 tool_result 条目
33.         List<ToolResultInfo> toolResults = new ArrayList<>();
34.         
35.         for (int msgIdx = 0; msgIdx < messages.size(); msgIdx++) {
36.             Map<String, Object> msg = messages.get(msgIdx);
37.             if ("user".equals(msg.get("role"))) {
38.                 Object content = msg.get("content");
39.                 if (content instanceof List) {
40.                     @SuppressWarnings("unchecked")
41.                     List<Map<String, Object>> contentList = (List<Map<String, Object>>) content;
42.                     
43.                     for (int partIdx = 0; partIdx < contentList.size(); partIdx++) {
44.                         Map<String, Object> part = contentList.get(partIdx);
45.                         if ("tool_result".equals(part.get("type"))) {
46.                             toolResults.add(new ToolResultInfo(msgIdx, partIdx, part));
47.                         }
48.                     }
49.                 }
50.             }
51.         }
52.         
53.         if (toolResults.size() <= KEEP_RECENT) {
54.             return messages;
55.         }
56.         
57.         // 从先前的 assistant 消息中映射 tool_use_id 到 tool_name
58.         Map<String, String> toolNameMap = new HashMap<>();
59.         for (Map<String, Object> msg : messages) {
60.             if ("assistant".equals(msg.get("role"))) {
61.                 Object content = msg.get("content");
62.                 if (content instanceof List) {
63.                     @SuppressWarnings("unchecked")
64.                     List<Map<String, Object>> contentList = (List<Map<String, Object>>) content;
65.                     
66.                     for (Map<String, Object> block : contentList) {
67.                         if ("tool_use".equals(block.get("type"))) {
68.                             String toolId = (String) block.get("id");
69.                             String toolName = (String) block.get("name");
70.                             toolNameMap.put(toolId, toolName);
71.                         }
72.                     }
73.                 }
74.             }
75.         }
76.         
77.         // 清除旧的结果（保留最近的 KEEP_RECENT 个）
78.         List<ToolResultInfo> toClear = toolResults.subList(0, toolResults.size() - KEEP_RECENT);
79.         
80.         for (ToolResultInfo info : toClear) {
81.             Map<String, Object> result = info.result;
82.             Object content = result.get("content");
83.             
84.             if (content instanceof String && ((String) content).length() > 100) {
85.                 String toolId = (String) result.get("tool_use_id");
86.                 String toolName = toolNameMap.getOrDefault(toolId, "unknown");
87.                 result.put("content", "[Previous: used " + toolName + "]");  // 静默替换
88.             }
89.         }
90.         
91.         return messages;
92.     }
93.    
94.     /**
95.      * Layer 2: 自动压缩 - 保存完整对话并生成摘要
96.      */
97.     private static List<Map<String, Object>> autoCompact(List<Map<String, Object>> messages) throws IOException {
98.         // 保存完整对话到磁盘
99.         Files.createDirectories(TRANSCRIPT_DIR);
100.         Path transcriptPath = TRANSCRIPT_DIR.resolve("transcript_" + System.currentTimeMillis() + ".jsonl");
101.         
102.         try (BufferedWriter writer = Files.newBufferedWriter(transcriptPath)) {
103.             for (Map<String, Object> msg : messages) {
104.                 writer.write(gson.toJson(msg));
105.                 writer.newLine();
106.             }
107.         }
108.         
109.         System.out.println("[transcript saved: " + transcriptPath + "]");
110.         
111.         // 调用 LLM 生成摘要
112.         String conversationText = gson.toJson(messages);
113.         if (conversationText.length() > 80000) {
114.             conversationText = conversationText.substring(0, 80000);
115.         }
116.         
117.         String summary = simulateLLMSummary(conversationText);
118.         
119.         // 用摘要替换整个对话历史
120.         List<Map<String, Object>> compressedMessages = new ArrayList<>();
121.         
122.         compressedMessages.add(Map.of(
123.             "role", "user",
124.             "content", "[Conversation compressed. Transcript: " + transcriptPath + "]\n\n" + summary
125.         ));
126.         
127.         compressedMessages.add(Map.of(
128.             "role", "assistant",
129.             "content", "Understood. I have the context from the summary. Continuing."
130.         ));
131.         
132.         return compressedMessages;
133.     }
134.    
135.     /**
136.      * Layer 3: 手动压缩工具
137.      * 当 Agent 主动调用 compact 工具时触发
138.      */
139.     private static String handleCompactTool(Map<String, Object> args) {
140.         String focus = (String) args.get("focus");
141.         String focusMsg = focus != null ? " Focus: " + focus : "";
142.         return "Manual compression requested." + focusMsg;
143.     }
144.    
145.     /**
146.      * 估算 token 数量
147.      * 简单实现：约 4 个字符对应 1 个 token
148.      */
149.     private static int estimateTokens(List<Map<String, Object>> messages) {
150.         String messagesStr = gson.toJson(messages);
151.         return messagesStr.length() / 4;
152.     }
153.    
154.     // --- 工具处理器映射 ---
155.     private static final Map<String, ToolExecutor> TOOL_HANDLERS = new HashMap<>();
156.    
157.     static {
158.         // ... 省略基础工具注册
159.         
160.         TOOL_HANDLERS.put(ToolType.COMPACT.name, ContextCompactSystem::handleCompactTool);
161.     }
162.    
163.     // --- Agent 主循环（集成了三层压缩）---
164.     public static void agentLoop(List<Map<String, Object>> messages) {
165.         while (true) {
166.             try {
167.                 // Layer 1: 每次调用前进行微观压缩
168.                 messages = microCompact(messages);
169.                
170.                 // Layer 2: 如果 token 数超过阈值，自动压缩
171.                 if (estimateTokens(messages) > THRESHOLD_TOKENS) {
172.                     System.out.println("[auto_compact triggered]");
173.                     messages = autoCompact(messages);
174.                 }
175.                
176.                 // ... 省略相同的 LLM 调用逻辑
177.                
178.                 boolean manualCompact = false;
179.                 for (Map<String, Object> block : content) {
180.                     if ("tool_use".equals(block.get("type"))) {
181.                         String toolName = (String) block.get("name");
182.                         
183.                         // 检查是否是 compact 工具
184.                         if (ToolType.COMPACT.name.equals(toolName)) {
185.                             manualCompact = true;  // 标记手动压缩
186.                         }
187.                         
188.                         // ... 执行工具
189.                     }
190.                 }
191.                
192.                 // Layer 3: 如果调用了 compact 工具，执行手动压缩
193.                 if (manualCompact) {
194.                     System.out.println("[manual compact]");
195.                     messages = autoCompact(messages);
196.                 }
197.                
198.             } catch (Exception e) {
199.                 System.err.println("Error in agent loop: " + e.getMessage());
200.                 e.printStackTrace();
201.                 return;
202.             }
203.         }
204.     }
205.    
206.     // --- 辅助类和方法 ---
207.     private static class ToolResultInfo {
208.         int msgIndex;
209.         int partIndex;
210.         Map<String, Object> result;
211.         
212.         ToolResultInfo(int msgIndex, int partIndex, Map<String, Object> result) {
213.             this.msgIndex = msgIndex;
214.             this.partIndex = partIndex;
215.             this.result = result;
216.         }
217.     }
218. }

复制代码

三条理压缩体系架构

办理恒久对话中的上下文长度限定题目，通过三层渐进式压缩计谋，在不丢失关键信息的条件下大幅度缩减上下文长度，实现无穷长对话的本领。

1. // 压缩流程
2. while (true) {
3.     // Layer 1: 每次调用前进行微观压缩
4.     messages = microCompact(messages);
5.    
6.     // Layer 2: 如果 token 数超过阈值，自动压缩
7.     if (estimateTokens(messages) > THRESHOLD_TOKENS) {
8.         messages = autoCompact(messages);
9.     }
10.    
11.     // Layer 3: 如果调用了 compact 工具，执行手动压缩
12.     if (manualCompact) {
13.         messages = autoCompact(messages);
14.     }
15. }

复制代码

• 分层压缩：微观、主动、手动三层计谋，粒度从细到粗
  
• 智能触发：基于token估算主动判定压缩机遇
  
• 渐进生存：生存迩来的关键信息，确保一连性
  
• 可规复性：压缩前生存完备对话，克制信息丢失
  

微观压缩：无感地举行轻量级压缩

1. private static List<Map<String, Object>> microCompact(List<Map<String, Object>> messages) {
2.     // 收集所有的 tool_result
3.     List<ToolResultInfo> toolResults = new ArrayList<>();
4.    
5.     // 保留最近的 KEEP_RECENT 个完整结果
6.     if (toolResults.size() <= KEEP_RECENT) {
7.         return messages;
8.     }
9.    
10.     // 将旧的结果替换为占位符
11.     for (ToolResultInfo info : toClear) {
12.         result.put("content", "[Previous: used " + toolName + "]");
13.     }
14. }

复制代码

• 存档优先：压缩前先完备生存，克制信息丢失
  
• 智能择要：用LLM天生高质量的对话择要
  
• 上下文重置：大幅缩减上下文，但生存焦点信息
  
• 路径嵌入：在消息中包罗存档路径，便于调试
  
• 结构完备：保持user-assistant对话结构
  

手动压缩：给予 Agent 主动控制权

1. /**
2. * Layer 2: 自动压缩 - 保存完整对话并生成摘要
3. */
4. private static List<Map<String, Object>> autoCompact(List<Map<String, Object>> messages) throws IOException {
5.     // 1. 保存完整对话到磁盘
6.     Files.createDirectories(TRANSCRIPT_DIR);
7.     Path transcriptPath = TRANSCRIPT_DIR.resolve("transcript_" + System.currentTimeMillis() + ".jsonl");
8.    
9.     try (BufferedWriter writer = Files.newBufferedWriter(transcriptPath)) {
10.         for (Map<String, Object> msg : messages) {
11.             writer.write(gson.toJson(msg));
12.             writer.newLine();
13.         }
14.     }
15.     // 存档保护：完整对话保存到文件，随时可查
16.     // JSONL格式：每行一个消息，便于处理和加载
17.    
18.     // 2. 调用 LLM 生成摘要
19.     String conversationText = gson.toJson(messages);
20.     if (conversationText.length() > 80000) {
21.         conversationText = conversationText.substring(0, 80000);
22.     }
23.     String summary = simulateLLMSummary(conversationText);
24.    
25.     // 3. 用摘要替换整个对话历史
26.     List<Map<String, Object>> compressedMessages = new ArrayList<>();
27.    
28.     compressedMessages.add(Map.of(
29.         "role", "user",
30.         "content", "[Conversation compressed. Transcript: " + transcriptPath + "]\n\n" + summary
31.     ));
32.     // 上下文重置：用单条消息包含存档位置和摘要
33.     // 完整可追溯：存档路径包含在上下文中
34.    
35.     compressedMessages.add(Map.of(
36.         "role", "assistant",
37.         "content", "Understood. I have the context from the summary. Continuing."
38.     ));
39.     // 连续性保持：添加assistant确认，维持对话结构
40.    
41.     return compressedMessages;
42. }

复制代码

1. /**
2. * Layer 3: 手动压缩工具
3. * 当 Agent 主动调用 compact 工具时触发
4. */
5. private static String handleCompactTool(Map<String, Object> args) {
6.     String focus = (String) args.get("focus");
7.     String focusMsg = focus != null ? " Focus: " + focus : "";
8.     return "Manual compression requested." + focusMsg;
9.     // Agent控制：Agent可以根据需要主动压缩
10.     // 参数化：可以指定摘要焦点，指导LLM关注特定方面
11. }

复制代码

• Agent自主控制：Agent可以主动管理上下文长度
  
• 使命驱动压缩：在符合的时间点（如使命切换时）触发压缩
  
• 聚焦择要：可以指定择要重点，优化信息生存
  
• 无缝集成：与主动压缩共享底层机制
  

架构演进与代价

从 TaskSystem 到 ContextCompactSystem 的升级：
维度TaskSystemContextCompactSystem对话长度受上下文限定支持无穷长对话信息生存全量存储智能择要+存档控制方式被动限定主动+主动压缩恒久影象使命文件对话存档+择要上下文优化无三层智能压缩
免责声明：如果侵犯了您的权益，请联系站长及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金.