米塞斯行为引擎 (Mises Behavior Engine) 产品需求文档

版本：2.0
更新日期：2026-01-19

📋 版本更新记录

目录

1. 产品概述
2. 功能模块设计
3. 数据模型设计
4. 技术实现方案
5. TITANS+MIRAS 架构与模型训练
6. 架构模式：纯MCP（有状态）
7. 序列流转控制
8. 小智MCP接入流程
9. 质量评判标准
10. 用户管理与计费系统
11. 知识库与专家系统 🆕
12. 开发里程碑
13. 关键文件清单

1. 产品概述

1.1 产品定位

米塞斯行为引擎（MBE）是一个基于米塞斯人类行为学（Praxeology）的AI决策分析系统，将"有目的行为理论"转化为可操作的AI工具，帮助个体做出更理性的主观决策。

1.2 核心理念

• 行为序列：不舒适 → 愿望 → 路径 → 评估 → 行动 → 循环
• 主观价值论：无客观最佳，只提供结构化选项和模拟
• 核心要素：机会成本、时间偏好、稀缺性、不确定性

1.3 技术架构

• 核心架构：TITANS + MIRAS
• 短期记忆：Transformer Attention处理当前输入
• 长期记忆：深层神经网络存储用户历史模式
• 惊喜机制：检测偏好变化，选择性更新记忆

graph TB
    subgraph external [外部接入层]
        XiaoZhi[小智 XIAOZHI.ME]
        OtherApps[其他MCP客户端]
    end
    
    subgraph mcp [MCP服务层]
        MCPServer[MCP Server]
        ToolRegistry[工具注册中心]
    end
    
    subgraph core [核心引擎层]
        UneaseDetector[不舒适挖掘器]
        DesireAnalyzer[愿望分析器]
        PathGenerator[路径生成器]
        FeasibilityAssessor[可行性评估器]
        ActionTracker[行动跟踪器]
    end
    
    subgraph memory [记忆系统层]
        ShortTermMem[短期记忆 Attention]
        LongTermMem[长期记忆 Neural]
        SurpriseEngine[惊喜检测引擎]
    end
    
    subgraph storage [存储层]
        PostgreSQL[(PostgreSQL)]
        VectorDB[(向量数据库)]
    end
    
    subgraph llm [LLM抽象层]
        LLMAdapter[LLM适配器]
        DeepSeek[DeepSeek]
        Qwen[Qwen]
        DoubleBao[豆包]
    end
    
    XiaoZhi --> MCPServer
    OtherApps --> MCPServer
    MCPServer --> ToolRegistry
    ToolRegistry --> UneaseDetector
    ToolRegistry --> DesireAnalyzer
    ToolRegistry --> PathGenerator
    ToolRegistry --> FeasibilityAssessor
    ToolRegistry --> ActionTracker
    
    UneaseDetector --> ShortTermMem
    DesireAnalyzer --> ShortTermMem
    PathGenerator --> LongTermMem
    FeasibilityAssessor --> LongTermMem
    ActionTracker --> SurpriseEngine
    
    ShortTermMem --> PostgreSQL
    LongTermMem --> VectorDB
    SurpriseEngine --> LongTermMem
    
    UneaseDetector --> LLMAdapter
    DesireAnalyzer --> LLMAdapter
    PathGenerator --> LLMAdapter
    FeasibilityAssessor --> LLMAdapter
    
    LLMAdapter --> DeepSeek
    LLMAdapter --> Qwen
    LLMAdapter --> DoubleBao

2. 功能模块设计

2.1 核心引擎模块

2.2 核心机制："变成用户"生成主观可行方案

graph TB
    subgraph understand [理解阶段 - 懂你]
        Profile[用户画像]
        Memory[历史记忆]
        Insight[深层洞察]
    end
    
    subgraph become [变身阶段 - 变成你]
        Persona[构建用户人格模型]
        Constraints[主观约束建模]
        Perspective[视角转换]
    end
    
    subgraph generate [生成阶段 - 替你想]
        Imagine[想象可能路径]
        Filter[用你的标准筛选]
        Feasibility[你觉得能做到吗]
    end
    
    subgraph validate [验证阶段 - 让你确认]
        Present[呈现方案]
        UserFeel[你的感受]
        Adjust[调整优化]
    end
    
    understand --> become --> generate --> validate

第一步：构建用户人格模型（Persona）

def build_user_persona(user_id):
    """
    用用户的所有信息构建一个"虚拟的他"
    """
    return {
        # 我是谁
        "identity": {
            "age_group": "middle",
            "roles": ["父亲", "经理", "儿子"],
            "career": "金融行业15年"
        },
        
        # 我怎么看世界
        "worldview": {
            "time_preference": 0.3,  # 偏长期
            "risk_tolerance": 0.4,   # 中等保守
            "core_values": ["家庭稳定", "职业成就"]
        },
        
        # 我的能力边界（主观认知）
        "perceived_capabilities": {
            "strengths": ["逻辑分析", "人脉资源"],
            "weaknesses": ["表达情感", "接受不确定"],
            "fears": ["失去稳定收入", "家人失望"]
        },
        
        # 我的历史模式
        "patterns": {
            "preferred_solutions": "渐进式，小步试错",
            "avoided_solutions": "激进变革，破釜沉舟",
            "past_successes": ["内部调岗", "谈判加薪"],
            "past_failures": ["创业尝试", "激进投资"]
        }
    }

第二步：主观约束建模

graph LR
    subgraph subjective [主观约束 - 不是客观事实]
        Time[我觉得我有多少时间]
        Money[我觉得我能承受多少损失]
        Energy[我觉得我有多少精力]
        Support[我觉得谁会支持我]
        Ability[我觉得我能学会什么]
    end
    
    subgraph fears [主观恐惧]
        F1[我怕失败后...]
        F2[我怕别人说...]
        F3[我怕万一...]
    end
    
    subjective --> Filter[方案筛选器]
    fears --> Filter

第三步：用用户的眼睛生成方案

