NextAgent/docs/architecture-overview.md

架构概览

整体架构设计

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 的核心创新——子网间通过标准化的张量格式通信，不传递自然语言。该协议基于**适配器模式（Adapter Pattern）和门面模式（Facade Pattern）**设计，旨在解决多子网架构中的模块异构性与通信效率问题。

核心设计模式

适配器模式（编解码层）

每个子网通过一个编解码层（Codec Layer）与外部通信。该层充当适配器，负责将子网内部的私有数据格式（如 PyTorch Tensor、MindSpore Tensor 或自定义结构）转换为统一的标准张量格式。

作用：屏蔽不同子网/框架的实现差异。新的子网只要实现对应的编解码器（Adapter），就能接入系统，无需修改调度 Core 或其他已有模块的代码。

门面模式（统一张量接口）

协议对外暴露统一的、简单的接口，隐藏底层复杂的通信过程：

class TensorBus:
    """统一张量总线 - 门面模式"""
    def send(tensor: StandardTensor, target: str) -> None:
        # 隐藏了底层实现（共享内存/NPU显存直传/TCP/IP）
        pass
    
    def recv(source: str) -> StandardTensor:
        pass
    
    def register(subnet_id: str, codec: CodecAdapter) -> None:
        """动态注册子网 - 运行时热插拔"""
        pass

调度 Core 和各子网只需与统一的张量门面交互，无需关心底层通信细节。

标准张量格式

{
  "header": {
    "source": "routing_compression | memory | logic_trace | llm | core",
    "target": "routing_compression | memory | logic_trace | llm | core",
    "tensor_type": "ref_tensor | memory_query | memory_result | reasoning_path | expression_verify | memory_update | control",
    "timestamp": 1717200000,
    "trace_id": "uuid-会话追踪ID"
  },
  "metadata": {
    "dimensions": [768, 128],            // 张量维度
    "precision": "float32",              // 精度类型
    "compression_ratio": 0.85,           // 压缩率
    "confidence": 0.92,                  // 置信度
    "encoding_model": "transformer_v3"   // 编码模型标识
  },
  "payload": {
    "data": [0.12, -0.34, ...],          // 实际数据（向量/结构化数据）
    "indices": [1024, 2048, ...],        // 冷区索引（可选）
    "metadata_map": {}                   // 附加元数据
  },
  "signature": "sha256-checksum"         // 完整性校验
}

张量类型

张量类型	说明	发送方 → 接收方
ref_tensor	引用张量，压缩后的多模态特征	路由子网 → Core
memory_query	记忆查询张量	Core → 记忆子网
memory_result	记忆检索结果张量	记忆子网 → Core
reasoning_path	推理路径与验证结果张量	逻辑子网 → Core
expression_verify	表达验证张量（含语义编码、置信度）	LLM 子网 → Core
memory_update	记忆更新参数包张量	Core → 记忆子网
control	控制信号张量（启停、参数调整）	Core → 任意子网

编/解码机制

每个子网都配备适配器式的编解码层：

┌─────────────┐      ┌───────────────────┐      ┌─────────────┐
│  子网内部    │ ──→  │  编码适配器         │ ──→  │  标准张量    │
│  内部格式    │      │  Adapter: 内部→标准  │      │  (统一格式)  │
└─────────────┘      └───────────────────┘      └─────────────┘
                                                        │
                                                        ▼
┌─────────────┐      ┌───────────────────┐      ┌─────────────┐
│  子网内部    │ ←──  │  解码适配器         │ ←──  │  标准张量    │
│  内部格式    │      │  Adapter: 标准→内部  │      │  (统一格式)  │
└─────────────┘      └───────────────────┘      └─────────────┘

核心优势

动态并网与即插即用

• 新的子网只需实现编解码适配器，通过 TensorBus.register() 向 Core 注册即可接入
• 支持运行时热插拔：不中断系统运行即可添加/移除子网
• 各子网独立迭代算法，只要编解码接口不变，不影响系统稳定性
• 支持运行时根据需求训练新的子网并动态接入

零拷贝（Zero-Copy）

支持分布式能力的系统上，张量可通过内核旁路技术直接在设备间传递内存地址，避免将数据从 NPU/GPU 搬回 CPU 再打包的昂贵序列化开销。

