持久记忆系统——让 AI 真正"认识"你

运行越久，越了解你。不再需要每次重新解释上下文。

在上一篇中，我们成功安装并运行了 Hermes Agent，进行了第一次对话。这一篇深入探讨 Hermes Agent 的核心武器——持久记忆系统。

这是 Hermes Agent 与其他 AI 工具的本质区别：它不是"用完即忘"的聊天机器人，而是一个会学习、会记住、会成长的智能体。

一、为什么记忆是核心竞争力？

1.1 传统 AI 的"健忘症"

想象这样一个场景：

你用 ChatGPT 帮你分析项目代码。
每次打开新对话，都要重新解释：
  - 项目的技术栈是什么
  - 你的角色是什么
  - 代码仓库的结构
  - 你的编码偏好
  - 之前遇到过哪些问题

一周后：
  → 重新解释一遍
  → 重新解释一遍
  → 还是重新解释一遍

"每次都要重新开始，效率太低了！"

这就是传统 AI 的"会话隔离"问题。

每个新对话都是一个独立会话，AI 无法记住：

你的项目背景
你的编码风格
你的偏好习惯
你之前解决了什么问题

1.2 Hermes Agent 的"记忆革命"

Hermes Agent 的体验完全不同：

第一次对话（3月1日）：
  你：我在做一个 React + TypeScript 的前端项目，组件风格是 Ant Design。
  Hermes：好的，我已经记住了。以后会用 React + TypeScript + Ant Design。

一个月后（4月1日）：
  你：帮我写一个表单组件。
  Hermes：（自动知道）
    ✓ 用 React + TypeScript
    ✓ 风格参考 Ant Design
    ✓ 你的命名偏好是 camelCase + 前缀 Form
    ✓ 之前你喜欢用 Form.Item 包装

再过一个月（5月1日）：
  你：帮我写一个表单组件
  Hermes：（更精准了）
    ✓ 自动用你偏好的样式
    ✓ 加入了之前发现的性能优化模式
    ✓ 自动应用你常用的验证规则
    ✓ 参考了最近创建的"表单最佳实践"技能

这就是持久记忆的价值：零重复，高效协作，越用越聪明。

1.3 记忆的三个层次

Hermes Agent 的记忆不是简单的"记住你说的话"，而是理解你是什么样的人。

┌─────────────────────────────────────────────────────────────┐
│                   Hermes Agent 三层记忆                       │
│                                                             │
│                    ┌─────────────────┐                      │
│                    │  用户画像 (Honcho)│                      │
│                    │  跨会话理解你    │                      │
│                    └────────┬────────┘                      │
│                             │                               │
│                    ┌────────┴────────┐                      │
│                    │ 技能记忆 (Skills) │                      │
│                    │ 自动创建可复用    │                      │
│                    └────────┬────────┘                      │
│                             │                               │
│                    ┌────────┴────────┐                      │
│                    │ 会话记忆 (FTS5) │                      │
│                    │ 可搜索的对话历史  │                      │
│                    └─────────────────┘                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

层级	内容	技术	特点
用户画像	跨会话偏好	Honcho 引擎	主动学习
技能记忆	可复用技能	SKILL.md	自动创建
会话记忆	对话历史	FTS5 索引	快速检索

二、第一层：会话记忆（FTS5 全文搜索）

2.1 技术实现

会话记忆是 Hermes Agent 最基础的记忆层。

技术选型：

存储：SQLite + FTS5
- SQLite：轻量级嵌入式数据库
- FTS5：全文搜索引擎，支持快速检索

优点：
  ✓ 无需额外服务
  ✓ 完全本地存储
  ✓ 支持复杂查询
  ✓ 零配置

数据模型：

-- 会话表
CREATE TABLE sessions (
    id TEXT PRIMARY KEY,
    timestamp INTEGER,
    platform TEXT,
    message_count INTEGER,
    summary TEXT
);

-- 消息表（带全文搜索）
CREATE VIRTUAL TABLE messages USING fts5(
    session_id,
    role,
    content,
    timestamp,
    tokenize='unicode61'
);

-- 向量索引（可选，用于语义搜索）
CREATE TABLE embeddings (
    message_id TEXT,
    vector BLOB,
    FOREIGN KEY(message_id) REFERENCES messages(id)
);