def generate_paths_as_user(user_persona, desires):
    """
    不是生成"客观最优"方案
    而是生成"用户认为可行"的方案
    """
    
    prompt = f"""
    你现在是这个人：
        - 身份：{user_persona['identity']}
        - 价值观：{user_persona['worldview']}
        - 自我认知的能力：{user_persona['perceived_capabilities']}
        - 过去成功的方式：{user_persona['patterns']['past_successes']}
        - 过去失败的教训：{user_persona['patterns']['past_failures']}
        - 害怕的事情：{user_persona['perceived_capabilities']['fears']}
    
    他的愿望是：{desires}
    
    请用他的视角思考：
        1. 他会觉得什么路径是"我能做到的"？
        2. 什么路径会让他觉得"这不像我"？
        3. 什么是他能想象自己执行的第一步？
    
    生成3个他主观认为可行的方案，不要给他客观上最优但他做不到的方案。
    """
    
    return llm.generate(prompt)

第四步：主观可行性检验

实现代码示例

def assess_subjective_feasibility(path, user_persona):
    """
    用用户的主观标准评估可行性
    """
    
    checks = {
        "imagination": self._can_user_imagine_doing(path, user_persona),
        "first_step": self._is_first_step_clear_and_doable(path),
        "resources": self._does_user_believe_has_resources(path, user_persona),
        "risk_tolerance": self._is_risk_within_user_tolerance(path, user_persona),
        "self_consistency": self._matches_user_self_image(path, user_persona)
    }
    
    # 综合评分（用户主观可行性）
    feasibility_score = sum(checks.values()) / len(checks)
    
    # 识别障碍
    barriers = [k for k, v in checks.items() if not v]
    
    return {
        "score": feasibility_score,
        "barriers": barriers,
        "user_might_say": self._predict_user_objection(barriers, user_persona)
    }

输出示例：个性化可行方案

{
  "user_desire": "想要更有意义的工作",
  "paths": [
    {
      "name": "内部探索",
      "description": "在现公司寻找更有意义的项目或部门",
      "why_fits_you": "你过去内部调岗成功过，这是你熟悉的方式",
      "first_step": "下周找HR聊聊内部机会",
      "feasibility": {
        "score": 0.85,
        "you_can_imagine": true,
        "matches_your_style": "渐进式，低风险"
      }
    },
    {
      "name": "副业试水",
      "description": "保持现工作，业余做有意义的事",
      "why_fits_you": "不用放弃稳定收入，符合你'家庭稳定'的核心价值",
      "first_step": "这周末花2小时想想你关心什么议题",
      "feasibility": {
        "score": 0.75,
        "you_can_imagine": true,
        "barrier": "你可能担心没时间，但可以从每周2小时开始"
      }
    },
    {
      "name": "跳槽到使命驱动公司",
      "description": "寻找有社会使命的公司",
      "why_might_hesitate": "这需要较大改变，你过去倾向渐进式",
      "first_step": "先看看市场上有哪些这类公司，不用马上行动",
      "feasibility": {
        "score": 0.5,
        "barrier": "风险较高，可能触发你'怕失去稳定收入'的担忧",
        "if_you_want_this": "可以先内部尝试，保留这个作为长期选项"
      }
    }
  ]
}

2.3 记忆系统模块

sequenceDiagram
    participant User as 用户
    participant Engine as 核心引擎
    participant STM as 短期记忆
    participant LTM as 长期记忆
    participant Surprise as 惊喜检测
    
    User->>Engine: 输入当前状态
    Engine->>STM: 处理当前输入
    Engine->>LTM: 检索历史模式
    LTM-->>Engine: 返回相关记忆
    Engine->>Surprise: 计算惊喜度
    
    alt 高惊喜度
        Surprise->>LTM: 优先更新记忆权重
    else 低惊喜度
        Surprise->>LTM: 常规衰减更新
    end
    
    Engine-->>User: 返回分析结果

2.4 MCP工具接口定义

{
  "tools": [
    {
      "name": "dig_uneasiness",
      "description": "深度挖掘用户主观不舒适，返回表面和隐藏层面",
      "parameters": {
        "user_input": "string - 用户描述的当前状态",
        "user_id": "string - 用户唯一标识"
      }
    },
    {
      "name": "analyze_desires",
      "description": "分析愿望层次、冲突和优先级排序",
      "parameters": {
        "uneasiness_result": "object - 不舒适分析结果",
        "user_id": "string"
      }
    },
    {
      "name": "generate_paths",
      "description": "生成个性化改变路径选项",
      "parameters": {
        "desires": "object - 愿望分析结果",
        "user_id": "string",
        "max_options": "integer - 最大选项数，默认5"
      }
    },
    {
      "name": "assess_feasibility",
      "description": "评估各路径的可行性、机会成本、时间偏好",
      "parameters": {
        "paths": "array - 路径选项列表",
        "user_profile": "object - 用户主观档案",
        "user_id": "string"
      }
    },
    {
      "name": "track_action",
      "description": "记录行动结果，触发记忆更新",
      "parameters": {
        "action_id": "string - 行动标识",
        "result": "string - 行动结果描述",
        "satisfaction": "integer - 满意度1-10",
        "user_id": "string"
      }
    },
    {
      "name": "update_memory",
      "description": "手动更新用户主观档案",
      "parameters": {
        "user_id": "string",
        "profile_updates": "object - 档案更新内容"
      }
    }
  ]
}

3. 数据模型设计

3.1 PostgreSQL 表结构

-- 用户画像（静态+动态）
CREATE TABLE user_profiles (
    user_id UUID PRIMARY KEY,
    
    -- 基础属性（可选填，通过对话逐步推断）
    gender VARCHAR(10),             -- 性别
    age_group VARCHAR(20),          -- 年龄段: child/teen/youth/middle/elder
    
    -- 角色标签（多角色）
    family_roles JSONB,             -- 家庭角色: ["父亲", "儿子", "丈夫"]
    career_info JSONB,              -- 职业信息: {"industry": "IT", "role": "工程师"}
    
    -- 米塞斯核心参数（通过行为推断，持续更新）
    time_preference FLOAT,          -- 时间偏好: 0=长期导向, 1=即时满足
    risk_tolerance FLOAT,           -- 风险承受: 0=保守, 1=激进
    core_values JSONB,              -- 价值排序: ["家庭", "事业", "健康", "自由"]
    
    -- 沟通偏好（影响输出风格）
    communication_style VARCHAR(20), -- direct/gentle/analytical/emotional
    
    -- 元数据
    profile_completeness FLOAT,     -- 画像完整度 0-1
    last_interaction TIMESTAMP,
    created_at TIMESTAMP,
    updated_at TIMESTAMP
);

