jianf/NextAgent
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: fix architecture boundaries - routing=unique input, LLM=unique output, memory=autonomous

Browse Source 
Key corrections:
- Routing subnet is the ONLY external input path; all images/text/voice must pass through it
- LLM subnet is the ONLY external output path; natural language goes directly to user
- Core is a purely internal layer, not directly exposed to users
- Memory subnet is autonomous: Core only passes query tensors + new information tensors;
  how to update/delete/modify is entirely decided by memory subnet
- Routing subnet uses sliding window mechanism: instant label tensor generation → Core,
  then after the round ends, Core schedules routing to process remaining raw data
- Updated all ASCII diagrams, Mermaid diagrams, pseudo-code, and data flow charts
- Added border rules table to all relevant docs
This commit is contained in:
root
2026-06-01 09:38:33 +08:00
parent 74fe091026
commit 3345394bf5
5 changed files with 378 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

337
docs/architecture-overview.md
View File

@ -7,48 +7,52 @@ NextAgent 采用**认知解耦架构（Cognitive Decoupled Architecture）**，
### 设计原则
- **单一职责**：每个子网只负责一种认知功能，降低复杂度
- **张量通信**：子网间不传递自然语言，通过标准张量协议交换信息
- **冷热分离**：活跃数据以张量形式在子网间传递，原始数据存储在冷区
- **张量通信**：子网间不传递自然语言，通过统一张量协议交换信息
- **边界隔离**：路由子网是唯一输入路径，LLM 是唯一输出路径，Core 为纯内部层
- **记忆自治**：记忆子网是唯一记忆模块，Core 仅传递查询和新信息张量，读写操作由记忆子网自行决策
- **冷热分离**：活跃数据以张量形式在子网间传递，原始数据暂存于路由子网的滑动窗口，一轮结束后再处理
- **启发式调度**：Core 根据上下文动态决定调用顺序和方式，非线性执行
- **LLM 下位化**：LLM 降级为专业语言生成引擎，知识与逻辑均外置
### 架构分层
### 边界隔离
```
┌─────────────────────────────────────────────────────────────────┐
│ 应用层 │
│ CLI / API / SDK / Web Interface / 第三方集成 │
└───────────────────────┬─────────────────────────────────────────┘
│
┌───────────────────────▼─────────────────────────────────────────┐
│ 调度 Core（前额叶皮层） │
│ ┌──────────────┐ ┌──────────────┐ ┌────────────────────────┐ │
│ │ 任务解析器 │ │ 调度策略引擎 │ │ 记忆聚合器 │ │
│ │ 拆解用户意图 │ │ 启发式调度规则 │ │ 汇总子网结果→记忆参数包 │ │
│ └──────────────┘ └──────────────┘ └────────────────────────┘ │
└──────┬──────┬──────┬──────┬──────┬──────┬───────────────────────┘
│ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼
┌─────────────────────────────────────────────────────────────────┐
│ 张量通信层（核心创新） │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ 标准张量 (Standard Tensor) │ │
│ │ Header: 源/目标/类型/时间戳 | Payload: 数据 | Sig: 校验 │ │
│ │ 各子网通过 编码层(Encoder) → 标准张量 → 解码层(Decoder) │ │
│ └────────────────────────────────────────────────────────┘ │
└──────┬──────┬──────┬──────┬──────┬──────┬───────────────────────┘
│ │ │ │ │ │
┌──────▼──┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼────────────────┐
│ 路由与 │ │ 记忆 │ │ 逻辑链路 │ │ LLM │ │ 存储层 │
│ 压缩子网 │ │ 子网 │ │ 追踪子网 │ │ 子网 │ │ ┌────────────┐ │
│(感觉中枢) │ │(海马体) │ │(推理回路)│ │(布洛卡) │ │ │ Neo4j 图DB │ │
│ │ │ │ │ │ │ │ │ │ 向量数据库 │ │
│ ViT │ │ Entity │ │ MCTS │ │ SFT │ │ │ 文本存储 │ │
│ Wav2Vec │ │ 三元组 │ │ PRM │ │ RLHF │ │ └────────────┘ │
│ BERT │ │ Cypher │ │ 路径追踪 │ │ 双输出 │ │ │
└──────────┘ └─────────┘ └─────────┘ └─────────┘ └────────────────┘
┌──────────────┐
│ 用户 │
└──────┬───────┘
│
┌────────────▼────────────┐
│ 外部输入/输出面 │
└──────┬──────┬───────────┘
│ │
┌──────▼──┐ ┌─▼──────────┐
│ 路由与 │ │ LLM 子网 │
│ 压缩子网 │ │(唯一输出路径)│
│(唯一输入 │ │ 自然语言→ │
│ 路径) │ │ 用户 │
│ 标签张量 │ │ 表达张量→ │
│ →Core │ │ Core │
└──────┬──┘ └────┬───────┘
│ │
│ 张量通信层 │
▼ ▼
┌────────────────────────┐
│ 调度 Core (内部层) │
│ │
│ ┌────────┐ ┌────────┐ │
│ │ 记忆子网 │ │逻辑子网│ │
│ │(自治) │ │(推理) │ │
│ └────────┘ └────────┘ │
└────────────────────────┘
```
| 方向 | 路径 | 约束 |
|------|------|------|
| **输入** | 用户 → 路由与压缩子网（唯一） | 所有外部输入必须且只能经过此路径 |
| **输出** | LLM 子网 → 用户（唯一） | 当前仅 LLM；可扩展图像/视频输出子网 |
| **内部** | Core + 内部子网 | Core 不直接暴露给用户 |
| **记忆** | 记忆子网（自治） | Core 仅传递查询张量+新信息张量；记忆子网自行决策全部读写操作 |
## 统一张量协议（Unified Tensor Protocol）
这是 NextAgent 的核心创新——子网间通过标准化的张量格式通信，不传递自然语言。该协议基于**适配器模式（Adapter Pattern）**和**门面模式（Facade Pattern）**设计，旨在解决多子网架构中的模块异构性与通信效率问题。
@ -161,100 +165,118 @@ class TensorBus:
### 核心职责
1. **任务解析**：接收用户输入，拆解为可执行的子任务序列
1. **接收路由标签张量**：接收路由与压缩子网处理后的标签张量，而非直接接收用户输入
2. **启发式调度决策**：根据上下文动态决定调用子网的方式和顺序，非线性
3. **子网结果聚合**：收集各子网返回的张量，综合分析
4. **表达验证**：接收 LLM 返回的表达验证张量，判断输出质量
5. **记忆聚合**：汇总各子网结果，打包为记忆更新参数包张量
5. **记忆中转**：将本轮新的信息与查询意图封装为张量传递给记忆子网（不越权处理记忆）
6. **冲突解决**：当子网返回矛盾结果时，启动仲裁机制
### Core 内部组件
| 组件 | 职责 |
|------|------|
| **任务解析器 (Task Parser)** | 接收输入，拆解任务图 |
| **任务解析器 (Task Parser)** | 接收路由标签张量，拆解任务图 |
| **调度策略引擎 (Scheduler)** | 维护启发式调度规则，决定下一步调哪个子网 |
| **上下文管理器 (Context Manager)** | 维护会话状态和中间结果 |
| **表达验证器 (Expression Verifier)** | 接收 LLM 的表达验证张量，判断正确性 |
| **记忆聚合器 (Memory Aggregator)** | 汇总多子网结果，打包为记忆更新参数张量 |
| **记忆中转器 (Memory Broker)** | 将本轮新信息和查询意图打包为张量传递给记忆子网；不越权处理记忆内容 |
### 启发式调度流程（非流式！）
Core 的调度不是线性管线式的。每次收到数据包后，会基于当前状态动态决策：
Core 的调度不是线性管线式的。每次收到路由子网的标签张量后，会基于当前状态动态决策：
```
输入到达
路由子网处理输入 → 生成标签张量
│
▼
┌──────────────────┐
│ 1. 任务解析 │ ── 拆解用户意图，生成初始任务图
└──────┬───────────┘
标签张量到达 Core
│
▼
┌─────────────────────┐
│ 1. 任务解析 │ ── 根据标签拆解用户意图，生成初始任务图
└──────┬──────────────┘
│
▼
┌──────────────────┐
│ 2. 调用记忆子网 │ ── "之前聊过这个吗？"
│ 查询上下文 │ 第一次记忆检索
└──────┬───────────┘
┌─────────────────────┐
│ 2. 向记忆子网查询 │ ── Core 传入：查询张量 + 新信息标签张量
│ (自治查询) │ 记忆子网自行检索，返回记忆张量
└──────┬──────────────┘
│
▼
┌──────────────────┐
│ 3. 启发式判断 │ ← 根据记忆结果决定下一步
│ │ 有相关记忆？→ 送逻辑推理 + 可能再次调路由提取更多信息
│ │ 无相关记忆？→ 调路由子网全面提取输入特征
│ │ 输入不清晰？→ 再次调路由子网重新提取特征
│ │ 需要更多背景？→ 再次调记忆子网深度检索
│ │ 歧义？→ 多次调不同子网交叉验证
└──────┬───────────┘
┌─────────────────────┐
│ 3. 启发式判断 │ ← 根据记忆结果决定下一步
│ │ 有相关记忆？→ 送逻辑推理
│ │ 需要更多输入？→ 调路由提取（滑动窗口）
│ │ 更深入记忆？→ 再传新查询给记忆子网
│ │ 模糊？→ 多次调不同子网交叉验证
└──────┬──────────────┘
│
▼
┌──────────────────┐
│ 4. 循环调度 │ ── 反复、多方式调用子网
│ (可能多轮) │ 记忆→推理→记忆→路由→推理→...
└──────┬───────────┘
┌─────────────────────┐
│ 4. 循环调度 │ ── 反复、多方式调用子网
│ (可能多轮) │ 记忆→推理→路由→记忆→…
└──────┬──────────────┘
│
▼
┌──────────────────┐
│ 5. 送 LLM 表达 │ ── 推理结果足够可靠后，送 LLM 生成自然语言
│ + 接收验证张量 │ Core 收到表达验证张量 → 判断正确性
└──────┬───────────┘
┌──────────────────────────┐
│ 5. 送 LLM 表达 │ ── 推理结果可靠后，送推理路径张量
│ + 接收验证张量 │ LLM → 自然语言给用户
│ │ LLM → 表达验证张量给 Core
│ │ Core 判断正确性
└──────┬───────────────────┘
│
▼
┌──────────────────┐
│ 6. 记忆聚合更新 │ ── 汇总本轮回所有子网结果
│ │ 打包为 memory_update 张量
│ │ 送记忆子网执行存储
└──────────────────┘
┌──────────────────────────┐
│ 6. 记忆更新（传递信息） │ ── Core 将新信息+验证结果打包
│ │ 传递给记忆子网
│ │ 记忆子网自行决定写入/更新/删除
└──────┬───────────────────┘
│
▼
┌──────────────────────────┐
│ 7. 调度路由处理残留数据 │ ── 本轮结束后 Core 通知路由子网
│ │ 处理滑动窗口中的原始数据
│ │ （压缩、标签索引、归档/丢弃）
└──────────────────────────┘
```
#### 启发式调度算法（简化伪代码）
```
function heuristic_process(input):
# 1. 任务解析
task_graph = parse_task(input)
function heuristic_process(raw_input):
# 0. 路由子网先行处理输入（唯一输入路径）
label_tensor = routing_subnet.process(raw_input)
# 路由子网持有原始数据的滑动窗口
# 2. 初始化调度状态
# 1. 初始化调度状态
state = {
"task": task_graph,
"label": label_tensor,
"context": {},
"iteration": 0,
"confidence": 0.0,
"pending_signals": []
"verified": False
}
# 3. 启发式调度循环
while not is_complete(state) and state.iteration < MAX_ITERATIONS:
# 2. 启发式调度循环
while not state.verified and state.iteration < MAX_ITERATIONS:
next_action = scheduler.decide_next_action(state)
# decide_next_action 根据当前状态、历史结果、置信度动态决定
# 可能调用：记忆查询、路由提取、逻辑推理、表达生成、记忆更新
# decide_next_action 动态决定下一步
if next_action.type == "memory_retrieve":
memory_tensor = memory_subnet.retrieve(next_action.params)
# Core 仅传递查询张量 + 新信息张量给记忆子网
memory_tensor = memory_subnet.retrieve({
"query": next_action.params,
"new_info": state.label
})
# 记忆子网自行检索，自行决定关联逻辑
state.context["memory"] = memory_tensor
state.pending_signals.append(memory_tensor)
elif next_action.type == "routing_extract":
ref_tensor = routing_subnet.extract(next_action.params)
# 从路由子网的滑动窗口中获取更丰富的特征
ref_tensor = routing_subnet.extract_from_window(
next_action.params
)
state.context["refined_input"] = ref_tensor
elif next_action.type == "logical_reason":
@ -264,17 +286,23 @@ function heuristic_process(input):
elif next_action.type == "llm_express":
verify_tensor = llm_subnet.express(state.context)
# verify_tensor 包含语义编码和置信度，非自然语言
state.context["verification"] = verify_tensor
# 如果验证通过，置完成标记
if verify_tensor.metadata.confidence > THRESHOLD:
state.verified = True
# 4. 记忆聚合更新
update_tensor = memory_aggregator.build_update_tensor(state)
memory_subnet.store(update_tensor)
# 3. 将本轮新信息 + 结果交给记忆子网（自治更新）
memory_subnet.update({
"session_info": state.context,
"new_data": state.label
})
# 记忆子网自行决定如何写入/更新/删除
# 4. 通知路由子网处理滑动窗口中的残留数据
routing_subnet.flush_window({
"processed": True,
"archive": use_relevant
})
# 5. LLM 的自然语言已直接输出给用户
return state.verified
```
@ -306,35 +334,54 @@ LLM 子网的输出有两个去向，这是核心设计之一：
## 记忆更新机制
记忆更新不是由子网单独完成，而是由 Core 聚合多子网结果后统一触发：
记忆子网是整个设计中**唯一与记忆内容交互的模块**。Core 不自作主张处理记忆，只负责将信息传递给记忆子网，由记忆子网自行决定如何更新、删除和修改。
### 信息传递流程
```
┌──────────┐ 路由子网结果张量
│ 路由 │ ─────────────┐
└──────────┘ │
├──┐
┌──────────┐ 推理子网结果张量 │ │
│ 推理 │ ─────────────┤ │
└──────────┘ │ │
│ ├── Core 记忆聚合器 ── 打包 ──→ 记忆更新参数张量
┌──────────┐ 记忆子网交互结果 │ │ (MemoryAggregator) (MemoryUpdateTensor)
│ 记忆 │ ─────────────┤ │
└──────────┘ │ │
├──┘
┌──────────┐ Core 内部状态 │
│ Core │ ─────────────┘
└──────────┘
本轮所有子网的结果
│
▼
┌──────────────────────────────┐
│ Core 记忆中转器 (Memory Broker) │
│ (不包含任何记忆处理逻辑) │
│ │
│ Core 只做两件事： │
│ 1. 封装查询张量 → 传给记忆子网 │
│ 2. 封装新信息张量 → 传给记忆子网 │
└──────────┬───────────────────┘
│
▼
┌──────────────────────────────┐
│ 记忆子网 (自治) │
│ │
│ 记忆子网自行决定： │
│ → 如何写入新信息 │
│ → 如何更新已有记忆 │
│ → 如何删除/修正错误记忆 │
│ → 选择图DB / 向量DB / 文本 │
│ │
│ 整个过程 Core 不参与 │
└──────────────────────────────┘
```
记忆更新参数张量 ──→ 记忆子网
│
├──→ 图数据库写入 (Neo4j)
│ (Entity + RELATES 三元组)
│
├──→ 向量索引更新
│ (语义向量写入)
│
└──→ 文本记忆记录
(会话日志归档)
### 查询流程
```
Core 需要查询记忆时：
│
├── 封装查询张量（含意图、种子实体、上下文）
├── 封装基础张量（含当前标签、路由结果）
│
▼
记忆子网接收后自行检索
│
├── 图数据库 Cypher 查询
├── 向量数据库语义检索
├── 自行关联推理
│
▼
返回包含记忆的张量给 Core
```
## 数据流完整链路（用户视角）
@ -342,51 +389,51 @@ LLM 子网的输出有两个去向，这是核心设计之一：
```mermaid
sequenceDiagram
participant User as 用户
participant Core as 调度 Core
participant RCN as 路由与压缩子网
participant MEM as 记忆子网
participant Core as 调度 Core (内部)
participant MEM as 记忆子网 (自治)
participant LTC as 逻辑链路追踪子网
participant LLM as LLM 子网
User->>Core: 自然语言/多模态输入
User->>RCN: ① 原始输入（唯一输入路径）
RCN->>RCN: 特征提取与标签生成
RCN-->>Core: ② 标签张量
Core->>RCN: ① 路由提取（标准张量）
RCN->>RCN: 特征提取与压缩
RCN-->>Core: 返回引用张量
Core->>MEM: ③ 传查询张量+新信息张量
Note over MEM: 记忆子网自行检索
MEM-->>Core: ④ 返回记忆张量
Core->>MEM: ② 记忆检索（标准张量）
MEM->>MEM: 图数据库+向量检索
MEM-->>Core: 返回记忆结果张量
Note over Core: ③ 启发式判断<br/>根据记忆结果决定下一步
Note over Core: ⑤ 启发式判断
alt 需要更多输入特征
Core->>RCN: 再次调路由子网（携带记忆上下文）
RCN-->>Core: 返回更精确的引用张量
Core->>RCN: 从滑动窗口获取详细特征
RCN-->>Core: 返回详细引用张量
else 需要深层记忆
Core->>MEM: 二次记忆检索（携带路由新结果）
MEM-->>Core: 返回关联记忆张量
Core->>MEM: 新查询张量
MEM-->>Core: 更深入的记忆结果
end
Core->>LTC: ④ 逻辑推理（标准张量）
LTC->>LTC: MCTS推理路径搜索+验证
LTC-->>Core: 返回推理路径张量
Core->>LTC: ⑥ 推理请求
LTC->>LTC: MCTS推理+验证
LTC-->>Core: ⑦ 推理路径张量
alt 推理置信度低
Core->>LTC: ⑤ 携带更多上下文重新推理
LTC-->>Core: 返回修正后的推理路径
alt 置信度低
Core->>LTC: 再次推理（携带更多上下文）
LTC-->>Core: 修正推理路径
end
Core->>LLM: ⑥ 表达生成（推理路径张量）
LLM->>LLM: 结构化→自然语言转换
Core->>LLM: ⑧ 推理路径张量
LLM->>LLM: 结构化→自然语言
LLM-->>User: ⑨ 自然语言输出（唯一输出路径）
LLM-->>Core: ⑩ 表达验证张量
LLM-->>User: ⑦ 自然语言输出（直接给用户）
LLM-->>Core: ⑧ 表达验证张量（判断正确性）
Note over Core: ⑪ 验证通过
Note over Core: ⑨ 表达验证通过
Core->>MEM: ⑫ 传本轮新信息张量
Note over MEM: 记忆子网自行决定<br/>如何写入/更新/删除
Core->>MEM: ⑩ 记忆更新（参数包张量）
MEM->>MEM: 图DB写入+向量索引更新+文本记录
Core->>RCN: ⑬ 通知处理滑动窗口残留数据
RCN->>RCN: 压缩·标签索引·归档
```
## 关键设计决策
@ -397,7 +444,7 @@ sequenceDiagram
| 调度策略 | 启发式调度 | 灵活、适应复杂任务，非固定管线 |
| LLM 输出机制 | 双通道（自然语言→用户 / 张量→Core） | 解耦表达与验证 |
| 记忆存储 | 图数据库(Neo4j) + 向量数据库 + 文本 | 结构化 + 语义 + 时序 三保险 |
| 记忆更新触发 | Core 聚合后统一封装 | 确保记忆一致性，避免碎片化写入 |
| 记忆更新触发 | Core 传新信息→记忆子网自治 | 唯一记忆模块，Core 不越权读写 |
| LLM 定位 | 专业语言生成引擎 | 不存储知识、不负责推理 |
## 与现有架构对比
@ -410,6 +457,8 @@ sequenceDiagram
| 调度方式 | 线性执行 | 线性工具链 | **启发式、非线性的循环调度** |
| LLM 定位 | 全知全能 | 主控+生成 | **降级为语言生成引擎** |
| 输出验证 | 无 | 无 | **表达验证张量机制** |
| 记忆更新 | 上下文窗口 | 外部DB写入 | **Core聚合后统一打包更新** |
| 记忆更新 | 上下文窗口 | 外部DB写入 | **Core传新信息→记忆子网自治更新** |
| **输入路径** | 直接接收 | 直接接收 | **唯一经路由子网** |
| **输出路径** | 直接输出 | 直接输出 | **唯一经 LLM 子网** |
| 幻觉控制 | 无专门机制 | 工具结果覆盖 | 知识/推理/表达完全解耦 |
| 可解释性 | 低（黑箱） | 中（可追踪工具调用） | 高（完整张量链路追踪） |

