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

210
README.md
View File

@ -1,80 +1,79 @@
# NextAgent — 认知解耦智能体架构
NextAgent 是一套颠覆传统单一 LLM 模式的**认知解耦智能体架构**。通过模拟人脑的模块化分工，将认知、记忆、推理与表达分离为独立子网，子网间通过**自定义张量协议**通信，从根本上解决大模型的**幻觉**问题与**效率瓶颈**。
NextAgent 是一套颠覆传统单一 LLM 模式的**认知解耦智能体架构**。通过模拟人脑的模块化分工，将认知、记忆、推理与表达分离为独立子网，子网间通过**统一张量协议**通信，从根本上解决大模型的**幻觉**问题与**效率瓶颈**。
## 核心架构
```
┌─────────────────────────────────────────────────────────────────────┐
│ 应用层 (CLI/API/SDK) │
└──────────────────────────────┬──────────────────────────────────────┘
┌──────────────┐
│ 用户 │
│ (输入/输出) │
└──────┬───────┘
│
┌──────────────────────────────▼──────────────────────────────────────┐
│ 调度 Core (前额叶皮层) │
│ 启发式调度 · 逻辑判断 · 任务解析 · 记忆聚合 │
│ ┌──────────────┐ ┌──────────────┐ ┌────────────────────────┐ │
│ │ 任务解析器 │ │ 调度策略引擎 │ │ 记忆聚合器 │ │
│ │ 拆解用户意图 │ │ 启发式调度规则 │ │ 汇总子网结果→记忆参数包 │ │
│ └──────────────┘ └──────────────┘ └────────────────────────┘ │
└──────┬──────┬──────┬──────┬──────┬──────┬──────┬───────────────────┘
│ │ │ │ │ │ │
│ └──张量通信层──┐ │ │ │
│ (Standard Tensor Protocol) │ │
▼ ▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ 路由与压缩 │ ←──→ │ 记忆子网 │ │ 逻辑链路 │ │ LLM 子网 │
│(感觉中枢) │ 张 量 │(海马体/皮层)│ │追踪神经网络│ │(布洛卡区) │
│ │ │ │ │ (推理回路) │ │ │
│ 多模态 │ │ 图数据库 │ │ 逻辑验证 │ │ 自然语言→用户 │
│ 特征提取 │ │ 向量数据库 │ │ 自我修正 │ │ 表达张量→Core │
│ 信息压缩 │ │ 文本记忆 │ │ 路径重规划 │ │ │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
│
▼
┌────────────────────┐
│ 存储层 (冷区存储) │
│ 原始数据 · 索引 │
└────────────────────┘
┌──────────▼──────────┐
│ 外部输入/输出 │
│ (唯一接入外部路径) │
└──────┬──────┬───────┘
│ │
┌──────▼──┐ ┌─▼────────┐
│ 路由与 │ │ LLM │
│ 压缩子网 │ │ 子网 │
│(唯一输入) │ │(唯一输出) │
│ 多模态 │ │ 自然语言 │
│ 特征提取 │ │ 给用户 │
│ 标签张量 │ │ │
└──────┬──┘ └────┬──────┘
│ │
│ 张量通信层 │
│ (内部通信) │
▼ ▼
┌──────────────────────────┐
│ 调度 Core (内部层) │
│ 启发式调度 · 内部分发 │
│ │
│ ┌──────────┐ ┌────────┐ │
│ │ 记忆子网 │ │ 逻辑子网 │ │
│ │(唯一记忆) │ │(推理回路)│ │
│ │ 自治读写 │ │ 验证重规│ │
│ │ 图DB/向量 │ │ 划/错误│ │
│ │ /文本 │ │ 追溯 │ │
│ └──────────┘ └────────┘ │
└──────────────────────────┘
```
### 边界规则
| 方向 | 路径 | 说明 |
|------|------|------|
| **输入** | 用户 → 路由与压缩子网（唯一） | 所有图像/文本/语音必须经过路由子网，且仅此一路 |
| **输出** | LLM 子网 → 用户（唯一） | 当前仅 LLM 输出自然语言，可扩展图像/视频输出子网 |
| **内部** | 调度 Core + 子网 | Core 是内部调度层，不直接与用户交互 |
| **记忆** | 记忆子网（自治） | 唯一记忆模块。Core 仅传递查询张量+新信息张量，如何更新/删除/修改由记忆子网自行决策 |
### Mermaid 架构图
```mermaid
graph TB
User["用户"] -->|"自然语言/多模态输入"| Core["调度 Core<br/>(前额叶皮层)"]
User["用户"] -->|"图像/文本/语音"| RCN["路由与压缩子网<br/>(唯一输入路径)"]
subgraph TensorLayer ["张量通信层 (Standard Tensor Protocol)"]
direction LR
TE["编码层<br/>Encoder: 内部张量→标准张量"]
TD["解码层<br/>Decoder: 标准张量→内部张量"]
subgraph Internal ["系统内部"]
direction TB
Core["调度 Core<br/>(内部调度层)"]
MEM["记忆子网<br/>(唯一记忆模块·自治)"]
LTC["逻辑链路追踪子网<br/>(推理回路)"]
end
subgraph Subnets ["四大子网"]
RCN["路由与压缩子网<br/>(感觉中枢)<br/>多模态→标准张量"]
MEM["记忆子网<br/>(海马体与皮层)<br/>图DB+向量DB+文本"]
LTC["逻辑链路追踪<br/>神经网络<br/>(推理回路)"]
LLM["LLM 子网<br/>(布洛卡区/表达核)"]
end
Cold["冷区存储<br/>原始数据"]
Core -->|"启发式调度"| RCN
Core -->|"启发式调度"| MEM
Core -->|"启发式调度"| LTC
Core -->|"启发式调度|张量"| LLM
RCN -.->|"标准张量"| Core
MEM -.->|"记忆检索张量"| Core
LTC -.->|"推理路径张量"| Core
LLM -.->|"表达验证张量"| Core
RCN -->|"标签张量"| Core
Core -->|"查询张量+新信息"| MEM
MEM -->|"记忆张量"| Core
Core -->|"推理请求"| LTC
LTC -->|"推理路径张量"| Core
Core -->|"推理路径"| LLM["LLM 子网<br/>(唯一输出路径)"]
LLM -->|"自然语言"| User
LLM -.->|"表达验证张量"| Core
Core -->|"记忆更新参数张量"| MEM
MEM -->|"读写"| Cold
RCN -.-> Cold
LTC -.-> Cold
RCN -.->|"滑动窗口保留原始数据"| Raw["临时原始数据"]
Core -.->|"一轮结束后调度处理"| RCN
```
## 通信机制：统一张量协议 (Unified Tensor Protocol)
@ -85,7 +84,7 @@ graph TB
#### 适配器模式（编解码层）
每个子网通过一个**编解码层（Codec Layer）**与外部通信，负责将子网内部的私有数据格式（如 PyTorch Tensor、MindSpore Tensor 或自定义结构）转换为统一的标准张量格式：
每个子网通过一个**编解码层（Codec Layer）**与外部通信，负责将子网内部的私有数据格式（如 PyTorch Tensor、自定义结构等）转换为统一的标准张量格式：
```
┌─────────────┐ ┌───────────────────┐ ┌─────────────┐
@ -100,7 +99,7 @@ graph TB
└─────────────┘ └───────────────────┘ └─────────────┘
```
**作用**：屏蔽不同子网/框架的实现差异。新的子网只要实现对应的编解码器（Adapter），就能接入系统，无需修改调度 Core 或其他已有模块的代码。
**作用**：屏蔽不同子网/框架的实现差异。新的子网只要实现编解码适配器，就能接入系统，无需修改调度 Core 或其他已有模块。
#### 门面模式（统一张量接口）
@ -131,9 +130,9 @@ interface TensorBus:
### 核心优势
#### 动态并网与即插即用
- 新的子网只需实现编解码器即可向 Core 注册，实现**运行时热插拔**
- 新的子网只需实现编解码适配器即可向 Core 注册，支持**运行时热插拔**
- 各子网独立迭代算法，接口不变即不影响系统稳定性
- 支持运行时动态创建/销毁子网
- 支持运行时根据需求动态创建/销毁子网
#### 零拷贝（Zero-Copy）
在支持分布式能力的系统上，张量可通过**内核旁路技术**直接在设备间传递内存地址，避免将数据从 NPU/GPU 搬回 CPU 再打包的昂贵序列化开销。
@ -142,26 +141,28 @@ interface TensorBus:
张量是 NPU/GPU 的**原生计算单元**，协议允许数据在设备内存池中直接流转，无需格式转换，大幅降低延迟和 CPU 占用。
#### 高数据保真度
相比于文本或 JSON 协议，张量能**无损传递高维特征图、注意力权重矩阵**等复杂数值结构，确保传递的是完整的
相比于文本或 JSON 协议，张量能**无损传递高维特征图、注意力权重矩阵**等复杂数值结构，确保传递的是完整的"思维向量"而非降维后的符号化描述。
## 调度方式：启发式调度
Core 的调度不是线性流式的。每次收到数据包后：
Core 的调度是启发式的，非流式管线。每次收到数据包后动态决策：
1. 解析输入 → 判断任务类型
2. 调用记忆子网检索上下文
3. 根据记忆结果决定：是否再次调用路由提取输入 → 送逻辑推理 → 再查记忆 → ...
4. 反复、多方式调用子网，逐步收敛到最终结果
5. 将所有子网结果聚合，打包为记忆更新参数包 → 送记忆子网更新
1. 路由子网处理输入 → 生成标签张量 → 交给 Core
2. Core 根据标签判断任务类型，调用记忆子网检索上下文
3. 根据记忆结果决定下一步——可能再次调路由提取、送逻辑推理、再查记忆……
4. 反复、多方式调用子网，逐步收敛
5. 将子网结果聚合 → 交记忆子网自主更新
6. 本轮结束后，Core 再调度路由子网对暂存的原始数据进行处理（标签生成、压缩、归档）
## 四大子网概述
## 子网职责
| 子网 | 类比人脑 | 核心职责 | 通信方式 |
|------|---------|---------|---------|
| **路由与压缩子网** | 感觉中枢 | 多模态特征提取、信息压缩、引用张量生成 | 标准张量 |
| **记忆子网** | 海马体与皮层 | 图数据库+向量数据库+文本三级记忆存储与检索 | 记忆检索张量 / 记忆更新参数张量 |
| **逻辑链路追踪神经网络** | 推理回路 | 逻辑验证、错误追溯、路径重规划、自我修正 | 推理路径张量 |
| **LLM 子网** | 布洛卡区/表达核 | 结构化→自然语言（给用户）+ 表达验证张量（给Core） | 表达验证张量 |
| 子网 | 角色 | 核心职责 |
|------|------|---------|
| **路由与压缩子网** | 🚪 唯一输入路径 | 处理多模态输入，生成标签张量，滑动窗口暂存原始数据 |
| **记忆子网** | 🧠 唯一记忆模块（自治） | 独立管理图数据库+向量数据库+文本三级存储，自行决策如何更新/删除/修改 |
| **逻辑链路追踪神经网络** | 🔗 推理回路 | 逻辑验证、错误追溯、路径重规划、自我修正 |
| **LLM 子网** | 📤 唯一输出路径 | 结构化→自然语言给用户 + 表达验证张量给Core |
| **调度 Core** | 🎯 内部调度层 | 启发式统筹调度，不直接与用户交互 |
## 设计哲学
@ -169,23 +170,28 @@ Core 的调度不是线性流式的。每次收到数据包后：
传统单一 LLM 的幻觉根源：**知识存储与语言表达在同一网络中耦合**。NextAgent 将两者解耦：
- **记忆子网** 负责存储和检索事实知识（图数据库 + 向量数据库）
- **逻辑推理子网** 负责验证推理链的正确性
- **LLM 子网** 只负责将结构化信息转换为自然语言，**从不"猜测"事实**
- Core 收到 LLM 返回的**表达验证张量**来判断 LLM 是否正确表达了推理结果
- **记忆子网** 独立负责知识存储与检索
- **逻辑推理子网** 独立负责推理验证
- **LLM 子网** 只负责语言表达，**从不"猜测"事实**
- Core 通过分析 LLM 返回的表达验证张量来判断输出正确性
### ⚡ 效率与灵活性 — 冷热数据分离
### 🔒 严格的输入/输出边界
- **热区（张量通信层）**：子网间传递轻量级张量，仅携带元数据和向量
- **温区（图数据库）**：结构化知识图谱，支持 Cypher 查询
- **冷区（原始存储）**：完整原始数据，按需拉取
```
输入 → [路由子网] → [Core+记忆+逻辑] → [LLM] → 输出
唯一入口 内部 唯一出口
```
### 🎯 LLM 下位化
- 路由子网是**唯一**与外部输入交互的组件
- LLM 子网是**唯一**与外部输出交互的组件
- Core 是**纯内部层**，不暴露给用户
- 记忆子网是**唯一记忆模块**，Core 不越权直接操作记忆
LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**：
- 知识来源：记忆子网 → 不依赖 LLM 自身参数知识
- 逻辑来源：推理子网 → LLM 不负责推理
- 输入：结构化推理路径张量 → 不是原始问题
### ⚡ 效率与灵活性
- **张量通信**：子网间传递轻量级张量
- **滑动窗口**：路由子网暂存原始数据，一轮结束后再处理
- **记忆自治**：记忆子网自主决定存储策略
## 快速开始
@ -220,31 +226,31 @@ NextAgent/
│ │ └── memory_aggregator.py # 记忆聚合器
│ ├── protocol/ # 张量协议层
│ │ ├── tensor_schema.py # 标准张量定义
│ │ ├── encoder.py # 编码层
│ │ └── decoder.py # 解码层
│ ├── subnets/ # 四大子网实现
│ │ ├── routing_compression/ # 路由与压缩子网
│ │ ├── encoder.py # 编码器基类
│ │ └── decoder.py # 解码器基类
│ ├── subnets/ # 子网实现
│ │ ├── routing_compression/ # 路由与压缩子网（唯一输入）
│ │ ├── memory/ # 记忆子网（图DB+向量DB+文本）
│ │ ├── logic_trace/ # 逻辑链路追踪子网
│ │ └── llm_expression/ # LLM 表达子网
│ │ └── llm_expression/ # LLM 表达子网（唯一输出）
│ └── storage/ # 存储层
│ ├── graph_db/ # Neo4j 图数据库客户端
│ ├── vector_db/ # 向量数据库客户端
│ └── text_store/ # 文本记忆存储
├── tests/ # 测试套件
├── config/ # 配置文件
└── requirements.txt # 依赖
├── tests/
├── config/
└── requirements.txt
```
## 文档索引
| 文档 | 内容 |
|------|------|
| [架构总览](docs/architecture-overview.md) | 整体设计、张量协议、启发式调度、记忆更新机制 |
| [路由与压缩子网](docs/routing-compression-subnet.md) | 多模态编码、压缩训练、张量化训练 |
| [记忆子网](docs/memory-subnet.md) | 三级存储、图数据库设计、训练计划（参考 TrulyMEM） |
| [架构总览](docs/architecture-overview.md) | 整体设计、张量协议、启发式调度、边界规则 |
| [路由与压缩子网](docs/routing-compression-subnet.md) | 唯一输入路径、滑动窗口、标签张量、两阶段处理 |
| [记忆子网](docs/memory-subnet.md) | 唯一记忆模块、自治读写、三级存储（参考 TrulyMEM）|
| [逻辑链路追踪神经网络](docs/logic-trace-subnet.md) | RLHF+PRM、MCTS、自我修正训练 |
| [LLM 子网](docs/llm-subnet.md) | 双输出通道、SFT/RLHF 微调、表达验证训练 |
| [LLM 子网](docs/llm-subnet.md) | 唯一输出路径、双输出通道、表达验证训练 |
---

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 要求从窗口提取更多特征） |
| 两阶段处理 | 快速出标签 → 轮结束再处理原始数据 |
### 输入/输出
| 项目 | 说明 |