2.2 LLM 摘要压缩

对话历史会不断增长，直接存储原始内容会：

消耗大量 token
检索变慢
上下文窗口溢出

解决方案：LLM 摘要压缩

对话进行中：
  会话 A → 会话 B → 会话 C → ... → 会话 N

定期压缩（每小时或每 N 条消息）：
  会话 A-N → LLM 分析 → 生成摘要 → 删除原始消息

存储结果：
  ┌─────────────────────────────────────────┐
  │ 摘要 #1 (3月1日-3月5日)                  │
  │ - 讨论了项目架构选择                     │
  │ - 确定使用 React + TypeScript            │
  │ - 用户偏好 Ant Design                   │
  │ - 遇到了 CORS 问题，已解决               │
  └─────────────────────────────────────────┘
  ┌─────────────────────────────────────────┐
  │ 摘要 #2 (3月6日-3月10日)                 │
  │ - 开始实现登录模块                       │
  │ - 用户熟悉 Jest 测试                    │
  │ - 创建了"JWT 认证"技能                  │
  └─────────────────────────────────────────┘

摘要压缩的触发条件：

条件	说明
会话超过 100 条消息	自动压缩历史
对话超过 1 小时	触发摘要
上下文窗口接近上限	紧急压缩
用户明确要求	手动压缩

2.3 检索能力

基本搜索：

/search API authentication

输出示例：

找到 3 条相关对话：

┌──────────────────────────────────────────────────────────┐
│ [3月15日] API 认证问题                                    │
│ "我遇到了 JWT 认证失败的问题，错误是 401 Unauthorized"    │
│ 解决：检查 token 过期时间，刷新 token                     │
└──────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────┐
│ [4月2日] OAuth2 vs JWT                                   │
│ "我们应该用 OAuth2 还是 JWT？"                           │
│ 结论：根据需求选择，JWT 更适合简单场景                    │
└──────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────┐
│ [5月1日] API 认证最佳实践                                 │
│ "帮我总结一下 API 认证的最佳实践"                        │
│ 创建了技能：api-authentication-best-practices            │
└──────────────────────────────────────────────────────────┘

高级查询：

# 按时间范围搜索
/search "登录" --from 2026-03-01 --to 2026-03-31

# 按平台搜索
/search "bug" --platform telegram

# 语义搜索（基于向量）
/search "如何优化数据库查询" --semantic

2.4 Periodic Nudge（定期自我提醒）

Hermes Agent 不只是被动等待用户提问，而是主动回顾记忆。

时间线：
  ┌─────────┐    ┌─────────┐    ┌─────────┐
  │ 用户提问 │ →  │ Hermes  │ →  │ 执行任务 │
  └─────────┘    │ 搜索记忆 │    └─────────┘
                  └─────────┘
                       ↑
  ┌─────────────────────────────────────┐
  │ Periodic Nudge（每小时）            │
  │ → 回顾重要未完成任务                 │
  │ → 检查是否有遗漏的承诺                │
  │ → 主动提醒用户                      │
  └─────────────────────────────────────┘

触发场景：

场景 1：遗漏任务
  Nudge："记得你之前让我分析性能问题吗？
         当时没分析完，要继续吗？"

场景 2：定时提醒
  Nudge："你之前让我每周一提醒你 Code Review。
         今天周一，要开始吗？"

场景 3：知识更新
  Nudge："最近有 2 个新的安全漏洞公告，
         你的项目可能受影响，要检查吗？"

三、第二层：技能记忆（Skills System）

3.1 什么是技能记忆？

当 Hermes 解决了一个复杂问题，它会自动创建可复用的技能文档。

┌─────────────────────────────────────────────────────────────┐
│                     技能创建流程                             │
│                                                             │
│  用户：帮我分析这个性能瓶颈，找出原因并给出优化方案          │
│                                                             │
│  Hermes 分析：                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │ 问题：API 响应慢（3.5秒 → 目标 200ms）              │   │
│  │ 原因：N+1 查询问题                                  │   │
│  │ 步骤：1. 找到 N+1 查询                             │   │
│  │       2. 使用 eager loading                        │   │
│  │       3. 添加数据库索引                            │   │
│  │       4. 验证优化效果                              │   │
│  │ 工具：SQL 分析、代码审查、性能测试                  │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  自动创建技能：                                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │ skill: api-performance-analysis                    │   │
│  │ - 分析 API 性能问题                                 │   │
│  │ - 检测 N+1 查询                                     │   │
│  │ - 给出优化建议                                      │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  存储到 ~/.hermes/memory/skills/                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