-- 行为历史（TITANS长期记忆的结构化存储）
CREATE TABLE behavior_history (
    id SERIAL PRIMARY KEY,
    user_id UUID REFERENCES user_profiles,
    
    -- 米塞斯序列记录
    uneasiness_surface TEXT,        -- 表面不舒适
    uneasiness_hidden JSONB,        -- 深层不舒适
    desires JSONB,                  -- 愿望分析
    paths_generated JSONB,          -- 生成的路径
    chosen_path TEXT,               -- 选择的路径
    action_result TEXT,             -- 行动结果
    satisfaction INTEGER,           -- 满意度 1-10
    
    -- 上下文标签
    life_domain VARCHAR(50),        -- 领域: career/family/health/finance/relationship
    trigger_context JSONB,          -- 触发情境: {"time": "晚上", "mood": "疲惫"}
    
    -- TITANS记忆参数
    surprise_score FLOAT,           -- 惊喜度
    memory_tier VARCHAR(20),        -- short_term/long_term/archive
    
    created_at TIMESTAMP
);

-- 会话上下文
CREATE TABLE session_context (
    session_id UUID PRIMARY KEY,
    user_id UUID REFERENCES user_profiles,
    current_stage VARCHAR(50),
    context_data JSONB,
    expires_at TIMESTAMP
);

-- 用户洞察（AI推断的深层理解）
CREATE TABLE user_insights (
    id SERIAL PRIMARY KEY,
    user_id UUID REFERENCES user_profiles,
    insight_type VARCHAR(50),       -- pattern/preference/conflict/growth
    insight_content TEXT,           -- 洞察内容
    confidence FLOAT,               -- 置信度
    evidence_ids INTEGER[],         -- 支撑的behavior_history.id
    created_at TIMESTAMP
);

3.2 用户画像JSON结构

{
  "user_id": "user_001",
  "profile": {
    "gender": "male",
    "age_group": "middle",
    "family_roles": ["父亲", "丈夫", "儿子"],
    "career": {"industry": "金融", "role": "经理", "years": 15}
  },
  "mises_params": {
    "time_preference": 0.3,
    "risk_tolerance": 0.4,
    "core_values": ["家庭稳定", "职业成就", "健康"]
  },
  "insights": [
    {"type": "pattern", "content": "工作压力常在季度末爆发"},
    {"type": "conflict", "content": "事业成功 vs 陪伴家人 长期冲突"},
    {"type": "preference", "content": "倾向渐进式改变，不喜欢激进方案"}
  ],
  "communication": {
    "style": "analytical",
    "preferred_depth": "deep"
  }
}

3.3 向量数据库存储

• 用途：存储用户历史行为的语义向量，支持相似场景检索
• 方案：PostgreSQL + pgvector 扩展
• 向量内容：不舒适向量、愿望向量、路径模式向量

3.4 "懂用户"核心机制

graph TB
    subgraph input [用户输入]
        CurrentInput[当前不舒适表达]
    end
    
    subgraph understand [三层理解机制]
        L1[层1: 静态画像<br/>性别/年龄/角色/职业]
        L2[层2: 动态记忆<br/>历史不舒适/愿望/行动结果]
        L3[层3: 深层洞察<br/>模式/冲突/偏好]
    end
    
    subgraph personalize [个性化处理]
        Context[情境感知]
        Retrieve[相似经历检索]
        Adapt[风格适配]
    end
    
    subgraph output [个性化输出]
        Response[懂你的回应]
    end
    
    CurrentInput --> L1 & L2 & L3
    L1 & L2 & L3 --> Context
    Context --> Retrieve --> Adapt --> Response

层1: 静态画像 - 我是谁

层2: 动态记忆 - 我经历过什么

# TITANS记忆检索
def understand_user(current_input, user_id):
    # 检索相似历史经历
    similar_experiences = titans.retrieve(
        query=current_input,
        user_id=user_id,
        top_k=5
    )
    
    # 例如：用户说"工作压力大"
    # 系统检索到：
    # - 3个月前也说过压力大，后来选择了休假，效果好
    # - 1年前压力大时想跳槽，但最后没跳，后悔了
    # - 每次季度末都会压力大（模式识别）
    
    return similar_experiences

层3: 深层洞察 - 我真正想要什么

{
  "insights": [
    {
      "type": "pattern",
      "content": "每次说'压力大'，深层都是'缺乏掌控感'",
      "confidence": 0.85
    },
    {
      "type": "conflict",
      "content": "长期在'高薪稳定' vs '自由有意义'之间挣扎",
      "confidence": 0.9
    },
    {
      "type": "preference",
      "content": "不喜欢激进方案，偏好小步试错",
      "confidence": 0.8
    },
    {
      "type": "growth",
      "content": "比1年前更重视家庭，时间偏好在降低",
      "confidence": 0.75
    }
  ]
}

个性化响应示例

画像渐进式构建

graph LR
    First[首次对话<br/>画像空白] --> Infer[推断基础信息<br/>性别/年龄/角色]
    Infer --> Accumulate[积累行为数据<br/>不舒适/愿望/结果]
    Accumulate --> Pattern[识别模式<br/>生成洞察]
    Pattern --> Deep[深度理解<br/>懂你的心]

关键：不强制填表，通过对话自然推断

# 对话中推断用户信息
def infer_profile_from_conversation(text):
    # "我儿子今年高考" → 推断：中年，父亲角色
    # "我们部门KPI" → 推断：企业员工
    # "我老婆说我..." → 推断：已婚，男性可能性高
    # "退休后闲着没事" → 推断：老年
    pass

4. 技术实现方案

4.1 项目结构

