AgentScope 2.0：9. Context —— 运行时上下文与状态管理深度解析
·
目录：
1. 面向生产环境的智能体工程平台
2. 快速上手 从零构建生产级智能体
3. Agent —— 智能体的核心抽象与工程化实践
4. Message & Event —— 消息模型与事件流深度解
5. Middleware —— 无侵入式智能体扩展机制深度解析
6. Model —— 统一模型接入层与容错机制深度解析
7. Permission System —— 权限控制系统深度解析
8. Tool —— 工具系统架构与生产级实践深度解析
9. Context —— 运行时上下文与状态管理深度解析
一、引言：智能体的"记忆"从何而来？
LLM 本身是无状态的。它不记得上一轮对话说了什么，不知道当前用户是谁，不清楚自己已经执行了多少步。
在 AgentScope Java 2.0 的构建块体系中，Context（上下文） 是赋予智能体"记忆"和"身份"的核心基础设施。官方文档将其定位为 io.agentscope.core.context 包下的完整上下文框架，提供：
RuntimeContext（请求级隔离） × AgentState（会话级持久化） × Memory / MessageStore（消息存储） × Compaction（上下文压缩） × EventStream（事件流）
一个生产级 Agent 框架必须回答三个问题：
- 谁在调用？ → RuntimeContext
- 之前发生了什么？ → AgentState + Memory
- 上下文太长怎么办？ → Compaction
本文系统解析 AgentScope Java 2.0 上下文系统的完整架构、核心组件与生产实践。
二、上下文系统架构总览
2.1 分层架构
┌─────────────────────────────────────────────────────────────────┐
│ Agent 层 │
│ ReActAgent / HarnessAgent │
│ 在 ReAct 循环中读写上下文 │
└──────────────────────────────┬──────────────────────────────────┘
│
┌────────────────┼────────────────┐
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ RuntimeContext │ │ AgentState │ │ EventStream │
│ (请求级/只读) │ │ (会话级/可写) │ │ (实时事件流) │
│ userId/sessionId │ │ messages/memory │ │ 流式输出 │
│ orgId/metadata │ │ toolResults │ │ 中间件事件 │
└──────────────────┘ └────────┬─────────┘ └──────────────────┘
│
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Memory │ │ MessageStore │ │ Compaction │
│ (语义检索/RAG) │ │ (消息持久化) │ │ (上下文压缩) │
│ MEMORY.md │ │ SQLite/Redis │ │ 自动摘要 │
└──────────────────┘ └──────────────────┘ └──────────────────┘
2.2 核心组件关系
| 组件 | 职责 | 生命周期 | 包路径 |
|---|---|---|---|
| RuntimeContext | 请求级上下文，携带用户/会话信息 | 单次请求 | io.agentscope.core.context |
| AgentState | 会话级状态，承载消息历史与工具结果 | 跨请求持久化 | io.agentscope.core.state |
| Memory | 长期记忆，支持语义检索 | 永久 | io.agentscope.core.memory |
| MessageStore | 消息持久化后端 | 永久 | io.agentscope.core.store |
| Compaction | 上下文压缩，防止 Token 溢出 | 自动触发 | io.agentscope.harness.compaction |
| EventStream | 实时事件流，驱动流式输出 | 单次请求 | io.agentscope.core.event |
三、RuntimeContext：请求级上下文
3.1 设计定位
RuntimeContext 是每次 Agent 调用的请求级上下文，承载本次调用的身份信息与环境参数：
public class RuntimeContext {
private final String sessionId; // 会话标识（必填）
private final String userId; // 用户标识
private final String orgId; // 组织标识（多租户）
private final Map<String, Object> metadata; // 扩展元数据
}
3.2 核心特性
| 特性 | 说明 |
|---|---|
| 不可变 | 构建后不可修改，线程安全 |
| 请求级 | 每次 agent.call() / streamEvents() 传入新实例 |
| 透传性 | 自动传递到 Middleware、Tool、PermissionEngine |
| 可扩展 | metadata 支持任意键值对扩展 |
3.3 构建与使用
// 构建 RuntimeContext
RuntimeContext ctx = RuntimeContext.builder()
.sessionId("session-2024-0808-001")
.userId("user-alice")
.orgId("org-acme")
.metadata("client_version", "2.1.0")
.metadata("source", "web")
.build();
// 传入 Agent 调用
Mono<ChatResponse> response = agent.call(userMessage, ctx);
// 或流式调用
Flux<AgentEvent> events = agent.streamEvents(userMessage, ctx);
3.4 在各层的透传
agent.call(msg, ctx)
│
├──→ Middleware.onAgent(ctx, ...) // 追踪/审计
├──→ Middleware.onReasoning(ctx, ...) // Token 计费
├──→ Tool.execute(input, ToolContext) // 工具获取 userId
├──→ PermissionEngine.evaluate(...) // 权限按用户判断
└──→ Model.generate(msgs, options) // 模型调用
### 3.5 多租户隔离
```java
// 不同租户的请求天然隔离
RuntimeContext tenantA = RuntimeContext.builder()
.sessionId("s-001").userId("alice").orgId("acme").build();
RuntimeContext tenantB = RuntimeContext.builder()
.sessionId("s-002").userId("bob").orgId("globex").build();
// Agent 内部通过 ctx.getOrgId() 加载不同的：
// - 权限规则
// - 工具过滤配置
// - 技能集
// - Workspace 路径
四、AgentState：会话级状态管理
4.1 设计定位
AgentState 是跨请求的会话级状态容器，承载 Agent 的完整对话历史与执行状态：
public class AgentState {
private final String sessionId; // 关联的会话 ID
private final List<Msg> messages; // 完整消息历史
private final List<ToolResultBlock> toolResults; // 工具执行结果
private final Map<String, Object> variables; // 自定义变量
private final Instant lastUpdated; // 最后更新时间
}
4.2 与 RuntimeContext 的区别
| 维度 | RuntimeContext | AgentState |
|---|---|---|
| 生命周期 | 单次请求 | 跨请求持久化 |
| 可变性 | 不可变 | 可变（追加消息） |
| 内容 | 身份/环境信息 | 对话历史/执行状态 |
| 存储 | 内存 | MessageStore（SQLite/Redis） |
| 作用域 | 透传给各层 | Agent 内部读写 |
4.3 状态加载与保存
// Agent 启动时自动从 MessageStore 加载状态
HarnessAgent agent = HarnessAgent.builder()
.name("assistant")
.model("dashscope:qwen-plus")
.messageStore(new SqliteMessageStore("/data/agent-state.db"))
.build();
// 首次调用：创建新状态
// 后续调用：自动加载已有消息历史
agent.call(new UserMessage("继续上次的讨论"), ctx);
4.4 状态结构详解
AgentState
├── messages[] # 完整消息序列
│ ├── SystemMessage # 系统提示词
│ ├── UserMessage # 用户输入
│ ├── AssistantMessage # 模型回复
│ │ ├── TextBlock # 文本内容
│ │ └── ToolUseBlock[] # 工具调用请求
│ └── ToolMessage # 工具执行结果
│ └── ToolResultBlock[] # 每个工具的返回
├── toolResults[] # 扁平化的工具结果列表
├── variables{} # 自定义状态变量
│ ├── current_plan # 当前计划
│ ├── iteration_count # 迭代计数
│ └── last_error # 最近错误
└── metadata{} # 元数据
├── created_at
├── updated_at
└── compaction_count
五、Memory：长期记忆系统
5.1 设计动机
AgentState 中的消息历史是短期记忆——受限于 LLM 上下文窗口，不可能无限增长。Memory 提供长期记忆能力：
将重要信息持久化到文件系统或向量数据库，需要时通过语义检索召回。
5.2 MEMORY.md 文件记忆
AgentScope 2.0 采用文件即记忆的设计理念：
workspace/
├── MEMORY.md # 长期记忆文件
├── skills/ # 技能目录
├── tools.json # MCP 工具配置
└── plans/ # 计划文件
MEMORY.md 是一个 Markdown 文件，Agent 可以自主读写：
# 长期记忆
## 用户偏好
- 用户 Alice 喜欢简洁的回答风格
- 偏好中文回复
- 工作时间：9:00-18:00 CST
## 项目上下文
- 当前项目：电商客服系统 v2.0
- 技术栈：Java 21 + Spring Boot 3.x + AgentScope 2.0
- 数据库：PostgreSQL 16
## 重要决策记录
- 2024-08-01: 确定使用 DashScope qwen-plus 作为主模型
- 2024-08-05: 权限系统从 Hook 迁移到 PermissionEngine
5.3 记忆的读写机制
// Agent 通过内置工具读写 MEMORY.md
@Tool(name = "read_memory", description = "读取长期记忆")
public String readMemory(
@ToolParam(name = "section", description = "要读取的记忆章节", required = false)
String section) {
return memoryService.read(section);
}
@Tool(name = "write_memory", description = "写入长期记忆")
public String writeMemory(
@ToolParam(name = "content", description = "要写入的内容") String content,
@ToolParam(name = "section", description = "目标章节") String section) {
memoryService.append(section, content);
return "记忆已更新";
}
5.4 记忆注入时机
在每轮推理前，HarnessAgent 自动将 MEMORY.md 的关键内容注入系统提示词：
┌─────────────────────────────────────────────────────────┐
│ System Prompt 组装流程 │
│ │
│ 1. 基础系统提示词（sysPrompt） │
│ 2. + 当前时间/日期 │
│ 3. + MEMORY.md 摘要（Middleware.onSystemPrompt） │
│ 4. + 可用技能描述 │
│ 5. + 可用工具列表（JSON Schema） │
│ 6. = 最终 System Message │
└─────────────────────────────────────────────────────────┘
5.5 向量记忆（RAG）
对于大规模记忆场景，AgentScope 支持向量数据库后端：
Memory vectorMemory = VectorMemory.builder()
.embeddingModel("dashscope:text-embedding-v3")
.vectorStore(new MilvusVectorStore(milvusClient))
.topK(5)
.similarityThreshold(0.7)
.build();
六、MessageStore：消息持久化
6.1 设计定位
MessageStore 是 AgentState 的持久化后端，负责消息历史的存储与加载：
public interface MessageStore {
/** 加载指定会话的消息历史 */
AgentState load(String sessionId);
/** 保存消息（增量追加） */
void save(String sessionId, List<Msg> newMessages);
/** 更新状态变量 */
void updateVariables(String sessionId, Map<String, Object> variables);
/** 删除会话 */
void delete(String sessionId);
/** 列出所有会话 */
List<String> listSessions();
}
6.2 内置实现
| 实现 | 适用场景 | 特点 |
|---|---|---|
| InMemoryMessageStore | 开发/测试 | 零配置，重启丢失 |
| SqliteMessageStore | 单机生产 | 嵌入式，无需外部依赖 |
| RedisMessageStore | 分布式生产 | 高性能，支持 TTL |
| JdbcMessageStore | 企业级 | 对接现有数据库 |
6.3 SQLite 存储示例
HarnessAgent agent = HarnessAgent.builder()
.name("assistant")
.model("dashscope:qwen-plus")
.messageStore(SqliteMessageStore.builder()
.dbPath("/data/agentscope/state.db")
.maxHistorySize(1000) // 最大消息数
.ttl(Duration.ofDays(30)) // 30 天过期
.build())
.build();
6.4 消息序列化
AgentScope 2.0 的消息采用 JSON 序列化存储：
{
"role": "assistant",
"content": [
{ "type": "text", "text": "我来帮你查询订单。" },
{ "type": "tool_use", "id": "call_001", "name": "query_order",
"input": { "order_id": "ORD-001" } }
],
"timestamp": "2024-08-08T10:30:00Z"
}
七、Compaction：上下文压缩
7.1 为什么需要压缩？
LLM 的上下文窗口是有限的（如 128K tokens）。当对话历史过长时：
- Token 超限：请求被拒绝
- 成本飙升：输入 Token 费用线性增长
- 质量下降：“Lost in the Middle” 效应，模型遗忘中间内容
- 延迟增加：处理更长的 prompt 耗时更久
7.2 Compaction 策略
AgentScope 2.0 提供多种压缩策略：
CompactionConfig config = CompactionConfig.builder()
.strategy(CompactionStrategy.SUMMARIZE) // 摘要压缩
.triggerMessages(50) // 消息数阈值
.triggerTokens(100000) // Token 数阈值
.keepMessages(15) // 保留最近 N 条消息
.summaryModel("dashscope:qwen-turbo") // 用轻量模型做摘要
.build();
7.3 压缩策略对比
| 策略 | 原理 | 优点 | 缺点 |
|---|---|---|---|
| TRUNCATE | 直接丢弃最早的消息 | 零成本、最快 | 丢失早期上下文 |
| SUMMARIZE | 用 LLM 将旧消息压缩为摘要 | 保留语义信 | 息 额外 API 调用 |
| SLIDING_WINDOW | 滑动窗口，保留最近 N 轮 | 简单可控 | 可能切断完整对话 |
| HYBRID | 摘要 + 滑动窗口组合 | 兼顾语义与时效 | 配置复杂 |
7.4 SUMMARIZE 策略执行流程
消息历史达到阈值（50 条 / 100K tokens）
│
▼
┌─────────────────────────────────────────────────────────┐
│ 1. 分割：old_messages (前 35 条) + recent_messages (后 15 条) │
│ 2. 调用 summaryModel 对 old_messages 生成摘要 │
│ 3. 将摘要替换 old_messages │
│ 4. 新的消息序列 = [SummaryMessage] + recent_messages │
│ 5. 保存到 AgentState │
└─────────────────────────────────────────────────────────┘
7.5 压缩事件
压缩过程会发出事件，供上层感知：
agent.streamEvents(msg, ctx)
.doOnNext(event -> {
if (event instanceof CompactionStartEvent e) {
log.info("开始压缩: {} 条消息 → 摘要", e.getMessageCount());
}
if (event instanceof CompactionEndEvent e) {
log.info("压缩完成: 节省 {} tokens", e.getTokensSaved());
}
})
.subscribe();
7.6 与 MEMORY.md 的协作
Compaction 压缩了旧消息
│
▼
重要信息是否已写入 MEMORY.md？
│
├── 是 → 安全压缩，信息可从 MEMORY.md 召回
└── 否 → Agent 应在压缩前主动写入 MEMORY.md
最佳实践：Agent 在感知到即将压缩时，应主动将关键信息写入 MEMORY.md，确保压缩后仍可召回。
八、EventStream：实时事件流
8.1 设计定位
EventStream 是 Agent 执行过程中的实时事件通道，驱动流式输出与中间件通知：
Flux<AgentEvent> events = agent.streamEvents(userMessage, ctx);
8.2 事件类型体系
AgentEvent (抽象基类)
├── TextBlockDeltaEvent # 文本增量（流式输出核心）
├── ToolCallStartEvent # 工具调用开始
├── ToolCallEndEvent # 工具调用结束
├── ToolResultEvent # 工具执行结果
├── PermissionRequestEvent # 权限审批请求
├── PermissionResponseEvent # 权限审批响应
├── CompactionStartEvent # 压缩开始
├── CompactionEndEvent # 压缩结束
├── ModelCallStartEvent # 模型调用开始
├── ModelCallEndEvent # 模型调用结束
├── ErrorEvent # 错误事件
└── DoneEvent # 执行完成
8.3 事件流时序
streamEvents(userMsg, ctx)
│
├── ModelCallStartEvent
├── TextBlockDeltaEvent ("我来")
├── TextBlockDeltaEvent ("帮你")
├── TextBlockDeltaEvent ("查询")
├── ModelCallEndEvent
│
├── ToolCallStartEvent (query_order)
├── ToolResultEvent ({...})
├── ToolCallEndEvent
│
├── ModelCallStartEvent
├── TextBlockDeltaEvent ("您的订单")
├── TextBlockDeltaEvent ("状态是...")
├── ModelCallEndEvent
│
└── DoneEvent
8.4 SSE 集成
@GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<String>> chatStream(@RequestParam String message) {
RuntimeContext ctx = RuntimeContext.builder()
.sessionId(UUID.randomUUID().toString())
.userId("user-001")
.build();
return agent.streamEvents(new UserMessage(message), ctx)
.flatMap(event -> {
if (event instanceof TextBlockDeltaEvent delta) {
return Flux.just(ServerSentEvent.<String>builder()
.data(delta.getDelta())
.build());
}
if (event instanceof ToolCallStartEvent tool) {
return Flux.just(ServerSentEvent.<String>builder()
.event("tool_start")
.data(tool.getToolCallName())
.build());
}
return Flux.empty();
});
}
九、上下文在各构建块中的流转
9.1 完整数据流
┌─────────────────────────────────────────────────────────────────┐
│ 请求进入 │
│ agent.call(userMsg, RuntimeContext) │
└──────────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 1. 加载 AgentState │
│ MessageStore.load(sessionId) → messages + variables │
└──────────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 2. 检查是否需要 Compaction │
│ messages.size() > threshold? → 执行压缩 │
└──────────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 3. 组装 System Prompt │
│ sysPrompt + MEMORY.md + Skills + Tools Schema │
└──────────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 4. ReAct 循环 │
│ Reasoning → Acting → Observation → Reasoning → ... │
│ 每轮读写 AgentState.messages │
│ 每次工具调用透传 RuntimeContext │
│ 每个步骤发出 AgentEvent │
└──────────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 5. 保存 AgentState │
│ MessageStore.save(sessionId, newMessages) │
└──────────────────────────────┬──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 6. 返回结果 │
│ ChatResponse / Flux<AgentEvent> │
└─────────────────────────────────────────────────────────────────┘
9.2 各组件的数据流向
| 组件 | 读取 | 写入 | 数据来源 |
|---|---|---|---|
| RuntimeContext | Middleware, Tool, Permission | Agent 调用方 | 外部传入 |
| AgentState | Agent, Compaction | Agent, MessageStore | MessageStore 加载 |
| Memory | System Prompt 组装 | Agent（通过工具） | MEMORY.md / 向量库 |
| MessageStore | Agent 启动时 | Agent 结束时 | SQLite / Redis |
| Compaction | AgentState.messages | AgentState.messages | 自动触发 |
| EventStream | 前端 / 日志 | Agent 各阶段 | 实时产生 |
十、完整实战：带记忆的客服 Agent
10.1 场景描述
构建一个电商客服 Agent：
- 记住用户偏好和历史问题
- 对话过长时自动压缩
- 消息持久化到 SQLite
- 流式输出 + 事件追踪
10.2 完整代码
public class CustomerServiceAgentDemo {
public static void main(String[] args) {
// === 1. 配置消息持久化 ===
MessageStore store = SqliteMessageStore.builder()
.dbPath("/data/agentscope/cs-agent.db")
.maxHistorySize(500)
.ttl(Duration.ofDays(90))
.build();
// === 2. 配置上下文压缩 ===
CompactionConfig compaction = CompactionConfig.builder()
.strategy(CompactionStrategy.SUMMARIZE)
.triggerMessages(40)
.triggerTokens(80000)
.keepMessages(10)
.summaryModel("dashscope:qwen-turbo")
.build();
// === 3. 配置工具 ===
Toolkit toolkit = new Toolkit();
toolkit.registerTool(new OrderTools());
toolkit.registerTool(new LogisticsTools());
// === 4. 构建 Agent ===
HarnessAgent agent = HarnessAgent.builder()
.name("customer-service")
.sysPrompt("""
你是电商客服助手。
- 记住用户的偏好和历史问题
- 回答要简洁专业
- 遇到无法解决的问题，引导用户联系人工客服
""")
.model("dashscope:qwen-plus")
.toolkit(toolkit)
.messageStore(store)
.compaction(compaction)
.middleware(new OtelTracingMiddleware())
.middleware(new AuditMiddleware())
.build();
// === 5. 模拟多轮对话 ===
RuntimeContext ctx = RuntimeContext.builder()
.sessionId("session-alice-001")
.userId("alice")
.orgId("acme")
.build();
// 第一轮
agent.streamEvents(
new UserMessage("我的订单 ORD-001 到哪了？"),
ctx
).doOnNext(e -> printEvent(e)).blockLast();
// 第二轮（自动加载历史消息）
agent.streamEvents(
new UserMessage("帮我查一下这个订单的退款进度"),
ctx
).doOnNext(e -> printEvent(e)).blockLast();
// 第三轮（Agent 记得之前的订单号）
agent.streamEvents(
new UserMessage("好的，那我等一下"),
ctx
).doOnNext(e -> printEvent(e)).blockLast();
}
private static void printEvent(AgentEvent event) {
switch (event) {
case TextBlockDeltaEvent e -> System.out.print(e.getDelta());
case ToolCallStartEvent e -> System.out.println("\n🔧 " + e.getToolCallName());
case CompactionStartEvent e -> System.out.println("\n📦 开始压缩...");
case CompactionEndEvent e -> System.out.println("📦 压缩完成，节省 " + e.getTokensSaved() + " tokens");
case DoneEvent e -> System.out.println("\n✅ 完成");
default -> {}
}
}
}
10.3 执行效果
=== 第一轮 ===
🔧 track_logistics
Agent: 您的订单 ORD-001 当前在杭州转运中心，预计明天下午送达。
=== 第二轮 ===
Agent: 您是想查询 ORD-001 的退款进度吗？我帮您查一下。
🔧 query_refund
Agent: ORD-001 的退款正在审核中，预计 1-2 个工作日完成。
=== 第三轮 ===
Agent: 好的，请您耐心等待。如果超过 3 个工作日仍未到账，请随时联系我。
✅ 完成
注意：第三轮中 Agent 自动记住了"ORD-001"，无需用户重复提及——这得益于 AgentState 的消息历史持久化。
十一、上下文管理的生产最佳实践
11.1 RuntimeContext 最佳实践
| 实践 | 说明 |
|---|---|
| sessionId 必传 | 无 sessionId 则无法关联历史消息 |
| userId 用于审计 | 所有操作日志都应关联 userId |
| metadata 轻量化 | 避免放入大对象，只放标识性信息 |
| 不可变原则 | 不要尝试修改已构建的 RuntimeContext |
11.2 AgentState 最佳实践
| 实践 | 说明 |
|---|---|
| 设置 maxHistorySize | 防止无限增长 |
| 配置 TTL | 过期会话自动清理 |
| 定期归档 | 超长会话归档到冷存储 |
| 监控状态大小 | 告警异常增长的会话 |
11.3 Compaction 最佳实践
| 实践 | 说明 |
|---|---|
| 用轻量模型做摘要 | qwen-turbo 而非 qwen-max |
| 保留足够近期消息 | keepMessages ≥ 10 |
| 压缩前写入 MEMORY.md | 确保关键信息不丢失 |
| 监控压缩频率 | 频繁压缩说明阈值过低 |
11.4 Memory 最佳实践
| 实践 | 说明 |
|---|---|
| 结构化存储 | 按章节组织 MEMORY.md |
| 定期整理 | 去除过时信息 |
| 区分事实与偏好 | 事实可验证，偏好主观 |
| 向量记忆设阈值 | similarityThreshold ≥ 0.7 避免噪声 |
十二、与其他构建块的协作矩阵
| 构建块 | 与 Context 的关系 |
|---|---|
| Model | 接收 RuntimeContext 用于计费/追踪；消息来自 AgentState |
| Tool | 通过 ToolContext 获取 RuntimeContext；执行结果写入 AgentState |
| Middleware | onAgent/onReasoning 接收 RuntimeContext；可读写 AgentState |
| Permission | 根据 RuntimeContext.userId/orgId 匹配权限规则 |
| Event | 所有事件携带 RuntimeContext；Compaction 事件反映状态变化 |
| Harness | 编排 Memory 注入、Compaction 触发、MessageStore 加载/保存 |
十三、从 1.x 到 2.0 的上下文演进
| 维度 | 1.x | 2.0 |
|---|---|---|
| 请求上下文 | 无统一抽象 | RuntimeContext 标准化 |
| 状态管理 | 内存列表 | AgentState + MessageStore |
| 消息持久化 | 无 | SQLite / Redis / JDBC |
| 长期记忆 | 无 | MEMORY.md + 向量检索 |
| 上下文压缩 | 简单截断 | SUMMARIZE / HYBRID / SLIDING_WINDOW |
| 事件流 | 无 | 完整 AgentEvent 体系 |
| 多租户 | 无 | orgId + 配置隔离 |
| 状态变量 | 无 | variables Map |
十四、结语
AgentScope Java 2.0 的 Context 构建块，用 RuntimeContext 解决了"谁在调用"的身份问题，用 AgentState + MessageStore 解决了"之前发生了什么"的记忆问题，用 Memory 解决了"长期知识如何留存"的问题，用 Compaction 解决了"上下文太长怎么办"的工程问题，用 EventStream 解决了"执行过程如何观测"的问题。
它的核心价值在于：
将"上下文管理"这件横跨多个关注点的复杂工程，拆解为五个独立、可组合、可配置的构建块，让开发者像搭积木一样组装出适合自己业务的上下文策略。
对于生产级 Agent 应用而言，上下文系统不是"锦上添花"的功能，而是决定 Agent 能否真正"记住事情"、“持续对话”、"可控运行"的基础设施。
没有上下文的 Agent 只是一个聊天机器人。有了上下文的 Agent，才是一个真正的智能体。
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
12
0- 0
已为社区贡献8条内容
所有评论(0)