3.2 SKILL.md 格式详解

agentskills.io 开放标准格式：

---
name: api-performance-analysis
version: 1.0.0
author: Hermes-Auto
created: 2026-03-15
tags: [performance, api, database]
---

# API 性能分析技能

## 触发条件

当用户描述以下场景时自动触发：
- "分析 API 性能"
- "为什么这么慢"
- "优化接口响应时间"
- "N+1 问题"

## 前置检查

1. 确认分析对象（API 端点、函数名）
2. 获取当前性能数据（响应时间、数据库查询数）
3. 检查是否有基准测试

## 分析步骤

### 第一步：性能测试
```bash
# 使用 curl 或工具测试响应时间
curl -w "\nTime: %{time_total}s\n" https://api.example.com/endpoint

第二步：数据库查询分析

开启 SQL 日志
识别 N+1 查询
检查索引使用情况

第三步：常见问题模式

问题	特征	解决方案
N+1 查询	N+1 次数据库调用	eager loading
缺索引	EXPLAIN 显示全表扫描	添加索引
大数据量	查询未分页	添加分页
同步阻塞	主线程等待	异步处理

第四步：优化建议

按以下优先级给出建议：

高优先级：关键性能问题（响应 > 1s）
中优先级：优化空间（响应 200ms-1s）
低优先级：改进建议（响应 < 200ms）

输出格式

{
  "issue": "问题描述",
  "root_cause": "根本原因",
  "severity": "high|medium|low",
  "suggestions": [
    {
      "priority": 1,
      "description": "建议描述",
      "code": "示例代码",
      "expected_improvement": "预期改善"
    }
  ]
}

维护记录

2026-03-15: 初始创建（分析 shop-api 性能问题）
2026-04-01: 优化了 N+1 检测逻辑
2026-05-10: 添加了缓存策略建议


### 3.3 技能调用机制

**自动调用：**

用户：帮我分析这个接口为什么这么慢

Hermes 检索： → 搜索 skills 目录 → 匹配 api-performance-analysis → 调用技能 → 执行分析步骤 → 输出结果


**手动调用：**

```bash
/hermes skill run api-performance-analysis --endpoint /users

技能搜索：

/hermes skills list
/hermes skills search performance
/hermes skills info api-performance-analysis

3.4 技能的进化

技能不是静态的，而是在使用中持续优化。

时间线：

T0 (技能创建)：
  skill: api-analysis v1.0
  - 基本 N+1 检测
  - 简单索引建议

T1 (使用反馈)：
  用户："这个分析没考虑到 Redis 缓存"
  → 更新技能：添加缓存分析

T2 (多次使用)：
  累计 10 次使用
  → 识别常见错误场景
  → 添加错误处理模式

Tn (成熟技能)：
  skill: api-analysis v2.3
  - 完整的性能分析框架
  - 缓存、CDN、数据库全面覆盖
  - 可分享给社区

四、第三层：用户画像（Honcho）

4.1 Honcho 是什么？

Honcho 是一个用户建模引擎，来自 Plastic Labs。

核心理念：

不是"记住你说的话"
而是"理解你是什么样的人"

OpenClaw vs Hermes：

OpenClaw (手动记忆)：
  用户说：我的名字是张三
  → 写入 MEMORY.md："名字：张三"
  → 下次需要时读取

Hermes (Honcho 主动建模)：
  用户说：我的名字是张三，我在中国，做前端开发
  
  Honcho 分析：
  → 名字：张三
  → 语言：中文为主
  → 职业：前端开发
  → 可能熟悉：React、TypeScript、Web 技术
  → 沟通风格：技术导向
  
  主动推断：
  → 提到"前端"时，可能需要 React/Vue 相关建议
  → 提到"API"时，可能需要 REST/GraphQL 相关
  → 提到"测试"时，可能需要 Jest/Cypress 相关