mises-behavior-engine/
├── docker-compose.yml
├── Dockerfile
├── requirements.txt
├── src/
│   ├── __init__.py
│   ├── main.py                    # FastAPI入口
│   ├── config.py                  # 配置管理
│   ├── core/                      # 核心引擎
│   │   ├── __init__.py
│   │   ├── uneasiness.py          # 不舒适挖掘
│   │   ├── desires.py             # 愿望分析
│   │   ├── paths.py               # 路径生成
│   │   ├── feasibility.py         # 可行性评估
│   │   ├── tracker.py             # 行动跟踪
│   │   └── predictor.py           # 循环预测
│   ├── memory/                    # 记忆系统
│   │   ├── __init__.py
│   │   ├── short_term.py          # 短期记忆
│   │   ├── long_term.py           # 长期记忆
│   │   └── surprise.py            # 惊喜检测
│   ├── llm/                       # LLM抽象层
│   │   ├── __init__.py
│   │   ├── base.py                # 基础接口
│   │   ├── deepseek.py
│   │   ├── qwen.py
│   │   └── doubao.py
│   ├── mcp/                       # MCP服务
│   │   ├── __init__.py
│   │   ├── server.py              # MCP Server
│   │   └── tools.py               # 工具注册
│   ├── storage/                   # 存储层
│   │   ├── __init__.py
│   │   ├── postgres.py
│   │   └── vector.py
│   └── schemas/                   # 数据模型
│       ├── __init__.py
│       └── models.py
├── training/                      # TITANS训练
│   ├── synthetic_data/            # 合成数据生成
│   │   ├── generator.py
│   │   └── prompts/
│   ├── titans/                    # TITANS记忆模块训练
│   │   └── train_memory.py
│   └── datasets/                  # 数据集
└── tests/
    └── ...

4.2 技术栈

4.3 LLM部署方式（调用外部API）

graph LR
    subgraph mbe [MBE服务]
        Engine[核心引擎]
        Adapter[LLM适配器]
    end
    
    subgraph api [外部LLM API]
        DeepSeek[DeepSeek API]
        Qwen[Qwen API]
        Doubao[豆包 API]
    end
    
    Engine --> Adapter
    Adapter -->|HTTP| DeepSeek
    Adapter -->|HTTP| Qwen
    Adapter -->|HTTP| Doubao

配置示例：

llm:
  provider: deepseek  # 或 qwen / doubao
  api_key: ${LLM_API_KEY}
  model: deepseek-chat
  temperature: 0.7

4.4 渐进式扩展架构（A → B → C）

graph TB
    subgraph phaseA [阶段A: 小型 50-100并发]
        A_LB[单实例]
        A_MBE[MBE x1]
        A_PG[(PostgreSQL)]
        A_Redis[(Redis)]
        A_LB --> A_MBE --> A_PG
        A_MBE --> A_Redis
    end
    
    subgraph phaseB [阶段B: 中型 100-500并发]
        B_LB[Nginx负载均衡]
        B_MBE1[MBE x1]
        B_MBE2[MBE x2]
        B_MBE3[MBE x3]
        B_PG[(PostgreSQL<br/>主从复制)]
        B_Redis[(Redis)]
        B_LB --> B_MBE1 & B_MBE2 & B_MBE3
        B_MBE1 & B_MBE2 & B_MBE3 --> B_PG
        B_MBE1 & B_MBE2 & B_MBE3 --> B_Redis
    end
    
    subgraph phaseC [阶段C: 大型 500+并发]
        C_LB[Traefik/K8s Ingress]
        C_MBE[MBE x N<br/>自动扩缩]
        C_PG[(PostgreSQL集群)]
        C_Redis[(Redis集群)]
        C_LB --> C_MBE --> C_PG
        C_MBE --> C_Redis
    end

4.5 阶段A：单实例部署

# docker-compose.yml（阶段A）
version: '3.8'
services:
  mbe-api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://mbe:password@postgres:5432/mbe
      - REDIS_URL=redis://redis:6379
      - LLM_PROVIDER=deepseek
      - LLM_API_KEY=${LLM_API_KEY}
    depends_on:
      - postgres
      - redis

  postgres:
    image: pgvector/pgvector:pg16
    environment:
      - POSTGRES_USER=mbe
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=mbe
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:alpine
    volumes:
      - redisdata:/data

volumes:
  pgdata:
  redisdata:

4.6 阶段B：多实例扩展

# docker-compose.yml（阶段B）
version: '3.8'
services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - mbe-api-1
      - mbe-api-2
      - mbe-api-3

  mbe-api-1:
    build: .
    environment:
      - LLM_API_KEY=${LLM_API_KEY_1}
      # ... 其他配置
  
  mbe-api-2:
    build: .
    environment:
      - LLM_API_KEY=${LLM_API_KEY_2}
  
  mbe-api-3:
    build: .
    environment:
      - LLM_API_KEY=${LLM_API_KEY_3}

  postgres:
    image: pgvector/pgvector:pg16
    # 可升级为主从复制

  redis:
    image: redis:alpine
    # 会话共享，支持多实例

4.7 阶段C：Kubernetes部署

# k8s/deployment.yaml（阶段C示意）
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mbe-api
spec:
  replicas: 5  # 可自动扩缩
  selector:
    matchLabels:
      app: mbe-api
  template:
    spec:
      containers:
        - name: mbe-api
          image: mbe:latest
          resources:
            requests:
              cpu: "500m"
              memory: "512Mi"
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: mbe-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: mbe-api
  minReplicas: 3
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          averageUtilization: 70

4.8 扩展关键点

5. TITANS+MIRAS 架构与模型训练

5.1 架构概述

TITANS（Training at Test Time with Attention for Neural Memory Systems）+ MIRAS（Memory, Attention, Retention, Algorithmic Selection）是 Google 在 NeurIPS 2025 发布的新一代记忆增强架构：

• 突破传统 Transformer 限制：支持超过 200 万 Token 上下文
• 推理时实时学习：Test-time 动态更新记忆
• 三层记忆架构：短期 → 长期 → 归档
• 惊喜驱动更新：只记住"重要"变化

