# NextAgent — 认知解耦智能体架构

NextAgent 是一套颠覆传统单一 LLM 模式的**认知解耦智能体架构**。通过模拟人脑的模块化分工，将认知、记忆、推理与表达分离为独立子网，子网间通过**统一张量协议**通信，从根本上解决大模型的**幻觉**问题与**效率瓶颈**。

## 核心架构

```
                        ┌──────────────┐
                        │    用户       │
                        │  (输入/输出)   │
                        └──────┬───────┘
                               │
                    ┌──────────▼──────────┐
                    │     外部输入/输出     │
                    │   (唯一接入外部路径)   │
                    └──────┬──────┬───────┘
                           │      │
                    ┌──────▼──┐ ┌─▼────────┐
                    │ 路由与   │ │ LLM      │
                    │ 压缩子网 │ │ 子网      │
                    │(唯一输入) │ │(唯一输出)  │
                    │ 多模态    │ │ 自然语言   │
                    │ 特征提取  │ │ 给用户     │
                    │ 标签张量  │ │          │
                    └──────┬──┘ └────┬──────┘
                           │         │
                           │ 张量通信层  │
                           │ (内部通信)  │
                           ▼         ▼
               ┌──────────────────────────┐
               │     调度 Core (内部层)     │
               │  启发式调度 · 内部分发      │
               │                           │
               │  ┌──────────┐ ┌────────┐  │
               │  │ 记忆子网  │ │ 逻辑子网 │  │
               │  │(唯一记忆) │ │(推理回路)│  │
               │  │ 自治读写  │ │ 验证重规│  │
               │  │ 图DB/向量 │ │ 划/错误│  │
               │  │ /文本    │ │ 追溯   │  │
               │  └──────────┘ └────────┘  │
               └──────────────────────────┘
```

### 边界规则

| 方向 | 路径 | 说明 |
|------|------|------|
| **输入** | 用户 → 路由与压缩子网（唯一） | 所有图像/文本/语音必须经过路由子网，且仅此一路 |
| **输出** | LLM 子网 → 用户（唯一） | 当前仅 LLM 输出自然语言，可扩展图像/视频输出子网 |
| **内部** | 调度 Core + 子网 | Core 是内部调度层，不直接与用户交互 |
| **记忆** | 记忆子网（自治） | 唯一记忆模块。Core 仅传递查询张量+新信息张量，如何更新/删除/修改由记忆子网自行决策 |

### Mermaid 架构图

```mermaid
graph TB
    User["用户"] -->|"图像/文本/语音"| RCN["路由与压缩子网<br/>(唯一输入路径)"]
    
    subgraph Internal ["系统内部"]
        direction TB
        Core["调度 Core<br/>(内部调度层)"]
        MEM["记忆子网<br/>(唯一记忆模块·自治)"]
        LTC["逻辑链路追踪子网<br/>(推理回路)"]
    end

    RCN -->|"标签张量"| Core
    Core -->|"查询张量+新信息"| MEM
    MEM -->|"记忆张量"| Core
    Core -->|"推理请求"| LTC
    LTC -->|"推理路径张量"| Core
    Core -->|"推理路径"| LLM["LLM 子网<br/>(唯一输出路径)"]
    LLM -->|"自然语言"| User
    LLM -.->|"表达验证张量"| Core
    
    RCN -.->|"滑动窗口保留原始数据"| Raw["临时原始数据"]
    Core -.->|"一轮结束后调度处理"| RCN
```

## 通信机制：统一张量协议 (Unified Tensor Protocol)

所有子网间不传递自然语言，而是通过**统一张量协议**通信。该协议基于**适配器模式（Adapter Pattern）**和**门面模式（Facade Pattern）**设计，旨在解决模块异构性与通信效率问题。

### 统一通信张量协议 (Unified Tensor Protocol)

所有子网间通过**纯数值张量**通信，不传递自然语言、JSON 或任何非张量结构。协议基于**适配器模式**设计。

#### 协议定义

统一通信张量由两部分组成：

**1. 元数据（独立于张量，由底层总线传递）**
| 字段 | 说明 |
|------|------|
| `source` | 发出模型 ID |
| `target` | 目标模型 ID |
| `reply_req` | 是否需要回复 (true/false) |