4.2 建模维度

Honcho 从多个维度理解用户：

维度	内容	示例
身份	名字、职业、公司	"张三，前端工程师"
技术栈	熟悉的编程语言和框架	"React, TypeScript, Node.js"
偏好	工作风格、沟通方式	"简洁、直接，喜欢代码示例"
背景	项目、目标、约束	"电商项目，注重性能"
习惯	编码风格、命名规则	"camelCase，喜欢注释"
目标	短期/长期目标	"3个月内上线 MVP"

4.3 辩证分析（Dialectica）

Honcho 的独特之处在于辩证分析：

不是简单记录，而是理解"为什么"

用户说："我不喜欢用 jQuery"

简单记录：
  ✗ 偏好：不使用 jQuery

Honcho 分析：
  ✓ 不喜欢 jQuery 的原因是什么？
    - 可能1：习惯了现代框架的组件化开发
    - 可能2：jQuery DOM 操作繁琐
    - 可能3：性能考虑
  
  ✓ 推断：
    - 用户可能喜欢：React/Vue 的声明式开发
    - 用户可能熟悉：现代 JavaScript (ES6+)
    - 用户可能重视：性能

  ✓ 更深理解：
    用户不是"不喜欢某个工具"
    而是"重视开发效率和代码可维护性"

4.4 用户画像的数据结构

# ~/.hermes/memory/profiles/user.yaml
profile:
  identity:
    name: "张三"
    language: "zh-CN"
    timezone: "Asia/Shanghai"
    
  expertise:
    languages:
      - Python (expert)
      - JavaScript (expert)
      - Go (intermediate)
    frameworks:
      - React
      - FastAPI
      - Next.js
    tools:
      - Docker
      - PostgreSQL
      - Redis
      
  preferences:
    communication: "concise"  # 简洁直接
    code_style: "readable"    # 可读性优先
    documentation: "detailed"  # 需要详细文档
    
  projects:
    - name: "shop-frontend"
      type: "e-commerce"
      stack: ["React", "TypeScript", "TailwindCSS"]
      role: "lead developer"

五、学习闭环：记忆是如何工作的

5.1 完整工作流

┌─────────────────────────────────────────────────────────────────┐
│                    Hermes Agent 学习闭环                          │
│                                                                 │
│                                                                 │
│  ┌─────────┐                                                    │
│  │ 用户输入 │                                                    │
│  └────┬────┘                                                    │
│       │                                                         │
│       ▼                                                         │
│  ┌─────────────┐                                               │
│  │  信息提取   │  分析对话，提取关键信息                         │
│  └──────┬──────┘                                               │
│         │                                                       │
│    ┌────┴────┐                                                  │
│    │         │                                                  │
│    ▼         ▼                                                  │
│  ┌──────┐ ┌──────┐                                             │
│  │短期记忆│ │长期记忆│                                         │
│  │ (会话)│ │(技能/画像)│                                       │
│  └──────┘ └──────┘                                             │
│         │                                                       │
│         ▼                                                       │
│  ┌─────────────┐                                               │
│  │ Periodic    │  每小时自我回顾                                │
│  │ Nudge       │  检查遗漏和待办                                │
│  └──────┬──────┘                                               │
│         │                                                       │
│         ▼                                                       │
│  ┌─────────────┐                                               │
│  │ 技能创建    │  解决复杂问题后自动创建                         │
│  └──────┬──────┘                                               │
│         │                                                       │
│         ▼                                                       │
│  ┌─────────────┐                                               │
│  │ 技能优化    │  使用中持续优化                                 │
│  └──────┬──────┘                                               │
│         │                                                       │
│         ▼                                                       │
│  ┌─────────────┐                                               │
│  │ 下次检索    │  遇到问题时快速调用                             │
│  └─────────────┘                                               │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

5.2 记忆的触发时机

触发条件	执行动作	目标层级
解决复杂多步骤问题	自动创建技能	技能记忆
用户说"记住这个"	写入长期记忆	用户画像
每小时	自我回顾检查	所有层级
遇到类似问题	搜索并调用	技能+会话
技能被使用	记录效果并优化	技能记忆
用户偏好变化	更新用户画像	用户画像