graph TB
    subgraph titans [TITANS架构]
        Input[用户输入] --> Encoder[编码器]
        
        subgraph memory [三层记忆系统]
            STM[短期记忆<br/>Attention]
            LTM[长期记忆<br/>神经网络MLP]
            Archive[归档记忆]
        end
        
        Encoder --> STM
        STM --> SurpriseCalc[惊喜度计算]
        SurpriseCalc -->|高惊喜| LTM
        SurpriseCalc -->|低惊喜| Decay[衰减遗忘]
        LTM --> Archive
        
        subgraph miras [MIRAS框架]
            Momentum[动量更新]
            Forgetting[遗忘门]
            Retention[保留机制]
        end
        
        SurpriseCalc --> Momentum
        Momentum --> LTM
        LTM --> Forgetting
    end
    
    memory --> Output[输出]

5.2 HOPE 神经记忆模型配置

基于 MCP-TITAN 项目的 HOPE（Hierarchical Online Predictive Encoding）模型：

{
  "name": "init_model",
  "arguments": {
    "inputDim": 768,              
    "hiddenDim": 512,             
    "memoryDim": 1024,            
    "transformerLayers": 6,       
    "numHeads": 8,                
    "ffDimension": 2048,          
    "dropoutRate": 0.1,           
    "maxSequenceLength": 512,     
    "memorySlots": 10000,         
    "similarityThreshold": 0.7,   
    "surpriseDecay": 0.85,        
    "pruningInterval": 1000,      
    "gradientClip": 1.0           
  }
}

5.3 训练流程（TITANS 专属）

graph LR
    subgraph p1 [阶段1]
        TeacherLLM[教师LLM] --> SynData[合成数据]
    end
    
    subgraph p2 [阶段2]
        SynData --> MemPretrain[记忆模块预训练]
        MemPretrain --> SurpriseTrain[惊喜检测校准]
    end
    
    subgraph p3 [阶段3]
        SurpriseTrain --> E2E[LLM+TITANS联合训练]
        E2E --> Model[米塞斯模型]
    end
    
    subgraph p4 [阶段4]
        Model --> TestTime[推理时学习]
    end

5.4 合成数据格式（TITANS 训练专用）

{
  "sequence": [
    {
      "stage": "uneasiness",
      "input": "我最近工作压力很大",
      "memory_update": {"type": "episodic", "surprise_expected": 0.3}
    },
    {
      "stage": "desires", 
      "input": "想要更多自由时间和意义感",
      "memory_update": {"type": "semantic", "surprise_expected": 0.6}
    },
    {
      "stage": "paths",
      "options": ["内部转岗", "跳槽", "副业"],
      "memory_retrieval": "similar_past_decisions"
    },
    {
      "stage": "action_feedback",
      "result": "副业成功",
      "surprise_actual": 0.9,
      "memory_update": "promote_to_long_term"
    }
  ]
}

5.5 训练步骤

Step 1: 记忆模块预训练

# MCP-TITAN 训练接口
{
  "name": "train_step",
  "arguments": {
    "x_t": "用户描述当前不舒适状态",
    "x_next": "期望的愿望分析输出"
  }
}

Step 2: Test-time Learning（推理时学习）

def inference_with_learning(user_input, user_id):
    memories = titans.retrieve_memory(user_input, user_id)
    response = engine.process(user_input, memories)
    surprise = titans.calculate_surprise(user_input, memories)
    
    if surprise > threshold:
        titans.store_memory(user_input, user_id=user_id)
        if surprise > high_threshold:
            titans.promote_to_long_term(user_id)
    
    return response

5.6 技术实现选择

6. 架构模式：纯MCP（有状态）

6.1 核心原则

MBE = 有状态的 MCP 工具服务，小智零改动

• 不是 Agent，是 MCP 工具
• 通过 session_id 管理多轮会话状态
• 序列流转完全在 MBE 内部控制
• 小智只负责传递用户输入和输出响应

graph LR
    subgraph xiaozhi [小智 - 零改动]
        Voice[语音IO]
        LLM[小智LLM]
        MCP[MCP客户端]
    end
    
    subgraph mbe [MBE - 有状态MCP服务]
        Server[MCP Server]
        Session[会话管理器]
        Logic[米塞斯逻辑]
        TITANS[TITANS记忆]
        LLMAPI[LLM API调用]
    end
    
    Voice --> LLM --> MCP
    MCP -->|session_id| Server
    Server --> Session
    Session --> Logic
    Logic --> TITANS
    Logic --> LLMAPI
    Server --> MCP --> LLM --> Voice

6.2 会话状态管理

sequenceDiagram
    participant U as 用户
    participant X as 小智
    participant M as MBE
    participant S as 会话存储
    
    U->>X: "工作压力大"
    X->>M: mises_analyze(input, device_id)
    M->>S: 创建会话 session_123
    M->>M: 阶段=uneasiness，分析
    M-->>X: {speech:"...", session_id:"123", stage:"uneasiness"}
    X->>U: 语音输出
    
    U->>X: "是的，继续"
    X->>M: mises_analyze(input, device_id)
    M->>S: 查找会话 session_123
    M->>M: 阶段=desires，继续分析
    M-->>X: {speech:"...", session_id:"123", stage:"desires"}
    X->>U: 语音输出
    
    Note over M,S: 会话超时后自动清理

会话状态结构：

{
  "session_id": "abc123",
  "identity": {
    "user_id": "user_001",
    "device_id": "device_001",
    "combined_id": "user_001:device_001"
  },
  "current_stage": "desires",
  "stages_completed": ["uneasiness"],
  "context": {
    "uneasiness": {"surface": "工作压力大", "hidden": ["意义感缺失"]},
    "desires": null,
    "paths": null,
    "assessment": null
  },
  "created_at": "2026-01-03T10:00:00Z",
  "expires_at": "2026-01-03T10:30:00Z"
}

6.3 用户识别：灵活适配方案

问题：小智MCP配置层级待确认（设备级/账号级/平台级）

解决方案：MBE支持多种识别模式，通过配置切换

# config.yaml
identity:
  mode: auto  # auto / device / user / combined
  # auto: 自动检测（优先user_id，fallback到device_id）
  # device: 仅用device_id（每设备独立记忆）
  # user: 仅用user_id（同账号共享记忆）
  # combined: user_id + device_id（最精确）