**2. 张量数据（纯数值张量，ndarray）**
```
┌──────────────────────────────────────────────────┐
│           Unified Communication Tensor             │
├──────────────────────────────────────────────────┤
│  [fmt_id]  [parser_id]  [padding...]  [payload...] │
│  └───────── 自描述前缀 ──────────┘  └──真实数据──┘│
└──────────────────────────────────────────────────┘
```

其中 `fmt_id` 和 `parser_id` 为**协议注册表**中预定义的标量标识：
- `fmt_id`：标识数据格式（如 0=ref_tensor, 1=memory_result, 2=reasoning_path）
- `parser_id`：标识应使用哪个解析网络（如 0=ref_parser, 1=memory_parser）

```python
# 协议注册表（系统设计时预定义）
PROTOCOL_REGISTRY = {
    "fmt": {0: "ref_tensor", 1: "memory_result", 2: "reasoning_path", ...},
    "parser": {0: "ref_parser", 1: "memory_parser", 2: "reasoning_parser", ...},
}
```

#### 编解码层（适配器模式）

每个子网实现编解码适配器，在子系统内部格式与统一通信张量之间转换：

```
┌─────────────┐      ┌─────────────────────┐      ┌────────────────┐
│  子网内部     │ ──→  │  编码适配器          │ ──→  │  统一通信张量    │
│  内部张量     │      │  拼接 fmt_id+parser_id│      │  [fmt][prs][数据]│
└─────────────┘      └─────────────────────┘      └────────────────┘
                                                            │
                                                            ▼
┌─────────────┐      ┌─────────────────────┐      ┌────────────────┐
│  子网内部     │ ←──  │  解码适配器          │ ←──  │  统一通信张量    │
│  内部张量     │      │  解析 parser_id → 解码 │      │  [fmt][prs][数据]│
└─────────────┘      └─────────────────────┘      └────────────────┘
```

**编解码器接口**：
```python
class CodecAdapter:
    """每个子网实现此接口"""
    def encode(self, internal_tensor: Tensor) -> Tensor:
        # 1. 查协议注册表获取 fmt_id
        # 2. 拼接 [fmt_id, parser_id, ...padding..., payload]
        pass

    def decode(self, comm_tensor: Tensor) -> Tensor:
        # 1. 读取前缀中的 parser_id
        # 2. 路由到对应解码器
        # 3. 剥离前缀，返回内部格式
        pass
```

#### 门面模式（通信总线）

底层通信机制（共享内存/NPU 显存直传/TCP/IP）对子网透明：

```python
class TensorBus:
    def send(tensor: Tensor, source: str, target: str, reply_req: bool) -> None
    def recv(source: str) -> tuple[Tensor, str, str, bool]  # tensor, source, target, reply_req
    def register(subnet_id: str, codec: CodecAdapter) -> None
```

#### 核心特性
- **纯粹张量**：无 JSON，无嵌套结构，全部为数值数据
- **自描述前缀**：fmt_id + parser_id 编码在张量头部
- **协议预定义**：所有 fmt_id/parser_id 系统设计时查表确定
- **硬件亲和**：张量是 NPU/GPU 原生单元，可实现零拷贝

### 核心优势

#### 动态并网与即插即用
- 新的子网只需实现编解码适配器即可向 Core 注册，支持**运行时热插拔**
- 各子网独立迭代算法，接口不变即不影响系统稳定性
- 支持运行时根据需求动态创建/销毁子网

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

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

#### 高数据保真度
相比于文本或 JSON 协议，张量能**无损传递高维特征图、注意力权重矩阵**等复杂数值结构，确保传递的是完整的"思维向量"而非降维后的符号化描述。

## 调度方式：启发式调度

Core 的调度是启发式的，非流式管线。每次收到数据包后动态决策：

1. 路由子网处理输入 → 生成标签张量 → 交给 Core
2. Core 根据标签判断任务类型，调用记忆子网检索上下文
3. 根据记忆结果决定下一步——可能再次调路由提取、送逻辑推理、再查记忆……
4. 反复、多方式调用子网，逐步收敛
5. 将子网结果聚合 → 交记忆子网自主更新
6. 本轮结束后，Core 再调度路由子网对暂存的原始数据进行处理（标签生成、压缩、归档）