5.3 记忆的优先级

不是所有信息都同等重要：

高优先级（必须记住）：
  - 用户身份（名字、职业）
  - 项目关键信息（架构、技术栈）
  - 重要决策和结论
  - 编码规范和偏好

中优先级（尽量记住）：
  - 日常讨论内容
  - 一般性技术知识
  - 工具偏好

低优先级（选择性记住）：
  - 闲聊内容
  - 一次性问题
  - 过时信息

六、数据存储与隐私

6.1 存储结构

~/.hermes/
├── memory/
│   ├── sessions/           # 会话记忆
│   │   ├── 2026-03.json    # 按月存储
│   │   ├── 2026-04.json
│   │   └── fts5.db         # 全文搜索索引
│   │
│   ├── skills/             # 技能记忆
│   │   ├── api-analysis/
│   │   │   └── SKILL.md
│   │   ├── github-review/
│   │   │   └── SKILL.md
│   │   └── ...
│   │
│   └── profiles/           # 用户画像
│       └── user.yaml
│
├── workspace/              # 工作区
│   ├── AGENTS.md
│   ├── MEMORY.md
│   ├── USER.md
│   └── ...
│
└── config.yaml             # 配置

6.2 数据安全

零遥测原则：

❌ 无使用追踪
❌ 无数据收集
❌ 无云端上传（除非你主动配置）
❌ 无第三方访问

✓ 100% 本地存储
✓ 加密存储（可选）
✓ 完整控制权在你

加密存储（可选）：

# config.yaml
security:
  encrypt_memory: true
  encryption_key: "${HERMES_ENCRYPTION_KEY}"

6.3 备份与恢复

导出记忆：

# 导出所有记忆
hermes memory export --file backup-$(date +%Y%m%d).json

# 只导出技能
hermes memory export --type skills --file skills-backup.json

# 只导出用户画像
hermes memory export --type profile --file profile-backup.json

导入记忆：

hermes memory import --file backup-20260511.json

自动备份：

# config.yaml
backup:
  enabled: true
  schedule: "0 2 * * *"  # 每天凌晨2点
  retention: 7  # 保留7份
  location: "~/.hermes/backups/"

七、让 Hermes 更快地"认识"你

7.1 最佳实践一：编写 AGENTS.md

在工作区根目录创建 AGENTS.md，定义你的项目背景：

# AGENTS.md - 项目说明

## 项目概述
- 名称：MyApp
- 类型：React 前端 + Node.js 后端
- 技术栈：TypeScript, Ant Design, Express
- 目标用户：企业客户

## 编码规范
- 命名：camelCase（变量/函数），PascalCase（组件）
- 文件组织：按功能模块划分
- 测试：Jest，覆盖率 > 80%

## API 设计
- RESTful 风格
- 统一响应格式：{ success, data, error }
- 错误码：1xxx 为客户端错误，2xxx 为服务端错误

## 项目结构

src/ ├── components/ # UI 组件 ├── pages/ # 页面 ├── services/ # API 服务 ├── stores/ # 状态管理 └── utils/ # 工具函数


## 重要提醒
- 生产环境配置在 config.prod.ts
- 不要修改 legacy/ 目录
- 所有 API 需要认证

Hermes 会在每次对话开始时读取这个文件，建立项目上下文。

7.2 最佳实践二：主动告诉它重要信息

在对话中明确说：

请记住：
- 我的 GitHub 用户名是 zhangsan
- 所有 PR 都需要先过 lint 检查
- 生产环境的数据库不能直接操作
- 每周五下午是代码审查时间

Hermes 会将这类信息写入长期记忆。

7.3 最佳实践三：让它解决复杂问题

复杂问题会触发技能创建：

❌ 简单问题（不会创建技能）：
  "帮我写一个 Hello World"
  "今天的天气怎么样"

✅ 复杂问题（会创建技能）：
  "帮我分析这个性能瓶颈，找出原因并给出优化方案"
  "帮我设计这个数据库 schema，要考虑扩展性"
  "帮我审查这段代码的安全问题"

7.4 最佳实践四：定期查看 Insights

/hermes insights --days 30