MCP工具参数设计（兼容所有层级）：

{
  "name": "mises_analyze",
  "parameters": {
    "user_input": "string - 用户输入",
    "device_id": "string - 设备ID（必传）",
    "user_id": "string - 用户ID（可选，如小智能提供）"
  }
}

MBE内部处理逻辑：

def get_identity(device_id, user_id=None):
    if config.identity.mode == "device":
        return device_id
    elif config.identity.mode == "user":
        return user_id or device_id  # fallback
    elif config.identity.mode == "combined":
        return f"{user_id or 'unknown'}:{device_id}"
    else:  # auto
        return user_id if user_id else device_id

待确认事项：

• 确认小智MCP配置层级（查阅xiaozhi.me文档或实测）
• 确认小智调用MCP时是否传递user_id
• 根据确认结果设置identity.mode

6.4 职责划分

6.5 MCP工具设计（有状态+灵活识别）

{
  "tools": [
    {
      "name": "mises_analyze",
      "description": "米塞斯行为分析引擎。当用户表达不舒适、困惑、决策困难、纠结、压力、想改变等情况时调用。支持多轮对话，自动管理会话状态和序列流转。",
      "parameters": {
        "user_input": "string - 用户原始输入",
        "device_id": "string - 设备ID（必传）",
        "user_id": "string - 用户ID（可选）"
      }
    },
    {
      "name": "mises_feedback",
      "description": "记录行动结果反馈。当用户报告之前决策的执行结果时调用。",
      "parameters": {
        "device_id": "string - 设备ID",
        "user_id": "string - 用户ID（可选）",
        "action_result": "string - 结果描述",
        "satisfaction": "integer - 满意度1-10"
      }
    }
  ]
}

6.6 返回格式（有状态）

{
  "speech_output": "我注意到你说工作压力大。分析发现：表面是工作量问题，深层可能涉及对意义的追求和时间自由的渴望。你觉得准确吗？要继续探索改变路径吗？",
  "session": {
    "id": "sess_abc123",
    "stage": "uneasiness",
    "next_stage": "desires",
    "is_complete": false
  },
  "await_response": true
}

小智只需读取 speech_output 直接语音输出。

会话生命周期：

• 新对话自动创建会话
• 同一 device_id 的后续输入自动关联到活跃会话
• 会话超时（30分钟无活动）自动清理
• 序列完成后会话标记为 is_complete: true

7. 序列流转控制（MBE内部）

7.1 触发模式（小智LLM自动判断）

小智LLM通过以下方式智能判断何时调用MBE：

graph TD
    UserInput[用户输入] --> Classifier[意图分类器]
    
    Classifier --> Explicit{显式触发?}
    Explicit -->|是| TriggerMBE[调用MBE]
    
    Explicit -->|否| Keyword{关键词匹配?}
    Keyword -->|是| TriggerMBE
    
    Keyword -->|否| Implicit{隐式检测?}
    Implicit -->|决策场景| TriggerMBE
    Implicit -->|非决策场景| NormalChat[普通对话]
    
    TriggerMBE --> StageRouter[阶段路由器]

7.2 灵活流转（MBE内部控制）

根据场景复杂度决定是否自动继续下一阶段：

stateDiagram-v2
    [*] --> Uneasiness: 触发MBE
    
    Uneasiness --> ComplexityCheck1: 完成不舒适挖掘
    ComplexityCheck1 --> Desires: 简单场景-自动继续
    ComplexityCheck1 --> ConfirmDesires: 复杂场景-询问确认
    ConfirmDesires --> Desires: 用户确认
    ConfirmDesires --> [*]: 用户取消
    
    Desires --> ComplexityCheck2: 完成愿望分析
    ComplexityCheck2 --> Paths: 简单场景-自动继续
    ComplexityCheck2 --> ConfirmPaths: 复杂场景-询问确认
    ConfirmPaths --> Paths: 用户确认
    
    Paths --> Assessment: 完成路径生成
    Assessment --> Action: 用户选择路径
    Action --> Feedback: 行动执行
    Feedback --> [*]: 循环结束或新不舒适

复杂度判断标准：

• 简单场景：单一不舒适、明确愿望、路径少于3个
• 复杂场景：多重不舒适、愿望冲突、涉及重大决策

7.3 内部调用规则

{
  "trigger_rules": {
    "dig_uneasiness": {
      "auto_trigger": true,
      "conditions": ["explicit_command", "keyword_match", "implicit_detection"]
    },
    "analyze_desires": {
      "auto_trigger": "conditional",
      "simple_scene": true,
      "complex_scene": "ask_confirmation"
    },
    "generate_paths": {
      "auto_trigger": "conditional",
      "requires": "desires_completed"
    },
    "assess_feasibility": {
      "auto_trigger": true,
      "requires": "paths_generated"
    },
    "track_action": {
      "auto_trigger": false,
      "requires": "user_reports_result"
    }
  }
}

8. 小智MCP接入流程

8.1 接入步骤（极简）

1. 部署MBE Docker服务，暴露MCP端点
2. 登录 xiaozhi.me/console
3. 在MCP管理页面添加自定义服务URL
4. 配置工具manifest（JSON格式）
5. 测试语音调用

8.2 交互示例

用户语音: "我最近工作压力大"
     ↓
[隐式检测] 小智LLM识别到决策场景
     ↓
调用MCP: dig_uneasiness("工作压力大", user_id)
     ↓
MBE返回: {
  "surface": "工作压力大",
  "hidden": ["意义感缺失", "时间自由受限"],
  "urgency": 8,
  "complexity": "medium"
}
     ↓
[灵活模式] 复杂度中等，询问用户
小智: "我发现你的压力可能不只是工作量，还涉及意义感和时间自由。要继续深入分析吗？"
     ↓
用户: "好的，帮我分析"
     ↓
调用MCP: analyze_desires(uneasiness_result, user_id)
     ↓
MBE返回: {
  "primary_desire": "获得工作意义感",
  "secondary_desires": ["更多自由时间", "收入稳定"],
  "conflicts": ["意义感 vs 收入稳定"]
}
     ↓
调用MCP: generate_paths(desires, user_id)
     ↓
