NextAgent/docs/architecture-overview.md

架构概览

整体架构设计

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  │ │ 路径追踪 │ │ 双输出  │ │                │
└──────────┘ └─────────┘ └─────────┘ └─────────┘ └────────────────┘

自定义张量协议（Standard Tensor Protocol）

这是 NextAgent 的核心创新——子网间通过标准化的张量格式通信，不传递自然语言。

标准张量格式

{
  "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 → 任意子网

编/解码机制

每个子网都配备编码层和解码层：

┌─────────────┐      ┌───────────────────┐      ┌─────────────┐
│  子网内部    │ ──→  │  编码层 (Encoder)   │ ──→  │  标准张量    │
│  内部张量    │      │  内部格式→标准格式  │      │  (通信格式)  │
└─────────────┘      └───────────────────┘      └─────────────┘
                                                        │
                                                        ▼
┌─────────────┐      ┌───────────────────┐      ┌─────────────┐
│  子网内部    │ ←──  │  解码层 (Decoder)   │ ←──  │  标准张量    │
│  内部张量    │      │  标准格式→内部格式  │      │  (通信格式)  │
└─────────────┘      └───────────────────┘      └─────────────┘

调度 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 三元组)
                                                    │
                                                    ├──→ 向量索引更新
                                                    │     (语义向量写入)
                                                    │
                                                    └──→ 文本记忆记录
                                                          (会话日志归档)

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

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: ③ 启发式判断<br/>根据记忆结果决定下一步
    
    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聚合后统一打包更新
幻觉控制	无专门机制	工具结果覆盖	知识/推理/表达完全解耦
可解释性	低（黑箱）	中（可追踪工具调用）	高（完整张量链路追踪）