# 架构概览 ## 整体架构设计 NextAgent 采用**认知解耦架构（Cognitive Decoupled Architecture）**，将传统单一 LLM 拆解为多个具有独立职能的子网，通过调度 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 │ │ 路径追踪 │ │ 双输出 │ │ │ └──────────┘ └─────────┘ └─────────┘ └─────────┘ └────────────────┘ ``` ## 统一张量协议（Unified Tensor Protocol） 这是 NextAgent 的核心创新——子网间通过标准化的张量格式通信，不传递自然语言。该协议基于**适配器模式（Adapter Pattern）**和**门面模式（Facade Pattern）**设计，旨在解决多子网架构中的模块异构性与通信效率问题。 ### 核心设计模式 #### 适配器模式（编解码层） 每个子网通过一个编解码层（Codec Layer）与外部通信。该层充当**适配器**，负责将子网内部的私有数据格式（如 PyTorch Tensor、MindSpore Tensor 或自定义结构）转换为统一的标准张量格式。 **作用**：屏蔽不同子网/框架的实现差异。新的子网只要实现对应的编解码器（Adapter），就能接入系统，无需修改调度 Core 或其他已有模块的代码。 #### 门面模式（统一张量接口） 协议对外暴露统一的、简单的接口，隐藏底层复杂的通信过程： ```python 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 和各子网只需与统一的张量门面交互，无需关心底层通信细节。 ### 标准张量格式 ```json { "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 Aggregator)** | 汇总多子网结果，打包为记忆更新参数张量 | ### 启发式调度流程（非流式！） Core 的调度不是线性管线式的。每次收到数据包后，会基于当前状态动态决策： ``` 输入到达 │ ▼ ┌──────────────────┐ │ 1. 任务解析 │ ── 拆解用户意图，生成初始任务图 └──────┬───────────┘ │ ▼ ┌──────────────────┐ │ 2. 调用记忆子网 │ ── "之前聊过这个吗？" │ 查询上下文 │ 第一次记忆检索 └──────┬───────────┘ │ ▼ ┌──────────────────┐ │ 3. 启发式判断 │ ← 根据记忆结果决定下一步 │ │ 有相关记忆？→ 送逻辑推理 + 可能再次调路由提取更多信息 │ │ 无相关记忆？→ 调路由子网全面提取输入特征 │ │ 输入不清晰？→ 再次调路由子网重新提取特征 │ │ 需要更多背景？→ 再次调记忆子网深度检索 │ │ 歧义？→ 多次调不同子网交叉验证 └──────┬───────────┘ │ ▼ ┌──────────────────┐ │ 4. 循环调度 │ ── 反复、多方式调用子网 │ (可能多轮) │ 记忆→推理→记忆→路由→推理→... └──────┬───────────┘ │ ▼ ┌──────────────────┐ │ 5. 送 LLM 表达 │ ── 推理结果足够可靠后，送 LLM 生成自然语言 │ + 接收验证张量 │ Core 收到表达验证张量 → 判断正确性 └──────┬───────────┘ │ ▼ ┌──────────────────┐ │ 6. 记忆聚合更新 │ ── 汇总本轮回所有子网结果 │ │ 打包为 memory_update 张量 │ │ 送记忆子网执行存储 └──────────────────┘ ``` #### 启发式调度算法（简化伪代码） ``` function heuristic_process(input): # 1. 任务解析 task_graph = parse_task(input) # 2. 初始化调度状态 state = { "task": task_graph, "context": {}, "iteration": 0, "confidence": 0.0, "pending_signals": [] } # 3. 启发式调度循环 while not is_complete(state) and state.iteration < MAX_ITERATIONS: next_action = scheduler.decide_next_action(state) # decide_next_action 根据当前状态、历史结果、置信度动态决定 # 可能调用：记忆查询、路由提取、逻辑推理、表达生成、记忆更新 if next_action.type == "memory_retrieve": memory_tensor = memory_subnet.retrieve(next_action.params) 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) 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) # 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) # 5. LLM 的自然语言已直接输出给用户 return state.verified ``` ## LLM 子网双输出通道 LLM 子网的输出有两个去向，这是核心设计之一： ``` ┌──────────────────────┐ │ LLM 子网 │ │ │ 输入：结构化推理路径张量 ──→ LLM 核心处理 │ │ ├── 通道1 ──────────────┤ │ → 自然语言文本 │ ──→ 直接输出给用户 │ │ ├── 通道2 ──────────────┤ │ → 表达验证张量 │ ──→ 返回给 Core │ (包含：语义编码、 │ Core 分析验证张量 │ 置信度、情感标记、 │ 判断 LLM 是否正确表达 │ 表达结构元数据) │ 而非获取自然语言内容 └──────────────────────┘ ``` **关键点**： - Core **不通过自然语言判断** LLM 的输出质量 - Core 通过分析**表达验证张量**（结构化数据）来判断 - 自然语言直接流向用户，Core 不截获 ## 记忆更新机制 记忆更新不是由子网单独完成，而是由 Core 聚合多子网结果后统一触发： ``` ┌──────────┐ 路由子网结果张量 │ 路由 │ ─────────────┐ └──────────┘ │ ├──┐ ┌──────────┐ 推理子网结果张量 │ │ │ 推理 │ ─────────────┤ │ └──────────┘ │ │ │ ├── Core 记忆聚合器 ── 打包 ──→ 记忆更新参数张量 ┌──────────┐ 记忆子网交互结果 │ │ (MemoryAggregator) (MemoryUpdateTensor) │ 记忆 │ ─────────────┤ │ └──────────┘ │ │ ├──┘ ┌──────────┐ Core 内部状态 │ │ Core │ ─────────────┘ └──────────┘ 记忆更新参数张量 ──→ 记忆子网 │ ├──→ 图数据库写入 (Neo4j) │ (Entity + RELATES 三元组) │ ├──→ 向量索引更新 │ (语义向量写入) │ └──→ 文本记忆记录 (会话日志归档) ``` ## 数据流完整链路（用户视角） ```mermaid sequenceDiagram participant User as 用户 participant Core as 调度 Core participant RCN as 路由与压缩子网 participant MEM as 记忆子网 participant LTC as 逻辑链路追踪子网 participant LLM as LLM 子网 User->>Core: 自然语言/多模态输入 Core->>RCN: ① 路由提取（标准张量） RCN->>RCN: 特征提取与压缩 RCN-->>Core: 返回引用张量 Core->>MEM: ② 记忆检索（标准张量） MEM->>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: ⑩ 记忆更新（参数包张量） MEM->>MEM: 图DB写入+向量索引更新+文本记录 ``` ## 关键设计决策 | 决策 | 选择 | 理由 | |------|------|------| | 子网间通信方式 | 标准张量协议 | 不依赖自然语言，结构化、可验证、低延迟 | | 调度策略 | 启发式调度 | 灵活、适应复杂任务，非固定管线 | | LLM 输出机制 | 双通道（自然语言→用户 / 张量→Core） | 解耦表达与验证 | | 记忆存储 | 图数据库(Neo4j) + 向量数据库 + 文本 | 结构化 + 语义 + 时序 三保险 | | 记忆更新触发 | Core 聚合后统一封装 | 确保记忆一致性，避免碎片化写入 | | LLM 定位 | 专业语言生成引擎 | 不存储知识、不负责推理 | ## 与现有架构对比 | 特性 | 传统单一 LLM | Agent + 工具调用 | NextAgent（认知解耦） | |------|-------------|----------------|-------------------| | 知识存储 | 模型参数内隐式存储 | 外部工具/数据库 | 专用记忆子网（图+向量+文本） | | 推理能力 | 隐式（端到端） | 提示工程驱动 | 专用推理子网 + MCTS | | 子网通信 | 自然语言 | 自然语言/JSON | **结构化张量协议** | | 调度方式 | 线性执行 | 线性工具链 | **启发式、非线性的循环调度** | | LLM 定位 | 全知全能 | 主控+生成 | **降级为语言生成引擎** | | 输出验证 | 无 | 无 | **表达验证张量机制** | | 记忆更新 | 上下文窗口 | 外部DB写入 | **Core聚合后统一打包更新** | | 幻觉控制 | 无专门机制 | 工具结果覆盖 | 知识/推理/表达完全解耦 | | 可解释性 | 低（黑箱） | 中（可追踪工具调用） | 高（完整张量链路追踪） |