小智语音输出: "根据分析，你有3个可能的路径：A.内部转岗寻找更有意义的项目 B.跳槽到使命驱动的公司 C.保持现状但发展副业..."

9. 质量评判标准

9.1 三层评判体系

graph LR
    L1[层1: 技术指标<br/>能用/稳定/快] --> L2[层2: 理解准确性<br/>懂对了吗] --> L3[层3: 行为效果<br/>有用吗]

9.2 核心指标定义

9.3 "懂你"指数计算

懂你指数 = 不舒适命中率×0.3 + 愿望识别率×0.2 + 
          方案采纳率×0.2 + 行动满意度/10×0.2 + 复用率×0.1

9.4 数据采集方式

隐式采集（自动）：

class DialogLog:
    session_id: str
    user_id: str
    response_time_ms: int           # 响应时间
    stages_completed: list          # 完成的阶段
    path_chosen: str                # 用户选择的方案
    user_confirmations: int         # 用户说"对"的次数
    user_corrections: int           # 用户说"不对"的次数

显式采集（对话中自然询问）：

┌─────────────────────────────────────────────┐
│ 采集点1：不舒适挖掘确认                      │
├─────────────────────────────────────────────┤
│ 引擎: 我感觉你的压力不只是工作量，           │
│      更深层是对意义的追求。对吗？            │
│                                             │
│ 用户: 对 → 记录 confirmed=true              │
│ 用户: 不是 → 记录 confirmed=false, 继续挖掘 │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 采集点2：方案选择                            │
├─────────────────────────────────────────────┤
│ 引擎: 有3个可能路径：A/B/C，哪个更接近你想要的？│
│                                             │
│ 用户: A吧 → 记录 path_chosen="A"            │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ 采集点3：下次对话回访                        │
├─────────────────────────────────────────────┤
│ 引擎: 上次你说要找HR聊聊，后来怎么样了？     │
│                                             │
│ 用户: 聊了 → 记录 first_step_done=true      │
│ 用户: 还没 → 记录 false, 探讨阻碍           │
└─────────────────────────────────────────────┘

9.5 数据存储

-- 对话质量记录
CREATE TABLE dialog_quality (
    id SERIAL PRIMARY KEY,
    session_id UUID,
    user_id UUID,
    uneasiness_confirmed BOOLEAN,
    desires_confirmed BOOLEAN,
    path_chosen VARCHAR(100),
    session_helpful BOOLEAN,
    created_at TIMESTAMP
);

-- 行动跟踪
CREATE TABLE action_tracking (
    id SERIAL PRIMARY KEY,
    user_id UUID,
    original_session_id UUID,
    first_step_done BOOLEAN,
    satisfaction INTEGER,
    tracked_at TIMESTAMP
);

9.6 质量看板

┌─────────────────────────────────────┐
│      米塞斯引擎质量看板              │
├─────────────────────────────────────┤
│  懂你指数: 0.72 (良好)              │
├─────────────────────────────────────┤
│  不舒适命中率: 73% ████████░░       │
│  愿望识别率:   78% ████████░░       │
│  方案采纳率:   55% ██████░░░░       │
│  行动满意度:   7.2 ████████░░       │
│  复用率:       65% ███████░░░       │
├─────────────────────────────────────┤
│  本周对话: 1,234  活跃用户: 456     │
└─────────────────────────────────────┘

10. 用户管理与计费系统

10.1 用户注册渠道

graph TB
    subgraph channels [注册渠道]
        Direct[直接注册<br/>Web/App]
        XiaoZhi[小智平台<br/>设备绑定]
        ThirdParty[第三方平台<br/>OAuth]
    end
    
    subgraph mbe [MBE用户系统]
        UserDB[(用户数据库)]
        Auth[认证服务]
        Bindng[账号绑定]
    end
    
    Direct --> Auth
    XiaoZhi --> Bindng
    ThirdParty --> Auth
    Auth --> UserDB
    Bindng --> UserDB

10.2 用户数据模型

-- 用户账号
CREATE TABLE users (
    user_id UUID PRIMARY KEY,
    phone VARCHAR(20),
    email VARCHAR(100),
    password_hash VARCHAR(255),
    
    -- 注册来源
    register_channel VARCHAR(50),   -- direct/xiaozhi/wechat/...
    register_device_id VARCHAR(100),
    
    -- 账号状态
    status VARCHAR(20),             -- active/suspended/deleted
    created_at TIMESTAMP,
    updated_at TIMESTAMP
);

-- 第三方账号绑定
CREATE TABLE user_bindings (
    id SERIAL PRIMARY KEY,
    user_id UUID REFERENCES users,
    platform VARCHAR(50),           -- xiaozhi/wechat/alipay
    platform_user_id VARCHAR(100),  -- 第三方平台用户ID
    bindng_data JSONB,              -- 额外绑定信息
    created_at TIMESTAMP,
    UNIQUE(platform, platform_user_id)
);

-- 设备绑定
CREATE TABLE user_devices (
    id SERIAL PRIMARY KEY,
    user_id UUID REFERENCES users,
    device_id VARCHAR(100),
    device_type VARCHAR(50),        -- xiaozhi/app/web
    last_active TIMESTAMP,
    created_at TIMESTAMP
);

10.3 小智自动注册流程

sequenceDiagram
    participant X as 小智设备
    participant M as MBE
    participant DB as 用户数据库
    
    X->>M: mises_analyze(input, device_id)
    M->>DB: 查询 device_id 是否已绑定用户
    
    alt 新设备
        M->>DB: 创建匿名用户 + 绑定设备
        DB-->>M: 返回 user_id
    else 已绑定
        DB-->>M: 返回已有 user_id
    end
    
    M->>M: 使用 user_id 处理请求
    M-->>X: 返回结果

10.4 计费模式

graph LR
    subgraph models [计费模式]
        Free[免费版<br/>基础功能]
        Sub[订阅版<br/>按月/年]
        PayAsGo[按量付费<br/>按对话次数]
        Enterprise[企业版<br/>定制]
    end

10.5 计费数据模型