硬件亲和性

张量是 NPU/GPU 的原生计算单元。协议允许数据在设备内存池中直接流转，无需经过格式转换，大幅降低延迟和 CPU 占用。

高数据保真度

相比于文本或 JSON 协议，张量能无损传递高维特征图、注意力权重矩阵等复杂数值结构，确保传递的是完整的

调度 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 = reasoning_tensor.metadata.confidence
            
        elif next_action.type == "llm_express":
            verify_tensor = llm_subnet.express(state.context)
            state.context["verification"] = verify_tensor
            if verify_tensor.metadata.confidence > THRESHOLD:
                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 分析验证张量
                    │     置信度、情感标记、  │     判断 LLM 是否正确表达
                    │     表达结构元数据)     │     而非获取自然语言内容
                    └──────────────────────┘

关键点：

• Core 不通过自然语言判断 LLM 的输出质量
• Core 通过分析表达验证张量（结构化数据）来判断
• 自然语言直接流向用户，Core 不截获

记忆更新机制

记忆子网是整个设计中唯一与记忆内容交互的模块。Core 不自作主张处理记忆，只负责将信息传递给记忆子网，由记忆子网自行决定如何更新、删除和修改。

信息传递流程

本轮所有子网的结果
    │
    ▼
┌──────────────────────────────┐
│  Core 记忆中转器 (Memory Broker) │
│  (不包含任何记忆处理逻辑)       │
│                               │
│  Core 只做两件事：              │
│  1. 封装查询张量 → 传给记忆子网  │
│  2. 封装新信息张量 → 传给记忆子网 │
└──────────┬───────────────────┘
           │
           ▼
┌──────────────────────────────┐
│       记忆子网 (自治)          │
│                               │
│  记忆子网自行决定：             │
│  → 如何写入新信息              │
│  → 如何更新已有记忆             │
│  → 如何删除/修正错误记忆        │
│  → 选择图DB / 向量DB / 文本    │
│                               │
│  整个过程 Core 不参与          │
└──────────────────────────────┘

查询流程

Core 需要查询记忆时：
    │
    ├── 封装查询张量（含意图、种子实体、上下文）
    ├── 封装基础张量（含当前标签、路由结果）
    │
    ▼
记忆子网接收后自行检索
    │
    ├── 图数据库 Cypher 查询
    ├── 向量数据库语义检索
    ├── 自行关联推理
    │
    ▼
返回包含记忆的张量给 Core

数据流完整链路（用户视角）

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: 记忆子网自行决定<br/>如何写入/更新/删除
    
    Core->>RCN: ⑬ 通知处理滑动窗口残留数据
    RCN->>RCN: 压缩·标签索引·归档

关键设计决策

决策	选择	理由
子网间通信方式	标准张量协议	不依赖自然语言，结构化、可验证、低延迟
调度策略	启发式调度	灵活、适应复杂任务，非固定管线
LLM 输出机制	双通道（自然语言→用户 / 张量→Core）	解耦表达与验证
记忆存储	图数据库(Neo4j) + 向量数据库 + 文本	结构化 + 语义 + 时序 三保险
记忆更新触发	Core 传新信息→记忆子网自治	唯一记忆模块，Core 不越权读写
LLM 定位	专业语言生成引擎	不存储知识、不负责推理

与现有架构对比

特性	传统单一 LLM	Agent + 工具调用	NextAgent（认知解耦）
知识存储	模型参数内隐式存储	外部工具/数据库	专用记忆子网（图+向量+文本）
推理能力	隐式（端到端）	提示工程驱动	专用推理子网 + MCTS
子网通信	自然语言	自然语言/JSON	结构化张量协议
调度方式	线性执行	线性工具链	启发式、非线性的循环调度
LLM 定位	全知全能	主控+生成	降级为语言生成引擎
输出验证	无	无	表达验证张量机制
记忆更新	上下文窗口	外部DB写入	Core传新信息→记忆子网自治更新
输入路径	直接接收	直接接收	唯一经路由子网
输出路径	直接输出	直接输出	唯一经 LLM 子网
幻觉控制	无专门机制	工具结果覆盖	知识/推理/表达完全解耦
可解释性	低（黑箱）	中（可追踪工具调用）	高（完整张量链路追踪）