4
docs/llm-subnet.md
View File

@ -2,7 +2,9 @@
## 概述
LLM 子网类比人脑的**布洛卡区（表达核）**，是 NextAgent 架构中**唯一直接与用户交互**的组件。在认知解耦架构下，LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**：知识来源外置到记忆子网，逻辑推理外置到推理子网，LLM 仅负责将结构化的推理结果转换为自然语言。
LLM 子网类比人脑的**布洛卡区（表达核）**，是 NextAgent 架构中**唯一的输出路径**（当前仅输出自然语言；可扩展图像、视频等输出子网）。
在认知解耦架构下，LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**：知识来源外置到记忆子网，逻辑推理外置到推理子网，LLM 仅负责将结构化的推理结果转换为自然语言。
### 核心设计：LLM 下位化

39
docs/memory-subnet.md
View File

@ -8,16 +8,30 @@
### 架构定位
记忆子网是整个 NextAgent 架构中**唯一与记忆内容交互的模块**。Core 不自作主张处理记忆——只负责将查询张量和新信息张量传递过来，**如何更新、删除、修改**由记忆子网自行完成。
```
记忆更新参数张量 (来自 Core) 记忆检索请求张量 (来自 Core)
│ │
▼ ▼
Core 传过来的两样东西
│
┌─────────┴────────────┐
│ │
查询张量 新信息张量
(含意图/种子实体) (含本轮标签/结果)
│ │
└─────────┬────────────┘
│
▼
┌───────────────────────────────────────────────────────────┐
│ 记忆子网 │
│ 记忆子网（自治） │
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ 记忆管理器 (Memory Manager) │ │
│ │ 解析参数包 → 分发到对应存储层 → 返回结果 │ │
│ │ 记忆管理器 (Memory Manager) │ │
│ │ 自行决定： │ │
│ │ → 如何解析查询 → 走图DB/向量DB/文本 │ │
│ │ → 如何写入新信息 → MERGE/CREATE/更新 │ │
│ │ → 如何更新已有记忆 → 增量/覆盖/合并 │ │
│ │ → 如何删除 → 软删除/硬删除/归档 │ │
│ │ → 如何关联 → 链路推理/图谱推理 │ │
│ └──────┬────────────┬──────────────┬─────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
@ -32,8 +46,8 @@
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ 张量编/解码层 │ │
│ │ 接收：memory_query / memory_update 标准张量 │ │
│ │ 输出：memory_result 标准张量 │ │
│ │ 输入：查询张量 + 新信息张量（来自 Core） │ │
│ │ 输出：记忆结果张量（返回给 Core） │ │
│ └────────────────────────────────────────────────────┘ │
└───────────────────────────────────────────────────────────┘
```
@ -133,9 +147,10 @@ LIMIT 10
| 项目 | 说明 |
|------|------|
| **输入1** | `memory_query` 张量（来自 Core，含查询意图和种子实体） |
| **输入2** | `memory_update` 张量（来自 Core，含要写入的三元组和元数据） |
| **输入1** | 查询张量（来自 Core，含查询意图、种子实体、上下文） |
| **输入2** | 新信息张量（来自 Core，含本轮标签和子网结果；**不含具体写入指令**） |
| **输出** | `memory_result` 张量（包含检索到的实体/关系/向量结果） |
| **自治** | 记忆子网自行决定如何写入、更新、删除、修改记忆 |
## 训练目标
@ -284,9 +299,9 @@ class Neo4jGraph:
| 信息一致性 | 同一信息多次检索结果是否一致 |
| 记忆容量 | 在不显著降低性能前提下的最大存储量 |
## 记忆更新参数包张量格式
## 新信息张量格式
Core 打包给记忆子网的 `memory_update` 张量格式：
Core 传递给记忆子网的**新信息张量**（Core 不发送
```json
{

60
docs/routing-compression-subnet.md
View File

@ -6,31 +6,65 @@
### 架构定位
路由与压缩子网是 **NextAgent 唯一外部信息输入路径**。所有图像、文本、语音输入都必须经过此子网处理。
```
原始输入 (图像/语音/文本)
原始输入 (图像/语音/文本) ←── 唯一外部输入入口
│
▼
┌──────────────────────────────────────────────┐
│ 路由与压缩子网（感觉中枢） │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 多模态 │ │ 特征融合 │ │ 压缩编码 │ │
│ │ 编码器 │ →│ (Attention)│ →│ (AutoEnc)│ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ ┌──────────────────────────────────────────┐│
│ │ 阶段 A（即时处理） ││
│ │ 输入产生时立即执行 ││
│ │ ││
│ │ ┌──────────┐ ┌──────────┐ ┌────────┐ ││
│ │ │ 多模态 │→│ 特征融合 │→│ 标签 │ ││
│ │ │ 编码器 │ │ (Attention)│ │ 生成器 │ ││
│ │ └──────────┘ └──────────┘ └────────┘ ││
│ │ ││
│ │ 输出：标签张量 → 立即发送给调度 Core ││
│ │ 原始数据 → 存入滑动窗口（保留一段时间） ││
│ └──────────────────────────────────────────┘│
│ │
│ ┌──────────────────────────────────────┐ │
│ │ 张量编码层 (Tensor Encoder) │ │
│ │ 内部张量 → 标准通信张量 │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────┐│
│ │ 阶段 B（轮结束后执行） ││
│ │ Core 通知后触发 ││
│ │ ││
│ │ ┌──────────┐ ┌──────────┐ ┌────────┐ ││
│ │ │ 压缩编码 │→│ 张量化 │→│ 归档/ │ ││
│ │ │ (AutoEnc) │ │ (Tensor) │ │ 丢弃 │ ││
│ │ └──────────┘ └──────────┘ └────────┘ ││
│ │ ││
│ │ 处理目标：滑动窗口中的原始数据 ││
│ └──────────────────────────────────────────┘│
│ │
└──────────────────┬───────────────────────────┘
│
▼
标准引用张量 (Standard Ref Tensor)
│
→ 发送给调度 Core
├── 阶段 A: 标签张量（即时） → 调度 Core
└── 阶段 B: 处理后数据（轮结束）→ 冷区存储/丢弃
```
### 滑动窗口机制
路由子网维护一个**滑动窗口**暂存原始输入数据：
| 参数 | 说明 |
|------|------|
| 窗口大小 | 最近 N 条输入（可配置，默认 10 条） |
| 保留时间 | 窗口内数据在本轮调度结束前均有效 |
| 触发清除 | Core 通知 `flush_window()` 后处理残留数据 |
| 数据用途 | 供 Core 调度中间再次提取详细特征 |
### 边界规则
| 规则 | 说明 |
|------|------|
| 唯一输入路径 | 所有外部数据必须经过此子网 |
| 不参与调度循环内部 | 路由子网不参与 Core 的内部记忆/推理循环（除非 Core 要求从窗口提取更多特征） |
| 两阶段处理 | 快速出标签 → 轮结束再处理原始数据 |
### 输入/输出
| 项目 | 说明 |