-- 用户套餐
CREATE TABLE user_subscriptions (
    id SERIAL PRIMARY KEY,
    user_id UUID REFERENCES users,
    plan_type VARCHAR(50),          -- free/personal/pro/enterprise
    
    -- 订阅周期
    start_date DATE,
    end_date DATE,
    auto_renew BOOLEAN,
    
    -- 支付信息
    payment_method VARCHAR(50),
    last_payment_at TIMESTAMP,
    
    status VARCHAR(20),             -- active/expired/cancelled
    created_at TIMESTAMP
);

-- 使用量统计
CREATE TABLE usage_records (
    id SERIAL PRIMARY KEY,
    user_id UUID REFERENCES users,
    
    -- 使用详情
    date DATE,
    dialog_count INTEGER,           -- 对话次数
    llm_tokens_used INTEGER,        -- LLM token消耗
    
    -- 计费
    cost_usd DECIMAL(10,4),         -- 成本
    
    created_at TIMESTAMP
);

-- 充值/支付记录
CREATE TABLE payment_records (
    id SERIAL PRIMARY KEY,
    user_id UUID REFERENCES users,
    
    amount DECIMAL(10,2),
    currency VARCHAR(10),
    payment_method VARCHAR(50),     -- wechat/alipay/card
    
    -- 第三方支付
    transaction_id VARCHAR(100),
    
    status VARCHAR(20),             -- pending/success/failed
    created_at TIMESTAMP
);

10.6 配额控制

class QuotaManager:
    def check_quota(self, user_id: str) -> bool:
        """检查用户是否还有配额"""
        user = get_user(user_id)
        plan = user.subscription.plan_type
        
        if plan == "free":
            today_usage = get_today_usage(user_id)
            return today_usage.dialog_count < 5
        
        elif plan in ["personal", "pro"]:
            return user.subscription.status == "active"
        
        elif plan == "enterprise":
            return True  # 无限制
    
    def record_usage(self, user_id: str, tokens: int):
        """记录使用量"""
        update_usage(user_id, dialog_count=1, tokens=tokens)

10.7 API认证

# MCP调用认证流程
def authenticate_request(device_id: str, api_key: str = None):
    """
    支持两种认证方式：
    1. device_id 自动关联用户（小智场景）
    2. api_key 直接认证（开发者场景）
    """
    
    if api_key:
        # API Key认证
        user = get_user_by_api_key(api_key)
    else:
        # 设备自动认证
        user = get_or_create_user_by_device(device_id)
    
    # 检查配额
    if not quota_manager.check_quota(user.user_id):
        raise QuotaExceededError("配额已用完")
    
    return user

10.8 管理后台功能

11. 知识库与专家系统 🆕

11.1 系统架构

graph TB
    subgraph upload [文档上传层]
        PDF[PDF上传]
        Batch[批量上传]
        Chunk[断点续传]
    end
    
    subgraph process [处理层]
        Extract[文本提取]
        Authority[权威性评估]
        Chunking[智能分块]
        Embed[向量嵌入]
        TITANS[TITANS增强]
    end
    
    subgraph storage [存储层]
        KB[(知识库)]
        Vector[(向量索引)]
        Expert[(专家配置)]
    end
    
    subgraph query [查询层]
        Router[专家路由]
        RAG[TITANS RAG]
        LLM[LLM生成]
    end
    
    PDF --> Extract
    Batch --> Extract
    Chunk --> Extract
    Extract --> Authority
    Authority --> Chunking
    Chunking --> Embed
    Embed --> TITANS
    TITANS --> KB
    TITANS --> Vector
    KB --> Expert
    
    Expert --> Router
    Router --> RAG
    RAG --> Vector
    RAG --> LLM

11.2 PDF权威性评估 🆕

上传PDF时自动评估内容可信度：

评估维度：

权威性等级：

代码实现：src/knowledge/authority_evaluator.py

11.3 批量上传与断点续传 🆕

支持大规模知识库建设：

批量上传：

• 支持一次选择多个文件
• 支持整个文件夹上传
• 支持拖拽上传
• 后台异步处理

断点续传：

• 适用于100MB以上大文件
• 分块大小：5MB
• 支持上传中断后恢复
• 上传进度实时显示

11.4 动态专家系统

支持基于知识库动态创建专家：

# 发布专家流程
1. 上传PDF → 自动提取文本
2. 权威性评估 → 显示评分
3. 智能分块 → 向量化
4. AI分析 → 自动生成专家建议
5. 填写专家信息 → 发布

专家匹配算法：

def match_expert(question):
    # 1. 关键词匹配 (40%)
    keyword_score = match_keywords(question, expert.keywords)
    
    # 2. 语义相似度 (40%)
    semantic_score = cosine_similarity(
        embed(question), 
        embed(expert.description)
    )
    
    # 3. 领域权重 (20%)
    domain_score = match_domain(question, expert.domains)
    
    return 0.4 * keyword_score + 0.4 * semantic_score + 0.2 * domain_score

11.5 TITANS RAG增强检索 🆕

相比传统RAG的优势：

代码实现：src/knowledge/titans_rag.py

11.6 专家服务架构 🆕

所有专家服务统一使用基类：

# BaseExpertService 提供：
- 知识库加载
- 向量检索
- TITANS记忆增强
- 提示词构建
- 置信度评估
- 来源引用

# BaseExpertServiceWithRisk 额外提供：
- 健康风险检测
- 免责声明

已迁移专家模块（V2版本）：

• 手工面包大师
• 美国饮食文化专家
• 日本饮食文化专家
• 现代主义烹饪大师
• 美食鉴赏家
• 体能训练教练
• 逻辑学导师
• 英语口语教练
• 体检诊断顾问

11.7 模型架构

详见：docs/MODEL_ARCHITECTURE.md

12. 开发里程碑

总计：约10-11周

13. 关键文件清单

13.1 核心引擎

13.2 知识库系统 🆕

13.3 专家模块（V2版本）🆕

13.4 MCP与API

13.5 存储与部署

13.6 训练脚本

附录

A. 参考资料

• TITANS论文 - Google NeurIPS 2025
• MCP-TITAN项目
• 米塞斯《人的行为》
• 小智开发文档

B. 术语表

C. 相关文档

文档版本：2.0 | 最后更新：2026-01-19