# 架构概览 ## 整体架构设计 NextAgent 采用**认知解耦架构（Cognitive Decoupled Architecture）**，将传统单一 LLM 拆解为多个具有独立职能的子网，通过调度 Core 统一协调，子网间通过**标准张量协议**通信。 ### 设计原则 - **单一职责**：每个子网只负责一种认知功能，降低复杂度 - **张量通信**：子网间不传递自然语言，通过统一张量协议交换信息 - **边界隔离**：路由子网是唯一输入路径，LLM 是唯一输出路径，Core 为纯内部层 - **记忆自治**：记忆子网是唯一记忆模块，Core 仅传递查询和新信息张量，读写操作由记忆子网自行决策 - **冷热分离**：活跃数据以张量形式在子网间传递，原始数据暂存于路由子网的滑动窗口，一轮结束后再处理 - **启发式调度**：Core 根据上下文动态决定调用顺序和方式，非线性执行 - **LLM 下位化**：LLM 降级为专业语言生成引擎，知识与逻辑均外置 ### 边界隔离 ``` ┌──────────────┐ │ 用户 │ └──────┬───────┘ │ ┌────────────▼────────────┐ │ 外部输入/输出面 │ └──────┬──────┬───────────┘ │ │ ┌──────▼──┐ ┌─▼──────────┐ │ 路由与 │ │ LLM 子网 │ │ 压缩子网 │ │(唯一输出路径)│ │(唯一输入 │ │ 自然语言→ │ │ 路径) │ │ 用户 │ │ 标签张量 │ │ 表达张量→ │ │ →Core │ │ Core │ └──────┬──┘ └────┬───────┘ │ │ │ 张量通信层 │ ▼ ▼ ┌────────────────────────┐ │ 调度 Core (内部层) │ │ │ │ ┌────────┐ ┌────────┐ │ │ │ 记忆子网 │ │逻辑子网│ │ │ │(自治) │ │(推理) │ │ │ └────────┘ └────────┘ │ └────────────────────────┘ ``` | 方向 | 路径 | 约束 | |------|------|------| | **输入** | 用户 → 路由与压缩子网（唯一） | 所有外部输入必须且只能经过此路径 | | **输出** | LLM 子网 → 用户（唯一） | 当前仅 LLM；可扩展图像/视频输出子网 | | **内部** | Core + 内部子网 | Core 不直接暴露给用户 | | **记忆** | 记忆子网（自治） | Core 仅传递查询张量+新信息张量；记忆子网自行决策全部读写操作 | ## 统一张量协议（Unified Tensor Protocol） NextAgent 的核心——子网间通过**纯数值张量**通信，不传递自然语言、JSON 或任何非张量结构。 ### 协议定义 统一通信张量由**元数据**（独立于张量，由底层总线携带）+ **张量数据**（纯数值）两部分组成。 #### 元数据（总线层传递，非张量的一部分） | 字段 | 说明 | |------|------| | `source` | 发出模型 ID (如 `routing`, `memory`, `logic_trace`, `llm`, `core`) | | `target` | 目标模型 ID | | `reply_req` | 是否需要回复 (true/false) | #### 张量数据（纯数值 ndarray） ``` ┌────────────────────────────────────────────────────┐ │ Unified Communication Tensor │ ├────────────────────────────────────────────────────┤ │ [fmt_id] [parser_id] [padding...] [payload...] │ │ └───────── 自描述前缀 (前缀张量) ──────┘ └──数据──┘│ └────────────────────────────────────────────────────┘ ``` 张量本身就是一个纯粹的数值阵列（如 PyTorch Tensor / NumPy ndarray）。其前缀维度编码了协议信息： - `dim[0]` = **fmt_id**：数据格式标识（查协议注册表） - `dim[1]` = **parser_id**：应使用的解析网络标识 - `dim[2..k]`：保留 / padding - `dim[k+1..]`：实际载荷数据 #### 协议注册表（系统设计时预定义） ```python PROTOCOL_REGISTRY = { "fmt": { 0: "ref_tensor", # 路由引用张量 1: "memory_result", # 记忆检索结果 2: "memory_query", # 记忆查询 3: "memory_update", # 新信息更新 4: "reasoning_path", # 推理路径 5: "expression_verify", # 表达验证 6: "control", # 控制信号 }, "parser": { 0: "ref_parser", 1: "memory_result_parser", 2: "memory_query_parser", 3: "memory_update_parser", 4: "reasoning_parser", 5: "expression_parser", 6: "control_parser", }, } ``` ### 编解码机制（适配器模式） 每个子网实现编解码适配器，在其内部张量格式与统一通信张量之间转换： ``` ┌─────────────┐ ┌─────────────────────┐ ┌──────────────────┐ │ 子网内部 │ ──→ │ 编码适配器 │ ──→ │ 统一通信张量 │ │ 内部张量 │ │ 查注册表 → │ │ [fmt][prs][数据] │ │ │ │ 拼接 fmt+parser 前缀 │ │ │ └─────────────┘ └─────────────────────┘ └──────────────────┘ │ ▼ ┌─────────────┐ ┌─────────────────────┐ ┌──────────────────┐ │ 子网内部 │ ←── │ 解码适配器 │ ←── │ 统一通信张量 │ │ 内部张量 │ │ 解析 prefix → │ │ [fmt][prs][数据] │ │ │ │ 路由对应解码器 → 剥离 │ │ │ └─────────────┘ └─────────────────────┘ └──────────────────┘ ``` #### 编解码接口 ```python class CodecAdapter: """每个子网实现此接口，注册到 TensorBus""" def encode(self, internal_tensor: Tensor, target: str, reply_req: bool) -> Tensor: """内部格式 → 统一通信张量 1. 查协议注册表，获取内部格式对应的 fmt_id 2. 查协议注册表，获取本子网的 parser_id 3. 在数据前拼接 [fmt_id, parser_id, padding..., data...] """ pass def decode(self, comm_tensor: Tensor) -> Tensor: """统一通信张量 → 内部格式 1. 读取 comm_tensor[0] 获取 parser_id 2. 根据 parser_id 路由到对应解码器 3. 剥离前缀，返回内部张量格式 """ pass class TensorBus: """通信总线（门面模式），屏蔽底层实现""" def send(self, tensor: Tensor, source: str, target: str, reply_req: bool) -> None: ... def recv(self, source: str) -> tuple[Tensor, str, str, bool]: ... def register(self, subnet_id: str, codec: CodecAdapter) -> None: ... ``` ### 核心优势 | 优势 | 说明 | |------|------| | 纯粹张量 | 无 JSON/嵌套结构，全部为数值数据，NPU/GPU 原生处理 | | 自描述 | fmt_id + parser_id 编码在张量头部，接收方即知如何解码 | | 即插即用 | 新子网只需实现编解码适配器，通过 `TensorBus.register()` 注册 | | 零拷贝 | 张量可直接在设备内存池流转，无需 CPU 搬运 | | 高保真 | 无损传递高维特征图、注意力权重，不降维 | | 硬件亲和 | 张量是 NPU/GPU 原生计算单元，无需格式转换 | ### 通信示例 ``` 路由子网处理完用户输入后，调用编码适配器: 内部张量 (形状 [768]) → 编码器 → 查表: 路由输出格式 → fmt_id=0, parser_id=0 → 拼接: [0, 0, 0, ..., 768维数据] → 形状 [770] → TensorBus.send(张量, source="routing", target="core", reply_req=True) Core 收到后，调用解码适配器: → 读取 tensor[0]=0 → 格式是 ref_tensor → 读取 tensor[1]=0 → 用 ref_parser 解码 → 剥离前 2 维 → 得到 768 维内部张量 ``` ## 调度 Core（前额叶皮层） 调度 Core 是整个架构的**总指挥**，类比人脑的前额叶皮层。 ### 核心职责 1. **接收路由标签张量**：接收路由与压缩子网处理后的标签张量，而非直接接收用户输入 2. **启发式调度决策**：根据上下文动态决定调用子网的方式和顺序，非线性 3. **子网结果聚合**：收集各子网返回的张量，综合分析 4. **表达验证**：接收 LLM 返回的表达验证张量，判断输出质量 5. **记忆中转**：将本轮新的信息与查询意图封装为张量传递给记忆子网（不越权处理记忆） 6. **冲突解决**：当子网返回矛盾结果时，启动仲裁机制 ### Core 内部组件 | 组件 | 职责 | |------|------| | **任务解析器 (Task Parser)** | 接收路由标签张量，拆解任务图 | | **调度策略引擎 (Scheduler)** | 维护启发式调度规则，决定下一步调哪个子网 | | **上下文管理器 (Context Manager)** | 维护会话状态和中间结果 | | **表达验证器 (Expression Verifier)** | 接收 LLM 的表达验证张量，判断正确性 | | **记忆中转器 (Memory Broker)** | 将本轮新信息和查询意图打包为张量传递给记忆子网；不越权处理记忆内容 | ### 启发式调度流程（非流式！） Core 的调度不是线性管线式的。每次收到路由子网的标签张量后，会基于当前状态动态决策： ``` 路由子网处理输入 → 生成标签张量 │ ▼ 标签张量到达 Core │ ▼ ┌─────────────────────┐ │ 1. 任务解析 │ ── 根据标签拆解用户意图，生成初始任务图 └──────┬──────────────┘ │ ▼ ┌─────────────────────┐ │ 2. 向记忆子网查询 │ ── Core 传入：查询张量 + 新信息标签张量 │ (自治查询) │ 记忆子网自行检索，返回记忆张量 └──────┬──────────────┘ │ ▼ ┌─────────────────────┐ │ 3. 启发式判断 │ ← 根据记忆结果决定下一步 │ │ 有相关记忆？→ 送逻辑推理 │ │ 需要更多输入？→ 调路由提取（滑动窗口） │ │ 更深入记忆？→ 再传新查询给记忆子网 │ │ 模糊？→ 多次调不同子网交叉验证 └──────┬──────────────┘ │ ▼ ┌─────────────────────┐ │ 4. 循环调度 │ ── 反复、多方式调用子网 │ (可能多轮) │ 记忆→推理→路由→记忆→… └──────┬──────────────┘ │ ▼ ┌──────────────────────────┐ │ 5. 送 LLM 表达 │ ── 推理结果可靠后，送推理路径张量 │ + 接收验证张量 │ LLM → 自然语言给用户 │ │ LLM → 表达验证张量给 Core │ │ Core 判断正确性 └──────┬───────────────────┘ │ ▼ ┌──────────────────────────┐ │ 6. 记忆更新（传递信息） │ ── Core 将新信息+验证结果打包 │ │ 传递给记忆子网 │ │ 记忆子网自行决定写入/更新/删除 └──────┬───────────────────┘ │ ▼ ┌──────────────────────────┐ │ 7. 调度路由处理残留数据 │ ── 本轮结束后 Core 通知路由子网 │ │ 处理滑动窗口中的原始数据 │ │ （压缩、标签索引、归档/丢弃） └──────────────────────────┘ ``` #### 启发式调度算法（简化伪代码） ``` function heuristic_process(raw_input): # 0. 路由子网先行处理输入（唯一输入路径） label_tensor = routing_subnet.process(raw_input) # 路由子网持有原始数据的滑动窗口 # 1. 初始化调度状态 state = { "label": label_tensor, "context": {}, "iteration": 0, "confidence": 0.0, "verified": False } # 2. 启发式调度循环 while not state.verified and state.iteration < MAX_ITERATIONS: next_action = scheduler.decide_next_action(state) # decide_next_action 动态决定下一步 if next_action.type == "memory_retrieve": # Core 仅传递查询张量 + 新信息张量给记忆子网 memory_tensor = memory_subnet.retrieve({ "query": next_action.params, "new_info": state.label }) # 记忆子网自行检索，自行决定关联逻辑 state.context["memory"] = memory_tensor elif next_action.type == "routing_extract": # 从路由子网的滑动窗口中获取更丰富的特征 ref_tensor = routing_subnet.extract_from_window( next_action.params ) state.context["refined_input"] = ref_tensor elif next_action.type == "logical_reason": reasoning_tensor = logic_subnet.reason(state.context) state.context["reasoning"] = reasoning_tensor # 从张量前缀解析器解码获取置信度 state.confidence = decode_confidence_from_tensor(reasoning_tensor) elif next_action.type == "llm_express": verify_tensor = llm_subnet.express(state.context) state.context["verification"] = verify_tensor # 解析表达验证张量获取通过判断 if decode_verified_from_tensor(verify_tensor): state.verified = True # 3. 将本轮新信息 + 结果交给记忆子网（自治更新） memory_subnet.update({ "session_info": state.context, "new_data": state.label }) # 记忆子网自行决定如何写入/更新/删除 # 4. 通知路由子网处理滑动窗口中的残留数据 routing_subnet.flush_window({ "processed": True, "archive": use_relevant }) return state.verified ``` ## LLM 子网双输出通道 LLM 子网的输出有两个去向，这是核心设计之一： ``` ┌──────────────────────┐ │ LLM 子网 │ │ │ 输入：结构化推理路径张量 ──→ LLM 核心处理 │ │ ├── 通道1 ──────────────┤ │ → 自然语言文本 │ ──→ 直接输出给用户 │ │ ├── 通道2 ──────────────┤ │ → 表达验证张量(纯张量) │ ──→ 返回给 Core │ 格式约定见协议注册表 │ Core 的验证器解析此张量 │ fmt_id=5: 含语义编码/ │ 判断 LLM 是否正确表达 │ 意图对齐度/实体保留等 │ 而非获取自然语言内容 └──────────────────────┘ ``` **关键点**： - Core **不通过自然语言判断** LLM 的输出质量 - Core 通过分析**表达验证张量**（结构化数据）来判断 - 自然语言直接流向用户，Core 不截获 ## 记忆更新机制 记忆子网是整个设计中**唯一与记忆内容交互的模块**。Core 不自作主张处理记忆，只负责将信息传递给记忆子网，由记忆子网自行决定如何更新、删除和修改。 ### 信息传递流程 ``` 本轮所有子网的结果 │ ▼ ┌──────────────────────────────┐ │ Core 记忆中转器 (Memory Broker) │ │ (不包含任何记忆处理逻辑) │ │ │ │ Core 只做两件事： │ │ 1. 生成查询张量 → 传给记忆子网 │ │ (fmt_id=2, 含编码后的查询) │ │ 2. 生成新信息张量 → 传给记忆子网 │ │ (fmt_id=3, 含编码后的更新数据)│ └──────────┬───────────────────┘ │ ▼ ┌──────────────────────────────┐ │ 记忆子网 (自治) │ │ │ │ 记忆子网自行决定： │ │ → 如何写入新信息 │ │ → 如何更新已有记忆 │ │ → 如何删除/修正错误记忆 │ │ → 选择图DB / 向量DB / 文本 │ │ │ │ 整个过程 Core 不参与 │ └──────────────────────────────┘ ``` ### 查询流程 ``` Core 需要查询记忆时： │ ├── 将当前上下文编码为内部查询张量 ├── 调用编码适配器: 拼接 fmt_id=2 → 统一通信张量 ├── TensorBus.send(张量, "core", "memory", reply_req=True) │ ▼ 记忆子网接收后: ├── 解码适配器读取 prefix → fmt_id=2 (memory_query) ├── 自行解析查询意图 → 图DB/向量DB/文本检索 ├── 将结果编码: 拼接 fmt_id=1 (memory_result) │ ▼ 返回记忆结果张量给 Core ``` ## 数据流完整链路（用户视角） ```mermaid sequenceDiagram participant User as 用户 participant RCN as 路由与压缩子网 participant Core as 调度 Core (内部) participant MEM as 记忆子网 (自治) participant LTC as 逻辑链路追踪子网 participant LLM as LLM 子网 User->>RCN: ① 原始输入（唯一输入路径） RCN->>RCN: 特征提取与标签生成 RCN-->>Core: ② 标签张量 Core->>MEM: ③ 传查询张量+新信息张量 Note over MEM: 记忆子网自行检索 MEM-->>Core: ④ 返回记忆张量 Note over Core: ⑤ 启发式判断 alt 需要更多输入特征 Core->>RCN: 从滑动窗口获取详细特征 RCN-->>Core: 返回详细引用张量 else 需要深层记忆 Core->>MEM: 新查询张量 MEM-->>Core: 更深入的记忆结果 end Core->>LTC: ⑥ 推理请求 LTC->>LTC: MCTS推理+验证 LTC-->>Core: ⑦ 推理路径张量 alt 置信度低 Core->>LTC: 再次推理（携带更多上下文） LTC-->>Core: 修正推理路径 end Core->>LLM: ⑧ 推理路径张量 LLM->>LLM: 结构化→自然语言 LLM-->>User: ⑨ 自然语言输出（唯一输出路径） LLM-->>Core: ⑩ 表达验证张量 Note over Core: ⑪ 验证通过 Core->>MEM: ⑫ 传本轮新信息张量 Note over MEM: 记忆子网自行决定
如何写入/更新/删除 Core->>RCN: ⑬ 通知处理滑动窗口残留数据 RCN->>RCN: 压缩·标签索引·归档 ``` ## 关键设计决策 | 决策 | 选择 | 理由 | |------|------|------| | 子网间通信方式 | 标准张量协议 | 不依赖自然语言，结构化、可验证、低延迟 | | 调度策略 | 启发式调度 | 灵活、适应复杂任务，非固定管线 | | LLM 输出机制 | 双通道（自然语言→用户 / 张量→Core） | 解耦表达与验证 | | 记忆存储 | 图数据库(Neo4j) + 向量数据库 + 文本 | 结构化 + 语义 + 时序 三保险 | | 记忆更新触发 | Core 传新信息→记忆子网自治 | 唯一记忆模块，Core 不越权读写 | | LLM 定位 | 专业语言生成引擎 | 不存储知识、不负责推理 | ## 与现有架构对比 | 特性 | 传统单一 LLM | Agent + 工具调用 | NextAgent（认知解耦） | |------|-------------|----------------|-------------------| | 知识存储 | 模型参数内隐式存储 | 外部工具/数据库 | 专用记忆子网（图+向量+文本） | | 推理能力 | 隐式（端到端） | 提示工程驱动 | 专用推理子网 + MCTS | | 子网通信 | 自然语言 | 自然语言/JSON | **结构化张量协议** | | 调度方式 | 线性执行 | 线性工具链 | **启发式、非线性的循环调度** | | LLM 定位 | 全知全能 | 主控+生成 | **降级为语言生成引擎** | | 输出验证 | 无 | 无 | **表达验证张量机制** | | 记忆更新 | 上下文窗口 | 外部DB写入 | **Core传新信息→记忆子网自治更新** | | **输入路径** | 直接接收 | 直接接收 | **唯一经路由子网** | | **输出路径** | 直接输出 | 直接输出 | **唯一经 LLM 子网** | | 幻觉控制 | 无专门机制 | 工具结果覆盖 | 知识/推理/表达完全解耦 | | 可解释性 | 低（黑箱） | 中（可追踪工具调用） | 高（完整张量链路追踪） |