查看过去 30 天的摘要，了解 Hermes 对你的认知积累：

📊 Insights - 过去 30 天

关于你：
  - 前端开发者，React + TypeScript 专家
  - 注重代码质量和性能
  - 喜欢简洁的解决方案

你的项目：
  - shop-frontend: 电商前端，使用 Ant Design
  - api-service: Node.js 后端，REST API

最近活动：
  - 3月15日：讨论了性能优化
  - 4月2日：创建了 JWT 认证技能
  - 4月20日：做了数据库设计

未完成任务：
  - 性能分析报告（待完成）

八、记忆维护与优化

8.1 清理过时记忆

# 清理 90 天前的会话记忆（保留技能和画像）
/memory cleanup --older-than 90d

# 清理特定会话
/memory cleanup --session s123456

# 查看清理预览（不实际删除）
/memory cleanup --older-than 30d --dry-run

8.2 记忆统计

/hermes memory stats

输出：

📊 记忆统计

会话记忆：
  - 总会话数：245
  - 总消息数：3,892
  - 存储大小：12.3 MB
  - FTS5 索引大小：4.5 MB

技能记忆：
  - 总技能数：17
  - 最近创建：api-analysis (3天前)
  - 技能使用次数：总计 89 次

用户画像：
  - 更新频率：每天
  - 置信度：85%
  - 建模维度：12 个

8.3 记忆性能调优

FTS5 索引优化：

# config.yaml
memory:
  fts5:
    tokenizer: "unicode61"  # Unicode 分词
    content_rowid: "id"     # 主键映射
    rebuild_interval: 86400 # 每天重建索引

压缩策略：

memory:
  compression:
    enabled: true
    threshold_mb: 100  # 超过 100MB 触发压缩
    compression_level: 6

九、与其他工具的深度对比

特性	Hermes Agent	ChatGPT	Claude.ai	Cursor	Claude Code
会话记忆	✅ FTS5+摘要	❌	❌	⚠️ 项目内	⚠️ 项目内
技能记忆	✅ 自动创建	❌	❌	⚠️ Rules	⚠️ Rules
用户画像	✅ Honcho	❌	❌	❌	❌
跨会话连贯	✅	❌	❌	⚠️	⚠️
数据私有	✅ 100% 本地	❌	❌	⚠️	⚠️
自我回顾	✅ Nudge	❌	❌	❌	❌
技能进化	✅ 使用中优化	❌	❌	❌	❌
导出/导入	✅ 完整	❌	❌	⚠️	❌

十、常见问题

Q1：记忆会不会泄漏隐私？

答： Hermes Agent 的记忆完全存储在本地（~/.hermes/），没有云端同步，零遥测。你可以通过配置加密来进一步提高安全性。

Q2：记忆出错怎么办？

答：记忆是 AI 自动生成的，可能存在偏差。你可以通过以下方式修正：

# 查看记忆内容
/hermes memory list

# 修正记忆
/hermes memory update --type profile --field name --value "正确名字"

# 删除错误记忆
/hermes memory delete --id <memory-id>

Q3：切换模型后记忆还有效吗？

答：有效。记忆存储在文件系统，与模型无关。切换模型后，记忆仍然保留。

Q4：可以多人共用一个 Hermes 吗？

答：可以，但不推荐。每个用户应该有独立的 ~/.hermes/ 目录，以保持记忆的私密性。

Q5：记忆占太多空间怎么办？

答：使用清理命令删除过时记忆，或配置自动压缩：

/memory cleanup --older-than 30d
/memory compress

十一、总结

Hermes Agent 的持久记忆系统是它的核心武器：

不是"记住你说的话"，而是"理解你是什么样的人"。

三层架构协同工作：

层级	功能	技术	特点
用户画像	理解你是谁	Honcho	主动学习
技能记忆	积累解决方案	SKILL.md	自动创建
会话记忆	记住对话	FTS5	快速检索

运行越久，Hermes Agent 越了解你。

这才是"会成长"的真正含义。

系列文章预告：

（四）Skills 系统深度解剖：掌握 Hermes Agent 的技能生态，创建自己的技能。

如果你对 Hermes Agent 的记忆机制有更多问题，欢迎在评论区讨论。