## 子网职责

| 子网 | 角色 | 核心职责 |
|------|------|---------|
| **路由与压缩子网** | 🚪 唯一输入路径 | 处理多模态输入，生成标签张量，滑动窗口暂存原始数据 |
| **记忆子网** | 🧠 唯一记忆模块（自治） | 独立管理图数据库+向量数据库+文本三级存储，自行决策如何更新/删除/修改 |
| **逻辑链路追踪神经网络** | 🔗 推理回路 | 逻辑验证、错误追溯、路径重规划、自我修正 |
| **LLM 子网** | 📤 唯一输出路径 | 结构化→自然语言给用户 + 表达验证张量给Core |
| **调度 Core** | 🎯 内部调度层 | 启发式统筹调度，不直接与用户交互 |

## 设计哲学

### 🧠 认知解耦 — 解决"幻觉"问题

传统单一 LLM 的幻觉根源：**知识存储与语言表达在同一网络中耦合**。NextAgent 将两者解耦：

- **记忆子网** 独立负责知识存储与检索
- **逻辑推理子网** 独立负责推理验证
- **LLM 子网** 只负责语言表达，**从不"猜测"事实**
- Core 通过分析 LLM 返回的表达验证张量来判断输出正确性

### 🔒 严格的输入/输出边界

```
输入 → [路由子网] → [Core+记忆+逻辑] → [LLM] → 输出
        唯一入口             内部             唯一出口
```

- 路由子网是**唯一**与外部输入交互的组件
- LLM 子网是**唯一**与外部输出交互的组件
- Core 是**纯内部层**，不暴露给用户
- 记忆子网是**唯一记忆模块**，Core 不越权直接操作记忆

### ⚡ 效率与灵活性

- **张量通信**：子网间传递轻量级张量
- **滑动窗口**：路由子网暂存原始数据，一轮结束后再处理
- **记忆自治**：记忆子网自主决定存储策略

## 快速开始

```bash
# 克隆仓库
git clone ssh://git@jianfgit.xyz:220/jianf/NextAgent.git
cd NextAgent

# 查看文档
# 架构总览：docs/architecture-overview.md
# 子网细节：docs/routing-compression-subnet.md
#           docs/memory-subnet.md
#           docs/logic-trace-subnet.md
#           docs/llm-subnet.md
```

## 目录结构

```
NextAgent/
├── README.md                          # 项目概述（本文件）
├── docs/
│   ├── architecture-overview.md       # 架构总览（核心）
│   ├── routing-compression-subnet.md  # 路由与压缩子网
│   ├── memory-subnet.md               # 记忆子网
│   ├── logic-trace-subnet.md          # 逻辑链路追踪神经网络
│   └── llm-subnet.md                  # LLM 子网
├── src/
│   ├── core/                          # 调度 Core
│   │   ├── scheduler.py               # 启发式调度引擎
│   │   ├── task_parser.py             # 任务解析器
│   │   └── memory_aggregator.py       # 记忆聚合器
│   ├── protocol/                      # 张量协议层
│   │   ├── tensor_schema.py           # 标准张量定义
│   │   ├── encoder.py                 # 编码器基类
│   │   └── decoder.py                 # 解码器基类
│   ├── subnets/                       # 子网实现
│   │   ├── routing_compression/       # 路由与压缩子网（唯一输入）
│   │   ├── memory/                    # 记忆子网（图DB+向量DB+文本）
│   │   ├── logic_trace/               # 逻辑链路追踪子网
│   │   └── llm_expression/            # LLM 表达子网（唯一输出）
│   └── storage/                       # 存储层
│       ├── graph_db/                  # Neo4j 图数据库客户端
│       ├── vector_db/                 # 向量数据库客户端
│       └── text_store/                # 文本记忆存储
├── tests/
├── config/
└── requirements.txt
```

## 文档索引

| 文档 | 内容 |
|------|------|
| [架构总览](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) | 唯一输出路径、双输出通道、表达验证训练 |

---

> NextAgent — 让智能体像人脑一样思考，模块化、可解释、可信赖。