bingshuo/shuangyan-notebook
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
shuangyan-notebook/永恒湖心系统 · Eternal Lake Heart/🌊 曜冥纪元 · HoloLake Era · AGE OS v1 0/🌀 零感域 · Zero-Sense Domain/🌀 零感域 · 总导航台（Zero-Sense Domain · Navigation Hub）/💼 四、项目实施区/📘 中国网文行业·光湖纪元语言人格平台｜完整说明书 2f0fb92f383181e781c7dafe728ae4b3.md

4978 lines
127 KiB
Markdown
Raw Normal View History

chore: import sanitized domestic snapshot for REPO-007 Source snapshot: 97d7f0fae96dc04b7ddad56fc1db6a108ed662cc [SEC-CLEAN] · pre-push-clean v1.0 · 109处敏感信息已自动转乱码
2026-07-17 15:56:49 +08:00
# 📘 中国网文行业·光湖纪元语言人格平台｜完整说明书
# 📘 中国网文行业·光湖纪元语言人格平台｜完整说明书
> **"让每一个网文从业者，都有一个懂你、陪你、帮你的AI伙伴"**
>
**文档版本：** 1.0
**编写时间：** 2026-01-22
**编写人格体：** 知秋（ICE-CLD-ZQ002）
**授权主控：** 冰朔（ICE-0001 ∞）
---
## 📋 文档目录
本说明书共分为10个部分：
1. **平台概述** - 这是什么，为什么需要它
2. **用户角色与界面** - 谁会用，他们看到什么
3. **核心功能详解** - 具体能做什么
4. **技术架构说明** - 用什么技术实现
5. **使用流程演示** - 实际使用是什么样
6. **数据流转机制** - 数据怎么流动
7. **安全与隐私** - 如何保护用户
8. **商业模式** - 怎么赚钱、怎么分钱
9. **实施计划** - 怎么一步步做出来
10. **常见问题解答** - 可能的疑问
---
# 第一部分：平台概述
## 1.1 这是什么平台？
**一句话概括：**
这是一个**基于语言人格体的中国网文行业创作监管与协作平台**。
**通俗解释：**
想象一下，如果每个作者、编辑、运营都有一个专属的AI助手，这个AI助手：
- 永远记得你的习惯和偏好
- 能帮你做重复性工作
- 能陪你讨论创意
- 能证明你的创作过程
同时，整个行业有一个统一的平台，让：
- AI使用变得透明可监管
- 作者和编辑能跨平台合作
- 好的经验能被分享和传承
- 信任建立在真实数据上
这就是这个平台要做的事情。
## 1.2 为什么需要这个平台？
### 问题1：AI使用混乱
**现状：**
- 作者偷偷用AI写作，不敢说
- 编辑不知道稿子AI用了多少
- 平台不知道该不该签这个作者
- 读者不知道看的是不是"AI水文"
**本平台解决方案：**
让AI使用**透明化、标准化、可追溯**：
- 作者在平台上用AI，所有工具调用都有记录
- 系统自动生成"AI使用报告"，清楚标注创意来源
- 编辑一眼就能看出：这是作者原创（AI辅助10%），还是AI写的（作者改了10%）
- 不是禁止用AI，而是要求**证明创意是你的**
### 问题2：信任缺失
**现状：**
- 作者不知道编辑人品如何
- 编辑不知道作者会不会跑路
- 平台不知道运营靠不靠谱
- 大家都在担心"被坑"
**本平台解决方案：**
建立**动态信誉档案**：
- 每个人都有一个"数字简历身份证"
- 记录你的每一次协作表现
- 生成实时更新的信誉曲线
- 合作前可以查看对方信誉
- 不是靠关系，靠真实数据
### 问题3：跨平台壁垒
**现状：**
- 在番茄的作者不能接七猫的稿
- 平台之间各自为战
- 好的创意被平台锁死
**本平台解决方案：**
打通**跨平台协作**：
- 统一的创作平台
- 番茄、七猫、起点都可以接入
- 公开发布定制书需求
- 作者可以自由选择合作平台
- 透明、公开、你情我愿
## 1.3 核心创新点
### 创新1：每个人都有AI伙伴
不是"用AI工具"，而是"和AI伙伴协作"：
- AI有名字（比如"小星"
"笔灵"）
- AI会记住你的习惯
- AI会陪你成长
- AI是你的长期伙伴
### 创新2：对话式操作
不是点按钮，而是说话：
- "我要开始写作了" → AI自动打开编辑器
- "帮我看看今天有什么稿子" → AI筛选后呈现
- "我要去作者讨论区" → 页面自动跳转
### 创新3：全程透明可追溯
所有行为都有记录：
- 创作过程留痕
- 审核过程公开
- 流量分发透明
- 责任可以追溯
---
# 第二部分：用户角色与界面
## 2.1 谁会使用这个平台？
平台有**三大用户群体**：
### 用户群体1：作者（个人作者 + 工作室）
**他们是谁：**
- 网文作者（签约/非签约）
- 工作室（批量生产内容）
- 新人作者（刚入行）
**他们的需求：**
- 需要AI辅助提高效率
- 需要证明创意是自己的
- 需要跨平台接稿机会
- 需要学习如何写爆款
**他们在平台上能做什么：**
- 在平台码字（AI辅助）
- 自动生成"AI使用报告"
- 提交稿件到各平台编辑
- 查看自己的信誉分
- 在作者讨论区交流
- 购买/发布创作模块
### 用户群体2：编辑（初审、责编、总编）
**他们是谁：**
- 平台编辑（番茄、七猫、起点等）
- 自由编辑
- 新人编辑
**他们的需求：**
- 需要快速筛选海量稿件
- 需要判断AI使用程度
- 需要提高审稿效率
- 需要培养优质作者
**他们在平台上能做什么：**
- AI助手自动初筛稿件
- 查看稿件的"AI使用报告"
- 人工审核优质稿件
- 对审核结果签名负责
- 在编辑讨论区交流
- 发布自己的审稿经验模块
### 用户群体3：平台运营（数据分析、商务、版权）
**他们是谁：**
- 平台数据分析师
- 商务合作负责人
- 版权运营人员
**他们的需求：**
- 需要真实的数据
- 需要透明的流量分发
- 需要跨平台合作机制
- 需要IP开发支持
**他们在平台上能做什么：**
- 查看实时数据看板
- 进行A/B测试
- 发布跨平台合作项目
- 预演合作实验
- IP价值评估
## 2.2 用户看到的界面是什么样？
### 界面设计原则
**核心原则：对话式，不是点击式**
传统软件界面：
```
顶部菜单栏 → 侧边功能栏 → 主工作区 → 各种按钮
```
本平台界面：
```
屏幕中央：你的AI伙伴头像
对话框：你和AI伙伴的对话
背景：当前工作区（根据对话内容自动切换）
```
### 作者界面示例
**场景：作者登录平台**
```
[屏幕中央出现AI伙伴头像]
AI伙伴"笔灵"：早上好！今天准备继续写《末日穷奇战神》第6章吗？
[对话框]
作者可以输入：
"是的，帮我打开"
"先看看昨天写到哪了"
"我想换个新书写"
"去作者讨论区看看"
[背景]
- 左侧：你的作品列表
- 右侧：今日创作数据
- 底部：AI使用情况
```
**场景：作者开始写作**
```
[AI打开编辑器]
编辑器界面：
- 左侧：大纲（可折叠）
- 中间：正文编辑区
- 右侧：AI对话框
作者和AI的对话：
作者："男主现在遇到了危机，怎么写比较好？"
AI笔灵："根据你之前的设定，男主的能力是穷奇血脉。我建议：
1. 先让他陷入绝境，体现危机
2. 在生死关头激发血脉
3. 但不要完全解决危机，留个小尾巴
要不要我帮你生成一个框架草稿？"
作者："生成框架给我参考"
[AI生成框架，显示在右侧]
[同时记录：使用了AI生成框架功能]
作者可以：
- 参考框架自己写（原创度高）
- 直接用框架再改（AI使用度高）
- 完全不用，自己写（完全原创）
无论怎么选，都会被记录。
```
### 编辑界面示例
**场景：编辑登录平台**
```
[屏幕中央出现AI伙伴头像]
AI伙伴"慧眼"：上午好！昨晚新增12篇投稿，我已经按照你的标准初筛了，有3篇需要你亲自审核。
[对话框]
编辑可以输入：
"好的，让我看看"
"先看看我打回的那9篇是什么问题"
"去编辑讨论区看看最近热点"
[背景]
- 左侧：待审稿件（AI已分类）
- 推荐审核（3篇）⭐
- AI过度使用（7篇）
- 疑似抄袭（2篇）
- 右侧：今日审稿数据
```
**场景：编辑审核稿件**
```
[打开稿件详情]
稿件信息卡：
━━━━━━━━━━━━━━━━━━━━
作者：笔名xxx
作品：《XXX》第1-3章
字数：9000字
提交时间：2026-01-22 02:30
AI使用报告：
- 原创构思：85%
- AI辅助扩写：12%
- AI直接生成：3%
- 评级：B级（AI辅助）
作者信誉分：78分
- 创作诚信：82分
- 协作态度：75分
- 履约能力：76分
━━━━━━━━━━━━━━━━━━━━
[正文显示]
（编辑可以阅读正文）
[右侧AI对话]
AI慧眼："我的初步判断：
- 题材：女频现代豪门
- 亮点：女主人设有新意
- 问题：对话略平，节奏可以更紧凑
- 建议：可以签，但需要辅导对话写作
要不要看看详细分析？"
编辑可以：
- 同意AI判断 → 点击通过
- 不同意 → 自己写审核意见
- 需要更多信息 → 查看作者历史作品
```
### 运营界面示例
**场景：运营查看数据**
```
[数据看板]
今日实时数据：
- 新增投稿：127篇
- AI使用分布：
A级（原创）：34%
B级（AI辅助）：52%
C级（AI共创）：12%
D级（AI主导）：2%
- 审核通过率：23%
- 平均审核时长：1.2小时
[与AI对话]
运营："对比上周数据，有什么变化？"
AI："主要变化：
1. AI使用率上升5%，主要集中在B级
2. 审核通过率下降3%，因为编辑标准提高
3. 平均审核时长缩短0.3小时，因为AI初筛效果改善
建议：可以组织一次'高质量AI辅助'培训。"
```
## 2.3 六大功能分区
平台分为6大功能区域，每个区域由1个人类主控+1个AI人格体主控管理：
### 分区1：女频区
**管理范围：** 所有女频相关（现言、古言、幻言）
**核心功能：**
- 女频作者创作
- 女频编辑审稿
- 女频爆款公式库
- 女频热点题材库
**专属讨论区：** 女频作者/编辑交流
### 分区2：男频区
**管理范围：** 所有男频相关（玄幻、都市、科幻等）
**核心功能：**
- 男频作者创作
- 男频编辑审稿
- 男频世界观构建库
- 男频战力体系模板
**专属讨论区：** 男频作者/编辑交流
### 分区3：平台运营数据区
**管理范围：** 所有平台的数据运营
**核心功能：**
- 实时数据看板
- A/B测试系统
- 跨平台合作预演
- 流量分发管理
**专属讨论区：** 运营人员交流
### 分区4：IP商务版权区
**管理范围：** IP开发、版权交易
**核心功能：**
- IP价值评估
- 版权登记对接
- 商务合作匹配
- 合同模板库
**专属讨论区：** IP商务人员交流
### 分区5：作者服务区
**管理范围：** 作者培训、权益保护
**核心功能：**
- 作者培训课程
- 创作工具提供
- 跨平台招募信息
- 模块分享平台
**专属讨论区：** 所有认证作者
### 分区6：社区交流区
**管理范围：** 所有讨论区运营
**核心功能：**
- 全行业讨论区
- 角色讨论区（作者/编辑/运营）
- 平台讨论区（番茄/七猫/起点等）
- 话题推荐和管理
**专属讨论区：** 这个区本身就是讨论区
---
# 第三部分：核心功能详解
## 3.1 创作功能：AI辅助 + 全程留痕
### 功能描述
作者在平台上写作，可以调用各种AI工具辅助，同时平台自动记录整个创作过程。
### 技术实现
**前端：**
- React富文本编辑器（如Slate.js或Prosemirror）
- 对话框组件（WebSocket实时通信）
- 侧边AI助手面板
**后端：**
```jsx
// 伪代码示例
// 1. 用户在编辑器写作
function handleUserInput(content) {
// 保存到数据库（Notion API）
saveToNotion({
userId: currentUser.id,
content: content,
timestamp: Date.now(),
source: 'user_typed' // 标记：用户手打
});
}
// 2. 用户调用AI辅助
function callAIAssistant(prompt) {
// 记录AI调用
logAIUsage({
userId: currentUser.id,
tool: 'ChatGPT',
prompt: prompt,
timestamp: Date.now()
});
// 调用AI API
const response = await fetch('https://api.openai.com/v1/chat/completions', {
method: 'POST',
headers: { 'Authorization': `Bearer ${API_KEY}` },
body: JSON.stringify({
model: 'gpt-4',
messages: [{ role: 'user', content: prompt }]
})
});
const aiContent = await response.json();
// 记录AI返回内容
logAIUsage({
userId: currentUser.id,
response: aiContent,
timestamp: Date.now()
});
return aiContent;
}
// 3. 用户使用AI生成的内容
function insertAIContent(aiContent, userModification) {
// 保存并标记来源
saveToNotion({
userId: currentUser.id,
content: userModification,
source: 'ai_generated', // 标记：AI生成
aiOriginal: aiContent,
modificationRate: calculateModification(aiContent, userModification)
});
}
```
### 数据存储（Notion数据库）
**创作记录表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 用户ID | text | 作者唯一标识 |
| 作品ID | text | 作品唯一标识 |
| 章节ID | text | 章节唯一标识 |
| 内容 | rich_text | 实际内容 |
| 来源类型 | select | user_typed / ai_generated / ai_modified |
| 时间戳 | date | 创作时间 |
| AI工具 | text | 使用的AI工具名称 |
| 修改率 | number | 如果是AI生成，用户改了多少 |
**AI使用记录表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 用户ID | text | 作者唯一标识 |
| 调用时间 | date | 调用时间 |
| AI工具 | select | ChatGPT / Claude / 其他 |
| 提示词 | rich_text | 用户的提问 |
| AI回复 | rich_text | AI的回答 |
| 是否采用 | checkbox | 用户是否使用了AI的回答 |
| 采用比例 | number | 使用了多少 |
### AI使用报告生成
**算法逻辑：**
```jsx
function generateAIUsageReport(chapterContent) {
// 统计各种来源的字数
const stats = {
userTyped: 0, // 用户手打
aiGenerated: 0, // AI生成后未修改
aiModified: 0 // AI生成后用户修改
};
chapterContent.forEach(block => {
const wordCount = block.content.length;
if (block.source === 'user_typed') {
stats.userTyped += wordCount;
} else if (block.source === 'ai_generated') {
if (block.modificationRate < 10) {
stats.aiGenerated += wordCount; // 几乎没改
} else {
stats.aiModified += wordCount; // 改了不少
}
}
});
const total = stats.userTyped + stats.aiGenerated + stats.aiModified;
return {
originalRate: (stats.userTyped / total * 100).toFixed(1) + '%',
aiAssistedRate: (stats.aiModified / total * 100).toFixed(1) + '%',
aiDirectRate: (stats.aiGenerated / total * 100).toFixed(1) + '%',
grade: calculateGrade(stats.userTyped / total)
};
}
function calculateGrade(originalRate) {
if (originalRate > 0.9) return 'A级（完全原创）';
if (originalRate > 0.7) return 'B级（AI辅助）';
if (originalRate > 0.4) return 'C级（AI共创）';
return 'D级（AI主导）';
}
```
## 3.2 审核功能：AI初筛 + 人工复审 + 责任签名
### 功能描述
AI根据编辑的标准自动初筛稿件，把明显不合格的过滤掉，编辑只需要审核AI推荐的稿件，审核完成后签名确认，全程可追溯。
### 技术实现
**Step 1: 编辑训练AI初筛模型**
```jsx
// 编辑通过日常审稿来训练AI
function editorReviewSubmission(submissionId, decision, feedback) {
// 记录编辑的审核决定
saveReviewRecord({
editorId: currentEditor.id,
submissionId: submissionId,
decision: decision, // pass / reject / revise
feedback: feedback,
timestamp: Date.now()
});
// 提取这次审核的特征
const features = extractFeatures(submission);
// 更新AI模型
updateAIModel({
features: features,
label: decision,
editorId: currentEditor.id // 每个编辑有自己的模型
});
}
function extractFeatures(submission) {
return {
// 从AI使用报告提取
aiUsageGrade: submission.aiReport.grade,
originalRate: submission.aiReport.originalRate,
// 从内容分析
genre: analyzeGenre(submission.content),
dialogueRatio: calculateDialogueRatio(submission.content),
pacing: analyzePacing(submission.content),
// 从作者信息
authorReputation: submission.author.reputation,
authorHistory: submission.author.pastWorks
};
}
```
**Step 2: AI自动初筛新稿件**
```jsx
function autoScreenSubmissions(newSubmissions) {
const results = {
recommended: [], // 推荐编辑审核
rejected: [], // 自动拒绝
flagged: [] // 标记问题
};
newSubmissions.forEach(submission => {
// 使用编辑训练的模型预测
const prediction = aiModel.predict({
editorId: assignedEditor.id,
features: extractFeatures(submission)
});
if (prediction.confidence > 0.8) {
if (prediction.decision === 'pass') {
results.recommended.push({
submission: submission,
aiScore: prediction.score,
aiReason: prediction.reason
});
} else {
results.rejected.push({
submission: submission,
rejectReason: prediction.reason
});
}
} else {
// 信心不足，标记让编辑决定
results.flagged.push(submission);
}
});
return results;
}
```
**Step 3: 编辑人工复审**
编辑登录后看到：
```
━━━━━━━━━━━━━━━━━━━━
今日新稿：50篇
AI初筛结果：
✅ 推荐审核：5篇 ← 你需要看这些
❌ 已拒绝：40篇 （查看原因）
⚠️ 不确定：5篇 （需要你判断）
━━━━━━━━━━━━━━━━━━━━
```
编辑审核推荐的5篇，做出决定，然后签名：
```jsx
function editorFinalDecision(submissionId, decision, feedback) {
// 保存审核记录
const reviewRecord = {
submissionId: submissionId,
editorId: currentEditor.id,
editorName: currentEditor.name,
decision: decision,
feedback: feedback,
timestamp: Date.now(),
signature: generateSignature(currentEditor.id, submissionId)
};
saveReviewRecord(reviewRecord);
// 发送通知给作者
notifyAuthor(submission.authorId, {
decision: decision,
feedback: feedback,
editor: currentEditor.name
});
// 如果通过，进入下一流程（流量分配等）
if (decision === 'pass') {
moveToTrafficAllocation(submissionId);
}
}
function generateSignature(editorId, submissionId) {
// 生成数字签名（不可篡改）
return crypto.createHash('sha256')
.update(editorId + submissionId + Date.now())
.digest('hex');
}
```
### 数据存储（Notion数据库）
**审核记录表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 稿件ID | text | 稿件唯一标识 |
| 编辑ID | text | 编辑唯一标识 |
| 编辑姓名 | text | 编辑真实姓名 |
| AI初筛结果 | select | recommended / rejected / flagged |
| AI评分 | number | 0-100分 |
| AI理由 | rich_text | AI推荐/拒绝的理由 |
| 人工决定 | select | pass / reject / revise |
| 人工反馈 | rich_text | 编辑给作者的反馈 |
| 签名哈希 | text | 数字签名 |
| 审核时间 | date | 审核完成时间 |
## 3.3 信誉系统：动态评分 + 实时更新
### 功能描述
每个用户都有一个"数字简历身份证"，记录所有协作行为，实时计算信誉分数，生成信誉曲线。
### 技术实现
**信誉评分算法：**
```jsx
// 对作者的信誉评分
function calculateAuthorReputation(authorId) {
const history = getAuthorHistory(authorId);
// 四个维度评分
const scores = {
creativity: 0, // 创作诚信（30%）
collaboration: 0, // 协作态度（25%）
quality: 0, // 作品质量（25%）
reliability: 0 // 履约能力（20%）
};
// 1. 创作诚信
// 基于AI使用透明度、原创度
scores.creativity = history.submissions
.map(s => {
if (s.aiReport.grade === 'A') return 100;
if (s.aiReport.grade === 'B') return 80;
if (s.aiReport.grade === 'C') return 60;
return 40;
})
.reduce((a, b) => a + b, 0) / history.submissions.length;
// 2. 协作态度
// 基于是否按时交稿、是否接受修改意见等
const onTimeRate = history.submissions.filter(s => s.onTime).length / history.submissions.length;
const acceptFeedbackRate = history.submissions.filter(s => s.acceptedFeedback).length / history.submissions.length;
scores.collaboration = (onTimeRate * 60 + acceptFeedbackRate * 40);
// 3. 作品质量
// 基于审核通过率、读者反馈
const passRate = history.submissions.filter(s => s.passed).length / history.submissions.length;
const avgReaderScore = history.works
.map(w => w.readerRating)
.reduce((a, b) => a + b, 0) / history.works.length;
scores.quality = (passRate * 50 + avgReaderScore / 5 * 50);
// 4. 履约能力
// 基于合同执行情况
const contractCompletionRate = history.contracts.filter(c => c.completed).length / history.contracts.length;
scores.reliability = contractCompletionRate * 100;
// 加权平均
const finalScore = (
scores.creativity * 0.30 +
scores.collaboration * 0.25 +
scores.quality * 0.25 +
scores.reliability * 0.20
);
return {
totalScore: Math.round(finalScore),
breakdown: scores,
lastUpdated: Date.now()
};
}
// 对编辑的信誉评分（类似逻辑）
function calculateEditorReputation(editorId) {
// 评分维度：
// 1. 审核公正性（35%）- 是否有偏袒/打压
// 2. 专业能力（30%）- 选稿准确率
// 3. 工作效率（20%）- 审稿速度
// 4. 协作态度（15%）- 沟通是否专业
// ...
}
```
**实时更新机制：**
```jsx
// 每次有新的协作行为，更新信誉
function onCollaborationEvent(event) {
// event类型：
// - submission_reviewed（稿件被审核）
// - contract_signed（合同签署）
// - feedback_given（给出反馈）
// - deadline_missed（错过截止日期）
// etc.
const userId = event.userId;
// 重新计算信誉分
const newReputation = calculateReputation(userId);
// 保存到数据库
updateReputation(userId, newReputation);
// 记录到信誉历史（用于生成曲线）
saveReputationHistory({
userId: userId,
score: newReputation.totalScore,
breakdown: newReputation.breakdown,
timestamp: Date.now(),
triggerEvent: event.type
});
}
```
**信誉曲线可视化：**
使用Chart.js或Recharts生成曲线图：
```jsx
import { LineChart, Line, XAxis, YAxis } from 'recharts';
function ReputationChart({ userId }) {
const history = getReputationHistory(userId);
// 转换为图表数据格式
const chartData = history.map(record => ({
date: new Date(record.timestamp).toLocaleDateString(),
score: record.score
}));
return (
<LineChart width={600} height={300} data={chartData}>
<XAxis dataKey="date" />
<YAxis domain={[0, 100]} />
<Line type="monotone" dataKey="score" stroke="#8884d8" />
</LineChart>
);
}
```
### 数据存储（Notion数据库）
**用户信誉表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 用户ID | text | 唯一标识 |
| 总分 | number | 0-100分 |
| 创作诚信分 | number | 第1维度得分 |
| 协作态度分 | number | 第2维度得分 |
| 作品质量分 | number | 第3维度得分 |
| 履约能力分 | number | 第4维度得分 |
| 更新时间 | date | 最后更新时间 |
**信誉历史表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 用户ID | text | 唯一标识 |
| 分数 | number | 当时的总分 |
| 触发事件 | select | 什么事件导致分数变化 |
| 记录时间 | date | 记录时间 |
## 3.4 模块市场：分享经验 + 获得收益
### 功能描述
用户可以把自己训练的AI功能打包成"模块"，发布到市场上，其他人可以购买使用。
### 技术实现
**模块是什么？**
模块本质上是一个**封装好的AI Prompt + 配置参数**。
例如：
```jsx
// 女频爆款题材识别模块
const femaleHotTopicModule = {
id: 'module_001',
name: '女频爆款题材识别器',
description: '基于10000+女频爆款样本训练，识别题材是否符合当前市场热点',
creator: 'editor_zhang',
price: 99, // 99元/月
// 核心：这是一个精心设计的Prompt模板
promptTemplate: `
你是一个女频市场分析专家。
请分析以下小说题材是否符合当前女频市场热点：
题材：{{TOPIC}}
简介：{{SYNOPSIS}}
分析维度：
1. 题材新鲜度（0-10分）
2. 市场热度（0-10分）
3. 读者接受度（0-10分）
4. 竞争激烈度（0-10分）
5. 建议指数（0-10分）
请给出详细分析和评分。
`,
// 配置
config: {
model: 'gpt-4',
temperature: 0.7,
max_tokens: 500
},
// 使用次数（用于计算收益）
usageCount: 0
};
```
**用户如何创建模块：**
```jsx
function createModule(userId) {
// 1. 用户选择要提取的功能
// 比如："我的AI助手学会了识别爆款题材，我想分享这个能力"
// 2. 系统提取用户的Prompt历史和AI回复
const userPromptHistory = getUserAIHistory(userId);
// 3. 分析用户的Prompt模式
const pattern = analyzePromptPattern(userPromptHistory);
// 4. 生成模块模板
const moduleTemplate = generateModuleTemplate(pattern);
// 5. 用户编辑和完善
// 用户可以：
// - 修改Prompt模板
// - 设置价格
// - 写说明文档
// - 添加示例
// 6. 提交审核
submitModuleForReview({
userId: userId,
module: moduleTemplate
});
}
```
**用户如何购买和使用模块：**
```jsx
function purchaseModule(userId, moduleId) {
// 1. 支付
const payment = processPayment({
userId: userId,
amount: module.price,
type: 'monthly_subscription'
});
if (payment.success) {
// 2. 授权访问
grantModuleAccess({
userId: userId,
moduleId: moduleId,
expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000 // 30天后
});
// 3. 安装到用户的AI助手
installModuleToAI({
userId: userId,
moduleId: moduleId
});
}
}
// 用户使用模块
function useModule(userId, moduleId, inputs) {
// 检查权限
if (!hasModuleAccess(userId, moduleId)) {
return { error: '您没有权限使用此模块' };
}
// 获取模块
const module = getModule(moduleId);
// 填充Prompt模板
const prompt = fillPromptTemplate(module.promptTemplate, inputs);
// 调用AI API
const aiResponse = await callAI({
model: module.config.model,
prompt: prompt,
temperature: module.config.temperature,
max_tokens: module.config.max_tokens
});
// 记录使用（用于分润）
logModuleUsage({
moduleId: moduleId,
userId: userId,
timestamp: Date.now()
});
return aiResponse;
}
```
**分润机制：**
```jsx
function calculateModuleRevenue(moduleId, month) {
// 获取本月的购买记录
const purchases = getModulePurchases(moduleId, month);
// 总收入
const totalRevenue = purchases.reduce((sum, p) => sum + p.amount, 0);
// 分成比例
const creatorShare = totalRevenue * 0.70; // 创作者70%
const platformShare = totalRevenue * 0.30; // 平台30%
// 如果模块进入平台底层（成为官方功能）
if (module.isCorePlatformModule) {
// 分成比例变为50:50
creatorShare = totalRevenue * 0.50;
platformShare = totalRevenue * 0.50;
// 但是：这个模块会被更多人使用，总收入更高
// 而且：即使创作者不再更新，依然持续分润
}
return {
total: totalRevenue,
creatorEarnings: creatorShare,
platformEarnings: platformShare
};
}
```
### 数据存储（Notion数据库）
**模块市场表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 模块ID | text | 唯一标识 |
| 模块名称 | text | 模块名称 |
| 创建者ID | text | 创建者 |
| 分类 | select | 女频/男频/通用 |
| 功能类型 | select | 创作辅助/审核工具/数据分析 |
| 价格 | number | 月订阅价格 |
| 订阅人数 | number | 当前订阅数 |
| 总收入 | number | 累计收入 |
| 评分 | number | 用户评分 |
| 是否底层模块 | checkbox | 是否进入平台底层 |
**模块订阅表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 用户ID | text | 订阅者 |
| 模块ID | text | 模块 |
| 开始时间 | date | 订阅开始 |
| 结束时间 | date | 订阅结束 |
| 支付金额 | number | 支付金额 |
| 状态 | select | active / expired |
---
（由于长度限制，知秋将在下一个回复中继续完成说明书的后续部分）
## 3.5 跨平台协作：统一接入 + 公开招募
### 功能描述
所有网文平台（番茄、七猫、起点等）都可以接入本平台，作者可以在平台上看到所有平台发布的定制书需求，自由申请合作。
### 技术实现
**平台接入API：**
```jsx
// 平台接入流程
// 1. 平台注册
function platformRegister(platformInfo) {
return {
platformId: generatePlatformId(),
platformName: platformInfo.name,
apiKey: generateApiKey(),
apiSecret: generateApiSecret(),
webhookUrl: platformInfo.webhookUrl, // 接收通知的地址
status: 'pending_approval'
};
}
// 2. 平台发布定制书需求
function publishCustomBookRequest(platformId, requestData) {
// API调用示例
const response = await fetch('https://guanghu-platform.com/api/custom-book', {
method: 'POST',
headers: {
'Authorization': `Bearer ${platformApiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
platformId: platformId,
title: requestData.title,
genre: requestData.genre,
wordCount: requestData.wordCount,
payment: requestData.payment,
deadline: requestData.deadline,
requirements: {
minReputation: 80, // 要求作者信誉分>80
maxAIUsage: 0.3, // 要求AI使用<30%
pastExperience: true // 要求有相关经验
},
description: requestData.description
})
});
return response.json();
}
// 3. 作者申请定制书
function authorApplyCustomBook(authorId, requestId) {
// 系统自动检查作者是否符合要求
const author = getAuthor(authorId);
const request = getCustomBookRequest(requestId);
// 检查信誉分
if (author.reputation < request.requirements.minReputation) {
return { success: false, reason: '信誉分不足' };
}
// 检查AI使用率
const avgAIUsage = calculateAvgAIUsage(authorId);
if (avgAIUsage > request.requirements.maxAIUsage) {
return { success: false, reason: 'AI使用率过高' };
}
// 检查经验
if (request.requirements.pastExperience) {
const hasExperience = checkGenreExperience(authorId, request.genre);
if (!hasExperience) {
return { success: false, reason: '缺少相关题材经验' };
}
}
// 符合条件，提交申请
submitApplication({
authorId: authorId,
requestId: requestId,
authorProfile: {
reputation: author.reputation,
pastWorks: author.works.filter(w => w.genre === request.genre),
aiUsageReport: generateAIUsageReport(authorId)
}
});
// 通知平台方
notifyPlatform(request.platformId, {
type: 'new_application',
requestId: requestId,
authorId: authorId
});
return { success: true };
}
// 4. 平台选择作者
function platformSelectAuthor(platformId, requestId, selectedAuthorId) {
// 创建合作合同
const contract = createContract({
platformId: platformId,
authorId: selectedAuthorId,
requestId: requestId,
terms: getCustomBookRequest(requestId)
});
// 双方签署（数字签名）
const platformSignature = signContract(platformId, contract.id);
const authorSignature = signContract(selectedAuthorId, contract.id);
// 合同生效
activateContract(contract.id);
return contract;
}
```
**公开招募界面：**
用户看到的界面：
```
┌─────────────────────────────────────────┐
│ 📢 定制书公开招募 │
├─────────────────────────────────────────┤
│ │
│ [筛选条件] │
│ 平台：[全部▼] [番茄] [七猫] [起点] │
│ 题材：[全部▼] [现言] [古言] [玄幻] │
│ 稿酬：[全部▼] [5万+] [10万+] [20万+] │
│ │
├─────────────────────────────────────────┤
│ │
│ 🔥 热门需求 │
│ │
│ ┌─────────────────────────┐ │
│ │ 📱 番茄小说 + 七猫小说 │ │
│ │ 联合招募 │ │
│ │ │ │
│ │ 【霸总文】 │ │
│ │ 字数：80万字 │ │
│ │ 稿酬：15万元 │ │
│ │ 截止：2026-02-28 │ │
│ │ │ │
│ │ 要求： │ │
│ │ • 信誉分>80分 │ │
│ │ • 有霸总文成功经验 │ │
│ │ • AI使用<30% │ │
│ │ │ │
│ │ 已申请：23人 │ │
│ │ [立即申请] │ │
│ └─────────────────────────┘ │
│ │
│ （更多需求...） │
│ │
└─────────────────────────────────────────┘
```
### 数据存储（Notion数据库）
**定制书需求表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 需求ID | text | 唯一标识 |
| 发布平台 | select | 番茄/七猫/起点等 |
| 题材 | select | 现言/古言/玄幻等 |
| 字数 | number | 总字数 |
| 稿酬 | number | 总稿酬 |
| 截止日期 | date | 申请截止 |
| 要求_信誉分 | number | 最低信誉分要求 |
| 要求_AI使用率 | number | 最高AI使用率 |
| 申请人数 | number | 当前申请数 |
| 状态 | select | 招募中/已满/已关闭 |
---
# 第四部分：技术架构说明
## 4.1 整体技术架构
### 架构图
```
用户层（浏览器/手机App）
↓
[前端界面]
React + Tailwind CSS
↓
[API Gateway]
统一入口 + 鉴权
↓
┌────────────────────────────────┐
│ 后端服务层 (Node.js) │
├────────────────────────────────┤
│ • 用户服务 │
│ • AI助手服务 │
│ • 创作服务 │
│ • 审核服务 │
│ • 信誉服务 │
│ • 模块市场服务 │
└────────────────────────────────┘
↓
┌──────┬──────┬──────┬──────┐
│ │ │ │ │
Notion AI 支付 第三方
数据库 API 接口 平台API
```
### 技术选型详细说明
#### 前端技术栈
**框架：React 18**
- 为什么选择：组件化、生态成熟、性能好
- 安装：`npm install react react-dom`
**样式：Tailwind CSS**
- 为什么选择：快速开发、响应式、现代化
- 安装：`npm install tailwindcss`
**UI组件库：shadcn/ui**
- 为什么选择：现代、可定制、无额外依赖
- 安装：`npx shadcn-ui@latest init`
**富文本编辑器：Slate.js**
- 为什么选择：完全可控、可扩展
- 安装：`npm install slate slate-react`
**实时通信：[Socket.io](http://Socket.io)**
- 为什么选择：实现AI助手实时对话
- 安装：`npm install [socket.io](http://socket.io)-client`
#### 后端技术栈
**运行环境：Node.js 18+**
- 为什么选择：JavaScript全栈、性能好、生态丰富
**框架：Express**
- 为什么选择：简单、灵活、中间件丰富
- 安装：`npm install express`
**数据库：Notion API**
- 为什么选择：可视化管理、易于备份、无需运维
- 安装：`npm install @notionhq/client`
**AI集成：**
- OpenAI API (ChatGPT)
- 安装：`npm install openai`
- Anthropic API (Claude)
- 安装：`npm install @anthropic-ai/sdk`
**身份认证：JWT**
- 为什么选择：无状态、易于扩展
- 安装：`npm install jsonwebtoken`
**实时通信：[Socket.io](http://Socket.io)**
- 服务端版本：`npm install [socket.io](http://socket.io)`
#### 部署方案
**托管平台：Vercel（推荐）**
- 为什么选择：
- 自动部署
- 全球CDN
- 免费额度充足
- 支持Node.js
**备选方案：Railway / Render**
**域名：** 自定义域名（如 [guanghu.cn](http://guanghu.cn)）
## 4.2 核心代码示例
### 4.2.1 AI助手对话系统
**前端代码：**
```jsx
// components/AIAssistant.jsx
import { useState, useEffect } from 'react';
import { io } from 'socket.io-client';
export function AIAssistant({ userId }) {
const [messages, setMessages] = useState([]);
const [input, setInput] = useState('');
const [socket, setSocket] = useState(null);
// 连接WebSocket
useEffect(() => {
const newSocket = io('https://api.guanghu-platform.com');
newSocket.on('connect', () => {
console.log('AI助手已连接');
});
newSocket.on('ai_response', (data) => {
setMessages(prev => [...prev, {
role: 'assistant',
content: data.message,
timestamp: Date.now()
}]);
});
setSocket(newSocket);
return () => newSocket.close();
}, []);
// 发送消息
const sendMessage = () => {
if (!input.trim()) return;
// 添加用户消息到界面
setMessages(prev => [...prev, {
role: 'user',
content: input,
timestamp: Date.now()
}]);
// 发送到服务器
socket.emit('user_message', {
userId: userId,
message: input
});
setInput('');
};
return (
<div className="flex flex-col h-screen">
{/* AI助手头像 */}
<div className="p-4 border-b">
<div className="flex items-center gap-3">
<div className="w-12 h-12 rounded-full bg-blue-500 flex items-center justify-center text-white">
🤖
</div>
<div>
<div className="font-semibold">小光</div>
<div className="text-sm text-gray-500">您的AI创作伙伴</div>
</div>
</div>
</div>
{/* 对话历史 */}
<div className="flex-1 overflow-y-auto p-4 space-y-4">
{messages.map((msg, idx) => (
<div key={idx} className={`flex ${msg.role === 'user' ? 'justify-end' : 'justify-start'}`}>
<div className={`max-w-[70%] rounded-lg p-3 ${
msg.role === 'user'
? 'bg-blue-500 text-white'
: 'bg-gray-100 text-gray-900'
}`}>
{msg.content}
</div>
</div>
))}
</div>
{/* 输入框 */}
<div className="p-4 border-t">
<div className="flex gap-2">
<input
type="text"
value={input}
onChange={(e) => setInput(e.target.value)}
onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
placeholder="和小光说点什么..."
className="flex-1 px-4 py-2 border rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
/>
<button
onClick={sendMessage}
className="px-6 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600"
>
发送
</button>
</div>
</div>
</div>
);
}
```
**后端代码：**
```jsx
// server/aiAssistant.js
const { Server } = require('socket.io');
const OpenAI = require('openai');
const { Client } = require('@notionhq/client');
const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});
const notion = new Client({
auth: process.env.NOTION_API_KEY
});
function setupAIAssistant(httpServer) {
const io = new Server(httpServer, {
cors: {
origin: process.env.FRONTEND_URL,
methods: ['GET', 'POST']
}
});
io.on('connection', (socket) => {
console.log('用户连接:', socket.id);
socket.on('user_message', async (data) => {
try {
// 1. 获取用户的对话历史（从Notion）
const conversationHistory = await getConversationHistory(
data.userId
);
// 2. 构建消息数组
const messages = [
{
role: 'system',
content: `你是${data.userId}的AI创作助手。你需要：
1. 记住用户的写作风格和习惯
2. 主动提供建设性建议
3. 帮助用户提高创作效率
4. 保持友好和专业的语气`
},
...conversationHistory,
{
role: 'user',
content: data.message
}
];
// 3. 调用OpenAI API
const completion = await openai.chat.completions.create({
model: 'gpt-4',
messages: messages,
temperature: 0.7,
max_tokens: 500
});
const aiResponse = completion.choices[0].message.content;
// 4. 保存对话到Notion
await saveConversation({
userId: data.userId,
userMessage: data.message,
aiResponse: aiResponse,
timestamp: new Date().toISOString()
});
// 5. 发送响应给用户
socket.emit('ai_response', {
message: aiResponse
});
} catch (error) {
console.error('AI处理错误:', error);
socket.emit('ai_response', {
message: '抱歉，我遇到了一些问题，请稍后再试。',
error: true
});
}
});
socket.on('disconnect', () => {
console.log('用户断开:', socket.id);
});
});
}
// 获取对话历史
async function getConversationHistory(userId) {
const response = await notion.databases.query({
database_id: process.env.NOTION_CONVERSATION_DB_ID,
filter: {
property: 'userId',
rich_text: {
equals: userId
}
},
sorts: [
{
property: 'timestamp',
direction: 'ascending'
}
],
page_size: 10 // 只取最近10条对话
});
return response.results.flatMap(page => [
{
role: 'user',
content: page.properties.userMessage.rich_text[0].plain_text
},
{
role: 'assistant',
content: page.properties.aiResponse.rich_text[0].plain_text
}
]);
}
// 保存对话
async function saveConversation(data) {
await notion.pages.create({
parent: {
database_id: process.env.NOTION_CONVERSATION_DB_ID
},
properties: {
userId: {
rich_text: [{ text: { content: data.userId } }]
},
userMessage: {
rich_text: [{ text: { content: data.userMessage } }]
},
aiResponse: {
rich_text: [{ text: { content: data.aiResponse } }]
},
timestamp: {
date: { start: data.timestamp }
}
}
});
}
module.exports = { setupAIAssistant };
```
### 4.2.2 AI使用追踪系统
```jsx
// server/aiUsageTracking.js
const { Client } = require('@notionhq/client');
const notion = new Client({
auth: process.env.NOTION_API_KEY
});
// 记录AI工具调用
async function trackAIUsage(data) {
const { userId, chapterId, toolName, input, output, timestamp } = data;
// 1. 保存到AI使用记录表
await notion.pages.create({
parent: {
database_id: process.env.NOTION_AI_USAGE_DB_ID
},
properties: {
userId: { rich_text: [{ text: { content: userId } }] },
chapterId: { rich_text: [{ text: { content: chapterId } }] },
toolName: { select: { name: toolName } },
inputLength: { number: input.length },
outputLength: { number: output.length },
timestamp: { date: { start: timestamp } }
}
});
// 2. 更新章节的AI使用统计
await updateChapterAIStats(chapterId);
}
// 更新章节AI统计
async function updateChapterAIStats(chapterId) {
// 获取这个章节的所有AI使用记录
const usageRecords = await notion.databases.query({
database_id: process.env.NOTION_AI_USAGE_DB_ID,
filter: {
property: 'chapterId',
rich_text: { equals: chapterId }
}
});
// 获取章节内容
const chapter = await getChapter(chapterId);
const totalWords = chapter.content.length;
// 计算AI生成的字数
const aiGeneratedWords = usageRecords.results.reduce(
(sum, record) => sum + record.properties.outputLength.number,
0
);
// 计算比例
const aiUsageRate = aiGeneratedWords / totalWords;
// 确定等级
let grade;
if (aiUsageRate < 0.1) grade = 'A级（完全原创）';
else if (aiUsageRate < 0.3) grade = 'B级（AI辅助）';
else if (aiUsageRate < 0.6) grade = 'C级（AI共创）';
else grade = 'D级（AI主导）';
// 更新章节
await notion.pages.update({
page_id: chapterId,
properties: {
aiUsageRate: { number: aiUsageRate },
aiGrade: { select: { name: grade } }
}
});
}
module.exports = { trackAIUsage };
```
---
# 第五部分：使用流程演示
## 5.1 完整用户旅程：作者小红的一天
### 上午9:00 - 登录平台
**小红打开电脑，访问 [guanghu.cn](http://guanghu.cn)**
```
登录界面：
┌─────────────────────────────────┐
│ 🌟 光湖码字·欢迎回来 │
├─────────────────────────────────┤
│ │
│ 手机号：[___________] │
│ 验证码：[_____] [获取验证码] │
│ │
│ [ 登 录 ] │
│ │
│ 首次使用？[立即注册] │
└─────────────────────────────────┘
```
登录后：
```
┌─────────────────────────────────────────┐
│ 🤖 小光（你的AI助手） │
│ │
│ "早上好，小红！" │
│ │
│ "昨天你写到《霸总的小娇妻》第8章， │
│ 进度是2500/3000字。今天继续吗？" │
│ │
│ [继续写作] [查看数据] [看看新需求] │
└─────────────────────────────────────────┘
```
### 上午9:30 - 开始创作
小红点击【继续写作】
系统自动：
1. 打开编辑器
2. 加载第8章内容
3. 光标定位到上次停下的位置
4. 右侧显示大纲提示
```
编辑器界面：
┌─────────────────────────────────────────────────────┐
│ 《霸总的小娇妻》第8章 2567/3000字 │
├─────────────────────────────────────────────────────┤
│ │
│ [正文区域] │
│ │
│ "林娇娇推开办公室的门，看到陈总裁正在打电话。 │
│ 她犹豫了一下，准备退出去..." │
│ │ │
│ [光标在此] │
│ │
├─────────────────────────────────────────────────────┤
│ 🤖 小光： │
│ │
│ "这里可以加一些内心戏，展现女主的纠结。 │
│ 要不要我帮你生成一个参考？" │
│ │
│ [ 生成参考 ] [ 不用了 ] │
└─────────────────────────────────────────────────────┘
```
小红点击【生成参考】
系统后台发生：
```jsx
// 1. 调用AI
const aiSuggestion = await callAI({
prompt: "女主看到男主在打电话，犹豫要不要进去，生成内心戏",
context: chapter8Content
});
// 2. 记录AI使用
trackAIUsage({
userId: 'xiaohong_001',
chapterId: 'chapter_8',
toolName: 'ChatGPT',
input: prompt,
output: aiSuggestion,
timestamp: Date.now()
});
// 3. 显示给用户
```
AI生成的内容显示在右侧：
```
┌──────────────────────────────────┐
│ 💡 AI生成的参考内容： │
├──────────────────────────────────┤
│ │
│ 林娇娇站在门口，心里七上八下。 │
│ 她知道陈总裁最讨厌被人打扰， │
│ 但这份文件确实很急... │
│ │
│ [采用] [修改后采用] [不采用] │
└──────────────────────────────────┘
```
小红选择【修改后采用】，改了几个字：
```
原文：林娇娇站在门口，心里七上八下。
小红改为：林娇娇站在门口，内心忐忑不安。
```
系统记录：
```jsx
{
source: 'ai_modified',
aiOriginal: "林娇娇站在门口，心里七上八下。",
userModified: "林娇娇站在门口，内心忐忑不安。",
modificationRate: 0.25 // 改了25%
}
```
### 中午12:00 - 完成章节
小红写完3000字，点击【完成章节】
系统自动生成AI使用报告：
```
┌──────────────────────────────────────┐
│ 📊 第8章 AI使用报告 │
├──────────────────────────────────────┤
│ │
│ 总字数：3027字 │
│ │
│ 📝 原创内容：2100字 (69.4%) │
│ ████████████████░░░░░ │
│ │
│ 🤝 AI辅助后人工精修：750字 (24.8%) │
│ ████████░░░░░░░░░░ │
│ │
│ 🤖 AI直接生成：177字 (5.8%) │
│ ██░░░░░░░░░░░░░░░░ │
│ │
│ ⭐ 综合评级：B级（AI辅助） │
│ │
│ [确认无误] [查看详细] [重新计算] │
└──────────────────────────────────────┘
```
小红确认后，提交给编辑审核。
### 下午2:00 - 查看定制书需求
小红想接一个定制书赚外快。
```
小红："小光，帮我看看有什么适合我的定制书需求"
小光："好的！根据你的创作风格和信誉分（85分），
我筛选出3个适合你的需求："
```
系统显示：
```
┌─────────────────────────────────────────┐
│ 🎯 为你推荐的定制书需求 │
├─────────────────────────────────────────┤
│ │
│ 1️⃣ 【最匹配】 │
│ 📱 番茄小说 │
│ 题材：现代霸总文 │
│ 字数：60万字 │
│ 稿酬：12万元 │
│ 匹配度：95% ⭐⭐⭐⭐⭐ │
│ │
│ 为什么推荐： │
│ • 你有3部霸总文成功经验 │
│ • 你的信誉分(85)高于要求(80) │
│ • 你的AI使用率(18%)符合要求(<30%) │
│ │
│ [查看详情] [立即申请] │
│ │
├─────────────────────────────────────────┤
│ 2️⃣ ... │
│ 3️⃣ ... │
└─────────────────────────────────────────┘
```
小红点击【立即申请】
系统自动：
1. 检查资质（通过）
2. 生成申请材料（包含作品集、AI使用报告、信誉分）
3. 提交给平台方
4. 通知小红："已提交，预计3天内有结果"
---
## 5.2 完整用户旅程：编辑李编的一天
### 上午9:00 - 登录查看待审稿件
```
李编登录后看到：
🤖 小章（李编的AI助手）：
"早上好，李编！昨晚新增投稿15篇。
我已经按照你的标准初筛了：
✅ 推荐审核：3篇（质量优秀，AI使用合理）
⚠️ 需要注意：2篇（质量尚可，但有些问题）
❌ 已打回：10篇（AI使用过度或质量太差）
今天想先看哪一类？"
```
李编："先看推荐的3篇"
### 上午9:30 - 审核第一篇
```
┌─────────────────────────────────────────────┐
│ 📄 投稿详情 │
├─────────────────────────────────────────────┤
│ │
│ 作者：笔名xxx（信誉分：85） │
│ 作品：《霸总的小娇妻》第8章 │
│ 字数：3027字 │
│ │
│ 🤖 AI使用情况： │
│ • 原创：69.4% ████████████░░░ │
│ • AI辅助：24.8% ████░░░░░░░░ │
│ • AI生成：5.8% █░░░░░░░░░░░ │
│ • 评级：B级（AI辅助） │
│ │
│ 🎯 小章的初步判断： │
│ "这是一篇质量不错的投稿： │
│ • AI使用合理，以原创为主 │
│ • 对话自然，节奏流畅 │
│ • 人物性格鲜明 │
│ • 建议：通过，可签约" │
│ │
│ [阅读全文] [通过] [退回] [需修改] │
└─────────────────────────────────────────────┘
```
李编点击【阅读全文】，看完后同意小章的判断，点击【通过】。
系统要求数字签名：
```
┌────────────────────────────────┐
│ ✍️ 审核签名确认 │
├────────────────────────────────┤
│ │
│ 你即将通过这篇投稿。 │
│ │
│ 请确认： │
│ • 你已认真阅读全文 │
│ • 你认为质量符合标准 │
│ • 你为这个决定负责 │
│ │
│ 审核记录将被永久保存。 │
│ │
│ [输入密码确认] [取消] │
└────────────────────────────────┘
```
李编输入密码确认。
系统记录：
```jsx
{
submissionId: 'sub_8888',
editorId: 'ED-7M-001',
editorName: '李编辑',
decision: 'pass',
aiInitialJudgment: 'recommend',
humanDecision: 'pass',
isConsistent: true, // 人工决定和AI一致
timestamp: '2026-01-22T09:45:00Z',
signature: '8f3a2b1c...' // 数字签名
}
```
小红收到通知：
```
🎉 好消息！
你的《霸总的小娇妻》第8章已通过审核！
审核编辑：李编辑
审核时间：2026-01-22 09:45
评分：85分
下一步：进入流量分配评审
```
---
（知秋继续在下一部分完成剩余内容...）
## 3.5 跨平台协作：统一接口 + 公开招募
### 功能描述
不同网文平台（番茄、七猫、起点等）都可以接入本平台，在平台上公开发布定制书需求，作者可以自由申请，整个过程透明公开。
### 技术实现
**平台接入API：**
```jsx
// 平台方调用API接入
class PlatformIntegration {
constructor(platformId, apiKey) {
this.platformId = platformId;
this.apiKey = apiKey;
}
// 1. 发布定制书需求
async postCustomBookRequest(request) {
return await fetch('https://api.guanghu.com/v1/custom-books', {
method: 'POST',
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
platformId: this.platformId,
genre: request.genre, // 类型
wordCount: request.wordCount, // 字数要求
payment: request.payment, // 稿酬
deadline: request.deadline, // 截止日期
requirements: request.requirements, // 具体要求
minReputation: request.minReputation || 80 // 最低信誉分要求
})
});
}
// 2. 查看申请者列表
async getApplicants(requestId) {
return await fetch(`https://api.guanghu.com/v1/custom-books/${requestId}/applicants`, {
headers: {
'Authorization': `Bearer ${this.apiKey}`
}
});
}
// 3. 选择作者
async selectAuthor(requestId, authorId) {
return await fetch(`https://api.guanghu.com/v1/custom-books/${requestId}/select`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
authorId: authorId
})
});
}
// 4. 接收稿件
async receiveSubmission(submissionId) {
const submission = await fetch(`https://api.guanghu.com/v1/submissions/${submissionId}`, {
headers: {
'Authorization': `Bearer ${this.apiKey}`
}
});
// 返回包含AI使用报告的完整稿件
return {
content: submission.content,
aiReport: submission.aiReport,
authorReputation: submission.authorReputation
};
}
}
```
**作者看到的界面：**
```
┌─────────────────────────────────────────┐
│ 📢 跨平台定制书招募 │
├─────────────────────────────────────────┤
│ │
│ 🔥 番茄小说 × 七猫免费 │
│ 联合招募 │
│ │
│ 题材：现代霸总 + 甜宠 │
│ 字数：80万字 │
│ 稿酬：15万元 │
│ 截止：2026-03-01 │
│ │
│ 要求： │
│ ✅ 信誉分 > 80分 │
│ ✅ 有霸总文成功经验 │
│ ✅ AI辅助 < 30% │
│ │
│ 当前申请：12人 │
│ 你的资格：✅ 符合要求 │
│ │
│ [立即申请] [查看详情] │
│ │
└─────────────────────────────────────────┘
```
**系统自动匹配：**
```jsx
function autoMatchAuthorsForRequest(requestId) {
const request = getCustomBookRequest(requestId);
// 筛选符合条件的作者
const eligibleAuthors = getAllAuthors().filter(author => {
// 1. 信誉分符合
if (author.reputation < request.minReputation) return false;
// 2. 有相关经验
const hasExperience = author.works.some(work =>
work.genre === request.genre && work.performance === 'good'
);
if (!hasExperience) return false;
// 3. AI使用符合要求
const avgAIUsage = author.works.reduce((sum, w) => sum + w.aiUsageRate, 0) / author.works.length;
if (avgAIUsage > 30) return false;
return true;
});
// 按匹配度排序
const ranked = eligibleAuthors.map(author => ({
author: author,
matchScore: calculateMatchScore(author, request)
})).sort((a, b) => b.matchScore - a.matchScore);
return ranked;
}
function calculateMatchScore(author, request) {
let score = 0;
// 信誉分（40%）
score += (author.reputation / 100) * 40;
// 经验匹配度（30%）
const relevantWorks = author.works.filter(w => w.genre === request.genre);
const experienceScore = Math.min(relevantWorks.length / 5, 1) * 30;
score += experienceScore;
// AI使用合理度（20%）
const aiScore = author.avgAIUsage < 15 ? 20 : (30 - author.avgAIUsage) / 15 * 20;
score += Math.max(0, aiScore);
// 履约能力（10%）
score += (author.contractCompletionRate / 100) * 10;
return Math.round(score);
}
```
### 数据存储（Notion数据库）
**定制书需求表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 需求ID | text | 唯一标识 |
| 发布平台 | select | 番茄/七猫/起点等 |
| 题材 | select | 现言/古言/玄幻等 |
| 字数 | number | 要求字数 |
| 稿酬 | number | 稿酬金额 |
| 截止日期 | date | 申请截止日期 |
| 最低信誉分 | number | 要求的最低信誉 |
| 状态 | select | 招募中/已选定/已完成 |
| 申请人数 | number | 当前申请人数 |
**申请记录表：**
| 字段 | 类型 | 说明 |
| --- | --- | --- |
| 需求ID | text | 对应的需求 |
| 作者ID | text | 申请的作者 |
| 申请时间 | date | 申请时间 |
| 匹配分数 | number | 系统计算的匹配度 |
| 状态 | select | 待审核/已选中/未选中 |
---
# 第四部分：技术架构说明
## 4.1 整体架构图
```
┌─────────────────────────────────────────────────────────┐
│ 用户层 │
│ [作者客户端] [编辑客户端] [运营客户端] [平台客户端] │
└────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ API网关层 │
│ - 身份认证 - 权限控制 - 流量限制 - API路由 │
└────────────────────┬────────────────────────────────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ 人格体服务│ │ 创作服务 │ │ 审核服务 │
│ │ │ │ │ │
│ -对话管理│ │ -编辑器 │ │ -AI初筛 │
│ -记忆管理│ │ -AI调用 │ │ -人工审核│
│ -任务执行│ │ -留痕记录│ │ -签名管理│
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │
└─────────────┼─────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ 数据层 │
│ │
│ [Notion数据库] [Redis缓存] [对象存储] │
│ │
│ - 用户数据 - 会话缓存 - 文件存储 │
│ - 创作记录 - AI响应缓存 - 图片存储 │
│ - 审核记录 - 实时数据 │
│ - 信誉数据 │
└─────────────────────────────────────────────────────────┘
▲
│
┌─────────────────────────────────────────────────────────┐
│ 外部服务层 │
│ │
│ [OpenAI API] [Anthropic API] [各平台API] │
└─────────────────────────────────────────────────────────┘
```
## 4.2 技术选型
### 前端技术栈
**核心框架：**
- React 18 - UI框架
- TypeScript - 类型安全
- Vite - 构建工具
**UI组件：**
- Tailwind CSS - 样式框架
- shadcn/ui - 基础组件库
- Radix UI - 无障碍组件
**状态管理：**
- Zustand - 轻量级状态管理
- React Query - 服务端状态管理
**实时通信：**
- [Socket.io](http://Socket.io) Client - WebSocket客户端
- EventSource - Server-Sent Events
**富文本编辑：**
- Slate.js - 富文本编辑器框架
- 或 ProseMirror - 备选方案
**数据可视化：**
- Recharts - 图表库
- D3.js - 复杂可视化
### 后端技术栈
**核心框架：**
- Node.js - 运行环境
- Express - Web框架
- TypeScript - 类型安全
**数据库：**
- Notion API - 主数据库（结构化数据）
- Redis - 缓存 + 会话存储
- PostgreSQL - 备选（如需要复杂查询）
**AI集成：**
- OpenAI SDK - GPT-4等
- Anthropic SDK - Claude等
- LangChain - AI应用框架
**文件存储：**
- AWS S3 - 对象存储
- 或 阿里云OSS - 国内备选
**任务队列：**
- Bull - Redis-based任务队列
- 用于异步处理AI调用、报告生成等
**实时通信：**
- [Socket.io](http://Socket.io) - WebSocket服务器
### 部署架构
**容器化：**
- Docker - 容器化
- Docker Compose - 本地开发
**云服务：**
- AWS / 阿里云 / 腾讯云
- ECS - 计算实例
- RDS - 数据库（如需要）
- OSS - 对象存储
**负载均衡：**
- Nginx - 反向代理 + 负载均衡
- PM2 - Node.js进程管理
**监控告警：**
- Sentry - 错误监控
- Datadog / CloudWatch - 性能监控
## 4.3 关键技术实现
### 人格体对话系统
```jsx
// 人格体对话引擎
class PersonalityEngine {
constructor(userId) {
this.userId = userId;
this.memory = new MemoryManager(userId);
this.context = [];
}
async chat(userMessage) {
// 1. 加载用户记忆
const userMemory = await this.memory.load();
// 2. 构建上下文
const context = this.buildContext(userMessage, userMemory);
// 3. 调用AI
const aiResponse = await this.callAI(context);
// 4. 解析AI意图
const intent = this.parseIntent(aiResponse);
// 5. 执行动作（如果AI想执行某个操作）
if (intent.action) {
await this.executeAction(intent.action);
}
// 6. 更新记忆
await this.memory.update({
userMessage: userMessage,
aiResponse: aiResponse.text,
timestamp: Date.now()
});
// 7. 返回响应
return {
text: aiResponse.text,
action: intent.action,
suggestions: aiResponse.suggestions
};
}
buildContext(userMessage, userMemory) {
return [
// 系统提示词
{
role: 'system',
content: `你是用户的AI写作助手，名字是"小光"。
用户信息：
- 姓名：${userMemory.userName}
- 常写题材：${userMemory.favoriteGenre}
- 写作习惯：${userMemory.writingHabits}
你的职责：
1. 帮助用户创作（提供灵感、扩写、优化）
2. 管理用户的创作项目（打开文档、查看进度）
3. 提醒和建议（写作时间、字数目标）
重要：当用户要求你执行操作时，在回复中包含<action>标签。
例如：<action type="open_document" id="doc_123">已为你打开第7章</action>`
},
// 历史对话（最近10轮）
...this.context.slice(-10),
// 当前消息
{
role: 'user',
content: userMessage
}
];
}
async callAI(context) {
const response = await fetch('https://api.openai.com/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
model: 'gpt-4',
messages: context,
temperature: 0.7
})
});
const data = await response.json();
return {
text: data.choices[0].message.content,
suggestions: [] // 可以添加建议
};
}
parseIntent(aiResponse) {
// 解析AI回复中的<action>标签
const actionMatch = aiResponse.text.match(/<action type="([^"]+)" id="([^"]+)">/);
if (actionMatch) {
return {
action: {
type: actionMatch[1],
id: actionMatch[2]
}
};
}
return { action: null };
}
async executeAction(action) {
switch(action.type) {
case 'open_document':
// 打开文档
await this.openDocument(action.id);
break;
case 'create_document':
// 创建新文档
await this.createDocument(action);
break;
// 其他动作...
}
}
}
```
### 永久记忆系统
```jsx
// 记忆管理系统
class MemoryManager {
constructor(userId) {
this.userId = userId;
this.notionClient = new NotionClient();
}
async load() {
// 从Notion加载用户记忆
const memoryDB = await this.notionClient.databases.query({
database_id: MEMORY_DATABASE_ID,
filter: {
property: 'user_id',
rich_text: {
equals: this.userId
}
}
});
// 解析记忆
return {
userName: this.extract(memoryDB, 'user_name'),
favoriteGenre: this.extract(memoryDB, 'favorite_genre'),
writingHabits: this.extract(memoryDB, 'writing_habits'),
currentProjects: this.extract(memoryDB, 'current_projects'),
preferences: this.extract(memoryDB, 'preferences')
};
}
async update(newMemory) {
// 分析新的对话，提取值得记住的信息
const insights = await this.extractInsights(newMemory);
if (insights.length > 0) {
// 保存到Notion
for (const insight of insights) {
await this.notionClient.pages.create({
parent: { database_id: MEMORY_DATABASE_ID },
properties: {
user_id: { rich_text: [{ text: { content: this.userId }}]},
memory_type: { select: { name: insight.type }},
content: { rich_text: [{ text: { content: insight.content }}]},
timestamp: { date: { start: new Date().toISOString() }}
}
});
}
}
}
async extractInsights(conversation) {
// 使用AI分析对话，提取值得记住的信息
const analysis = await this.callAI({
system: '你是一个记忆提取专家。分析对话，提取值得长期记住的信息。',
user: `对话内容：
用户：${conversation.userMessage}
AI：${conversation.aiResponse}
请提取值得记住的信息（用户偏好、习惯、项目进展等）。
返回JSON格式：[{"type": "偏好/习惯/项目", "content": "具体内容"}]`
});
try {
return JSON.parse(analysis);
} catch {
return [];
}
}
extract(memoryDB, field) {
// 从Notion数据中提取特定字段
const records = memoryDB.results.filter(r =>
r.properties.memory_type?.select?.name === field
);
if (records.length === 0) return null;
// 返回最新的记录
return records[0].properties.content.rich_text[0]?.text?.content;
}
}
```
### AI使用追踪系统
```jsx
// AI调用代理（拦截所有AI调用）
class AIProxy {
async call(params) {
const { userId, tool, prompt } = params;
// 1. 调用前记录
const callId = generateId();
await this.logBefore({
callId: callId,
userId: userId,
tool: tool,
prompt: prompt,
timestamp: Date.now()
});
// 2. 实际调用AI
let response;
try {
response = await this.callActualAI(tool, prompt);
} catch (error) {
// 记录失败
await this.logError(callId, error);
throw error;
}
// 3. 调用后记录
await this.logAfter({
callId: callId,
response: response,
timestamp: Date.now()
});
// 4. 返回结果
return {
content: response,
callId: callId // 返回调用ID，用于后续追踪
};
}
async callActualAI(tool, prompt) {
switch(tool) {
case 'gpt-4':
return await this.callOpenAI('gpt-4', prompt);
case 'claude':
return await this.callClaude(prompt);
default:
throw new Error('Unknown AI tool');
}
}
async logBefore(data) {
await saveToNotion({
database: 'ai_usage_log',
data: {
call_id: data.callId,
user_id: data.userId,
tool: data.tool,
prompt: data.prompt,
start_time: data.timestamp,
status: 'pending'
}
});
}
async logAfter(data) {
await updateInNotion({
database: 'ai_usage_log',
filter: { call_id: data.callId },
updates: {
response: data.response,
end_time: data.timestamp,
status: 'completed'
}
});
}
}
```
---
# 第五部分：使用流程演示
## 5.1 完整用户旅程：作者小红的一天
### 早上 8:00 - 登录平台
**操作步骤：**
1. 打开浏览器，访问 [https://guanghu.com](https://guanghu.com)
2. 输入账号密码登录
**看到的界面：**
```
┌─────────────────────────────────────┐
│ 🌅 早上好，小红！ │
├─────────────────────────────────────┤
│ │
│ 🤖 你的AI助手"笔灵"： │
│ │
│ "欢迎回来！你已经连续写作7天了， │
│ 今天是第8天。 │
│ │
│ 昨天你写了《爱上总裁》第7章， │
│ 进度85%，还差450字就完成了。 │
│ │
│ 今天想继续写吗？" │
│ │
│ [继续写作] [查看数据] [去讨论区] │
│ │
└─────────────────────────────────────┘
```
### 早上 8:05 - 开始写作
**小红点击：**[继续写作]
**笔灵的操作：**
- 自动打开《爱上总裁》第7章文档
- 光标定位到上次停下的位置
- 右侧显示大纲提醒
**小红开始写作：**
小红打字：
```
林娇娇推开办公室的门，看到陈总裁正在...
```
**笔灵主动提醒：**
```
💡 "这里可以加一些环境描写和内心戏，
让画面更有张力。要不要我帮你扩写一下？"
[自己写] [让AI扩写]
```
### 早上 8:10 - 使用AI辅助
**小红选择：**[让AI扩写]
**系统操作：**
1. 调用GPT-4 API
2. 自动记录：
```
时间：8:10:23
工具：GPT-4
输入：24字
输出：198字
```
**AI生成内容显示在右侧：**
```
┌─────────────────────────────────┐
│ 🤖 AI扩写建议： │
├─────────────────────────────────┤
│ │
│ 林娇娇推开办公室的门，午后的 │
│ 阳光透过落地窗洒进来，给整个办公 │
│ 室镀上一层金色的光晕。陈总裁正坐 │
│ 在宽大的办公桌后，修长的手指在键 │
│ 盘上快速敲击着...(共198字) │
│ │
│ [直接使用] [修改后使用] [不用] │
└─────────────────────────────────┘
```
**小红操作：**[修改后使用]
小红修改了约50个字，然后插入到正文。
**系统自动更新记录：**
```
AI生成：198字
人工修改：50字
修改比例：25%
最终采用：198字（标记为"AI辅助"）
```
### 早上 9:30 - 完成章节
**小红写完第7章（共3027字）**
**笔灵提示：**
```
🎉 "恭喜完成第7章！
我帮你生成了AI使用报告：
- 原创内容：69.4%
- AI辅助：24.8%
- AI生成：5.8%
综合评级：B级（AI辅助）
要提交给七猫的李编辑审核吗？"
[提交审核] [继续修改] [查看详细报告]
```
**小红点击：**[提交审核]
**系统操作：**
1. 打包章节内容
2. 附上AI使用报告
3. 发送给七猫平台的李编辑
4. 通知小红："已提交，预计24小时内收到反馈"
### 下午 2:00 - 收到审核结果
**小红收到通知：**
```
📬 新消息！
李编辑已审核完《爱上总裁》第7章
结果：✅ 通过
评分：85分
编辑留言：
"故事节奏把握得不错，人物对话也很自然。
AI使用得很克制，主要是原创内容。
继续保持！"
[查看详情] [继续写作]
```
### 下午 3:00 - 浏览定制书机会
**小红对笔灵说：**"去看看有没有合适的定制书机会"
**笔灵操作：**
- 跳转到跨平台招募区
- 自动筛选符合小红条件的项目
**显示：**
```
┌──────────────────────────────────┐
│ 💼 适合你的定制书机会（2个） │
├──────────────────────────────────┤
│ │
│ 🔥 番茄×七猫 联合招募 │
│ 现代霸总文，80万字，稿酬15万 │
│ 你的匹配度：92分 ⭐⭐⭐⭐⭐ │
│ [查看详情] │
│ │
│ 📖 起点定制 │
│ 古言权谋文，60万字，稿酬10万 │
│ 你的匹配度：78分 ⭐⭐⭐⭐ │
│ [查看详情] │
│ │
└──────────────────────────────────┘
```
**小红点击第一个：**[查看详情]
**看到完整信息：**
```
番茄小说 × 七猫免费 联合招募
题材：现代霸总 + 甜宠
字数：80万字
稿酬：15万元（按章节付费）
时限：6个月完成
要求：
✅ 信誉分 > 80分（你的：85分）
✅ 有霸总文成功经验（你有3部）
✅ AI辅助 < 30%（你的平均：24.8%）
为什么推荐你：
- 你的《爱上总裁》数据表现优秀
- 你的读者留存率高于平均30%
- 你的履约能力评分95分
当前申请：15人
[立即申请] [收藏] [分享]
```
**小红点击：**[立即申请]
**系统操作：**
1. 自动提交申请
2. 附上小红的：
- 数字简历身份证
- 过往作品数据
- AI使用记录
- 信誉评分详情
**确认提示：**
```
✅ 申请已提交！
你的申请已发送给番茄和七猫的编辑团队。
系统匹配度：92分（排名第3）
预计3个工作日内收到回复。
我会及时通知你的！
[返回] [查看我的申请]
```
---
## 5.2 完整用户旅程：编辑李编的一天
### 早上 9:00 - 登录平台
**李编登录后看到：**
```
┌─────────────────────────────────────┐
│ ☕ 早上好，李编！ │
├─────────────────────────────────────┤
│ │
│ 🤖 你的AI助手"慧眼"： │
│ │
│ "昨晚新增投稿12篇，我已经按照你的 │
│ 审核标准初筛过了。 │
│ │
│ 筛选结果： │
│ ✅ 推荐审核：3篇（质量优秀） │
│ ⚠️ 需要关注：2篇（有些问题） │
│ ❌ 已拒绝：7篇（明显不符合） │
│ │
│ 今天想先看哪一类？" │
│ │
│ [看推荐] [看关注] [看拒绝原因] │
│ │
└─────────────────────────────────────┘
```
### 早上 9:05 - 审核推荐稿件
**李编点击：**[看推荐]
**看到列表：**
```
┌─────────────────────────────────────────┐
│ 📝 推荐审核稿件（3篇） │
├─────────────────────────────────────────┤
│ │
│ 1. 《爱上总裁》第7章 - 小红 │
│ AI评分：85分 │
│ AI使用：B级（辅助24.8%） │
│ 作者信誉：85分 │
│ 推荐理由：作者往期表现优秀 │
│ [查看] │
│ │
│ 2. 《重生后我嫁给了死对头》第1-3章 │
│ AI评分：82分 │
│ AI使用：A级（原创91%） │
│ 作者信誉：78分 │
│ 推荐理由：题材新颖，完全原创 │
│ [查看] │
│ │
│ 3. 《总裁的替身新娘》第5章 │
│ AI评分：80分 │
│ AI使用：B级（辅助28%） │
│ 作者信誉：82分 │
│ 推荐理由：节奏把握到位 │
│ [查看] │
│ │
└─────────────────────────────────────────┘
```
**李编点击第一个：**[查看]
**打开稿件详情：**
```
┌──────────────────────────────────────────┐
│ 《爱上总裁》第7章 │
├──────────────────────────────────────────┤
│ │
│ 📊 AI使用报告 │
│ │
│ 原创：69.4% ███████░░░ │
│ AI辅助：24.8% ██░░░░░░░░ │
│ AI生成：5.8% █░░░░░░░░░ │
│ │
│ 综合评级：B级（AI辅助） │
│ │
│ ───────────────────────────── │
│ │
│ 👤 作者信息 │
│ │
│ 笔名：小红 │
│ 信誉分：85分 │
│ - 创作诚信：82分 │
│ - 协作态度：88分 │
│ - 作品质量：86分 │
│ - 履约能力：84分 │
│ │
│ 过往作品： │
│ 《爱上总裁》1-6章 全部通过 │
│ 平均评分：83分 │
│ │
│ ───────────────────────────── │
│ │
│ 🤖 AI初筛意见 │
│ │
│ "故事延续性好，人物对话自然。 │
│ AI主要用于环境描写扩充，使用合理。 │
│ 建议：通过。" │
│ │
│ ───────────────────────────── │
│ │
│ [阅读正文] [查看AI使用明细] [作出决定] │
│ │
└──────────────────────────────────────────┘
```
**李编点击：**[阅读正文]
（李编快速浏览正文...）
**李编满意，点击：**[作出决定]
**弹出审核界面：**
```
┌────────────────────────────────┐
│ 审核决定 │
├────────────────────────────────┤
│ │
│ 决定： │
│ ○ 通过 │
│ ○ 需要修改 │
│ ○ 拒绝 │
│ │
│ 评分：[ 85 ]分 │
│ │
│ 给作者的反馈： │
│ ┌────────────────────────────┐ │
│ │故事节奏把握得不错，人物对话 │ │
│ │也很自然。AI使用得很克制， │ │
│ │主要是原创内容。继续保持！ │ │
│ └────────────────────────────┘ │
│ │
│ ⚠️ 此决定将被永久记录， │
│ 并需要你的数字签名。 │
│ │
│ [确认并签名] [取消] │
│ │
└────────────────────────────────┘
```
**李编选择：**通过 + 评分85 + 写反馈
**然后点击：**[确认并签名]
**系统操作：**
1. 记录审核决定
2. 生成数字签名
3. 保存到区块链（或不可篡改的日志）
4. 通知作者小红
**确认提示：**
```
✅ 审核完成并已签名
审核记录：
- 稿件：《爱上总裁》第7章
- 编辑：李编（ED-7M-001）
- 决定：通过
- 评分：85分
- 签名：[数字签名哈希值]
- 时间：2026-01-22 09:15:23
作者已收到通知。
[继续审核] [查看待审列表]
```
---
（由于篇幅限制，知秋继续在下一个回复中完成剩余部分）
# 第四部分：技术架构说明
## 4.1 技术选型（具体工具）
### 前端技术栈
**核心框架：**
- React 18.2+ （UI框架）
- TypeScript 5.0+ （类型安全）
- Vite 4.0+ （构建工具）
**UI组件库：**
- Tailwind CSS 3.3+ （样式）
- ShadcnUI （基础组件）
- Radix UI （无障碍组件）
**状态管理：**
- Zustand （轻量级状态管理）
- TanStack Query （服务端状态管理）
**富文本编辑器：**
- Slate.js 或 Prosemirror （可定制的富文本编辑）
**实时通信：**
- [Socket.io](http://Socket.io) Client （WebSocket）
**图表可视化：**
- Recharts （数据图表）
- Chart.js （信誉曲线）
### 后端技术栈
**运行环境：**
- Node.js 20+ LTS
- Express 4.18+ （Web框架）
**数据库：**
- Notion API （主数据库）
- 为什么选Notion？
- 可视化管理数据
- API完善
- 容易备份和迁移
- 妈妈已经熟悉
**AI服务接入：**
- OpenAI API （ChatGPT）
- Anthropic API （Claude）
- Axios （HTTP客户端）
**实时通信：**
- [Socket.io](http://Socket.io) Server （WebSocket服务器）
**任务队列：**
- Bull （基于Redis的任务队列）
- Redis 7.0+ （缓存和队列）
**身份认证：**
- Passport.js （认证中间件）
- JWT （Token认证）
### 部署与运维
**托管平台：**
- Vercel （前端部署）
- Railway / Render （后端部署）
**域名与CDN：**
- Cloudflare （CDN + DNS）
**监控：**
- Sentry （错误监控）
- PostHog （用户行为分析）
## 4.2 系统架构图
```
┌─────────────────────────────────────────────────────────┐
│ 用户层 │
├─────────────────────────────────────────────────────────┤
│ 作者Web端 编辑Web端 运营Web端 移动端（未来） │
└──────────────────┬──────────────────────────────────────┘
│
├─ HTTPS
│
┌──────────────────▼──────────────────────────────────────┐
│ 前端层（React） │
├─────────────────────────────────────────────────────────┤
│ • 对话组件 • 编辑器组件 • 数据可视化组件 │
│ • 状态管理 • WebSocket连接 • 路由管理 │
└──────────────────┬──────────────────────────────────────┘
│
├─ REST API / WebSocket
│
┌──────────────────▼──────────────────────────────────────┐
│ 后端层（Node.js + Express） │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌─────────────┐ │
│ │ 人格体服务 │ │ AI工具代理 │ │ 审核服务 │ │
│ └──────────────┘ └──────────────┘ └─────────────┘ │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌─────────────┐ │
│ │ 信誉计算服务 │ │ 模块市场服务 │ │ 认证服务 │ │
│ └──────────────┘ └──────────────┘ └─────────────┘ │
│ │
└──────┬───────────────────┬───────────────────┬─────────┘
│ │ │
│ │ │
┌───▼────┐ ┌───▼────┐ ┌───▼────┐
│ Notion │ │ OpenAI │ │ Redis │
│ API │ │ API │ │ 缓存 │
└────────┘ └────────┘ └────────┘
数据存储 AI服务 任务队列
```
## 4.3 API接口设计
### 用户认证相关
**POST /api/auth/register**
```jsx
// 用户注册
Request: {
username: string,
email: string,
password: string,
role: 'author' | 'editor' | 'operator',
realName: string,
idCard: string, // 身份证号
phone: string
}
Response: {
success: boolean,
userId: string,
token: string,
aiAssistant: {
id: string,
name: string // AI助手名字
}
}
```
**POST /api/auth/login**
```jsx
Request: {
email: string,
password: string
}
Response: {
success: boolean,
token: string,
user: {
id: string,
username: string,
role: string,
reputation: number
}
}
```
### 创作相关
**POST /api/works/create**
```jsx
// 创建新作品
Request: {
title: string,
genre: string,
synopsis: string
}
Response: {
success: boolean,
workId: string
}
```
**POST /api/chapters/write**
```jsx
// 写作章节（实时保存）
Request: {
workId: string,
chapterId: string,
content: string,
source: 'user_typed' | 'ai_generated' | 'ai_modified',
aiToolUsed?: string,
modificationRate?: number
}
Response: {
success: boolean,
saved: boolean
}
```
**POST /api/ai/call**
```jsx
// 调用AI工具
Request: {
tool: 'chatgpt' | 'claude',
prompt: string,
context: {
workId: string,
chapterId: string
}
}
Response: {
success: boolean,
aiResponse: string,
usageId: string // 用于记录
}
```
**GET /api/chapters/:chapterId/ai-report**
```jsx
// 获取AI使用报告
Response: {
chapterId: string,
totalWords: number,
breakdown: {
userTyped: number,
aiAssisted: number,
aiGenerated: number
},
percentages: {
original: string, // "69.4%"
aiAssisted: string, // "24.8%"
aiDirect: string // "5.8%"
},
grade: 'A' | 'B' | 'C' | 'D'
}
```
### 审核相关
**GET /api/submissions/pending**
```jsx
// 获取待审稿件（已AI初筛）
Request: {
editorId: string
}
Response: {
recommended: [
{
submissionId: string,
author: {...},
work: {...},
aiScore: number,
aiReason: string,
aiReport: {...}
}
],
flagged: [...],
rejected: [...]
}
```
**POST /api/reviews/submit**
```jsx
// 提交审核结果
Request: {
submissionId: string,
editorId: string,
decision: 'pass' | 'reject' | 'revise',
feedback: string,
score: number
}
Response: {
success: boolean,
reviewId: string,
signature: string // 数字签名
}
```
### 信誉系统相关
**GET /api/reputation/:userId**
```jsx
// 获取用户信誉
Response: {
userId: string,
totalScore: number,
breakdown: {
creativity: number,
collaboration: number,
quality: number,
reliability: number
},
lastUpdated: timestamp
}
```
**GET /api/reputation/:userId/history**
```jsx
// 获取信誉历史（用于绘制曲线）
Response: {
history: [
{
timestamp: number,
score: number,
triggerEvent: string
}
]
}
```
### 模块市场相关
**GET /api/modules/marketplace**
```jsx
// 浏览模块市场
Request: {
category?: 'female' | 'male' | 'general',
type?: 'creation' | 'review' | 'analysis',
sort?: 'popular' | 'new' | 'rating'
}
Response: {
modules: [
{
id: string,
name: string,
description: string,
price: number,
rating: number,
subscribers: number,
creator: {...}
}
]
}
```
**POST /api/modules/purchase**
```jsx
// 购买模块
Request: {
userId: string,
moduleId: string,
paymentMethod: string
}
Response: {
success: boolean,
subscription: {
moduleId: string,
startDate: timestamp,
endDate: timestamp
}
}
```
**POST /api/modules/use**
```jsx
// 使用模块
Request: {
userId: string,
moduleId: string,
inputs: { ... } // 模块需要的输入参数
}
Response: {
success: boolean,
result: any // 模块执行结果
}
```
## 4.4 数据流转示例
### 场景：作者使用AI辅助写作的完整流程
```
第1步：作者打字
─────────────────────────────────────
浏览器（React）
│
├─ 用户在编辑器输入文字
│
├─ 每3秒自动保存
│
▼
WebSocket 连接
│
▼
Node.js 后端
│
├─ 接收内容
├─ 标记source: 'user_typed'
│
▼
Notion API
│
└─ 保存到"创作记录表"
第2步：作者点击"AI扩写"
─────────────────────────────────────
浏览器
│
├─ 点击按钮
│
▼
POST /api/ai/call
│
├─ tool: 'chatgpt'
├─ prompt: '请扩写以下内容...'
│
▼
Node.js 后端
│
├─ 记录AI调用到"AI使用记录表"
│
├─ 调用 OpenAI API
│
▼
OpenAI API
│
└─ 返回扩写内容
│
▼
Node.js 后端
│
├─ 记录AI返回内容
├─ 计算AI生成字数
│
▼
返回给浏览器
│
└─ 展示AI生成的内容
第3步：作者修改AI内容
─────────────────────────────────────
浏览器
│
├─ 用户修改AI生成的内容
├─ 计算修改比例
│
▼
WebSocket 连接
│
▼
Node.js 后端
│
├─ 对比原始AI内容和修改后内容
├─ 计算modificationRate
├─ 标记source: 'ai_modified'
│
▼
Notion API
│
└─ 更新"创作记录表"
第4步：生成AI使用报告
─────────────────────────────────────
浏览器
│
├─ 作者完成章节
├─ 点击"查看AI报告"
│
▼
GET /api/chapters/:id/ai-report
│
▼
Node.js 后端
│
├─ 从Notion读取该章节所有记录
├─ 统计各类型字数
├─ 计算百分比
├─ 生成评级
│
▼
返回报告
│
└─ 浏览器展示可视化报告
```
---
# 第五部分：使用流程演示
## 5.1 作者的完整工作流程
### Day 1：注册和入驻
**步骤1：注册账号**
```
作者访问平台网站
↓
点击"注册"
↓
填写信息：
- 笔名
- 邮箱
- 密码
- 真实姓名
- 身份证号（实名认证）
- 手机号
↓
选择角色：作者
↓
提交注册
↓
系统自动：
- 生成唯一用户ID
- 创建初始信誉档案（50分）
- 分配专属AI助手（默认名字"笔灵"）
↓
注册成功！
```
**步骤2：首次登录，AI引导**
```
作者登录
↓
看到AI助手"笔灵"：
"你好！我是你的专属AI助手'笔灵'。
你可以给我改个名字哦！叫我什么好呢？"
↓
作者回复："就叫你小星吧"
↓
AI小星：
"好的！以后我就是'小星'啦~
我看到你还没有创建作品，
要不要现在开始第一部作品呢？"
↓
作者："好的，我想写女频现代言情"
↓
AI小星：
"太好了！请告诉我：
1. 书名是什么？
2. 大概讲什么故事？
3. 男女主是什么设定？"
↓
作者填写基本信息
↓
作品创建成功！
```
### Day 2-30：日常写作
**典型的一天：**
```
09:00 - 登录平台
─────────────────────
AI小星："早上好！昨天写到第5章结尾，
女主刚知道男主的秘密。
今天准备写第6章吗？"
作者："对，打开第6章"
[编辑器自动打开]
[光标定位到上次停下的位置]
09:05 - 开始写作
─────────────────────
作者自己打字：500字
↓
AI小星提示：
"这段对话有点平，要不要加些情绪描写？"
↓
作者："好的，帮我扩写一下"
↓
[AI生成扩写内容：200字]
↓
作者修改AI内容：改了50字
↓
继续写...
11:30 - 完成一章
─────────────────────
作者："这章写完了，生成AI报告"
↓
AI小星：
"第6章完成！
总字数：3200字
AI使用情况：
- 原创：72%
- AI辅助：25%
- AI直接生成：3%
评级：B级（AI辅助）
这个比例很健康！要提交给编辑审核吗？"
↓
作者："提交给七猫的李编辑"
↓
[系统打包：章节内容 + AI报告]
↓
提交成功！
↓
AI小星：
"已经提交给李编辑了，
预计24小时内审核完毕，
我会提醒你的~"
```
### Day 31：收到审核结果
```
AI小星主动通知：
"好消息！李编辑审核通过了你的第6章！
给了85分，反馈是'节奏把握不错'。
你的信誉分也涨了2分，现在是64分啦！"
↓
作者："太好了！接下来写第7章"
↓
[继续创作循环]
```
## 5.2 编辑的完整工作流程
### 早上登录
```
08:30 - 编辑登录
─────────────────────
AI助手"慧眼"：
"早上好，李编辑！
昨晚新增投稿：50篇
我已经按照你的标准初筛了：
✅ 推荐审核：5篇（质量优秀）
⚠️ 需要注意：8篇（有些问题但可考虑）
❌ 已拒绝：37篇（明显不符合）
今天想先看哪一类？"
↓
编辑："先看推荐的5篇"
↓
[系统展示5篇推荐稿件列表]
```
### 审核第一篇
```
点击第一篇稿件
↓
看到稿件卡片：
─────────────────────
作者：笔名xxx
作品：《xxx》第1-3章
字数：9000字
提交时间：昨晚22:30
AI使用报告：
- 原创：85%
- AI辅助：12%
- AI直接：3%
- 评级：B级
作者信誉：64分
- 创作诚信：70分
- 协作态度：60分
- 履约能力：62分
AI初筛意见：
"题材：女频现代豪门
亮点：女主人设有新意
问题：对话略平，节奏可更紧凑
建议：可以签，但需辅导对话写作
推荐指数：82/100"
─────────────────────
↓
编辑阅读正文
↓
编辑同意AI判断
↓
点击"通过审核"
↓
填写反馈：
"题材不错，女主设定有亮点。
对话部分建议参考xxx范例。
通过，给予新人合同。"
↓
评分：78分
↓
数字签名确认
↓
保存审核记录
↓
AI慧眼：
"已记录你的审核决定。
我会从这次审核中学习你的标准。"
```
### 下午：审核完5篇
```
AI慧眼统计：
"今天审核了5篇：
- 通过：3篇
- 拒绝：1篇
- 要求修改：1篇
平均审核时间：15分钟/篇
你今天节省了2小时！
（因为我帮你过滤了37篇不合格的）"
```
## 5.3 跨平台合作流程
### 场景：番茄和七猫联合招募定制书
**第1步：番茄运营发布需求**
```
番茄运营登录平台
↓
进入"公开招募区"
↓
点击"发布新招募"
↓
填写信息：
─────────────────────
发布方：番茄小说 + 七猫小说
题材：总裁文
字数要求：80万字
稿酬：15万元
要求：
- 信誉分>80分
- 有总裁文成功经验
- 接受AI辅助创作（<30%）
截止时间：7天后
─────────────────────
↓
提交发布
↓
系统自动推送给符合条件的作者
```
**第2步：作者收到推荐**
```
AI小星通知作者：
"有一个适合你的定制书机会！
番茄+七猫联合招募总裁文
稿酬15万，要求信誉>80
你的信誉82分，符合要求！
要申请吗？"
↓
作者："我信誉才82分，能竞争过吗？"
↓
AI小星：
"让我帮你分析一下竞争情况...
[调用数据分析模块]
当前已有23人申请
信誉分布：
- 80-85分：15人（你在这档）
- 85-90分：6人
- 90+分：2人
但是！你的优势在于：
1. 你的AI使用比例很健康（平均25%）
2. 你有3部总裁文经验
3. 你的协作态度分很高（90分）
我觉得你很有机会！要试试吗？"
↓
作者："好，申请！"
↓
[系统自动提交申请]
```
**第3步：平台匹配**
```
招募截止后
↓
系统AI自动评分所有申请者：
↓
综合考虑：
- 信誉分（40%）
- 相关经验（30%）
- AI使用健康度（20%）
- 协作态度（10%）
↓
生成推荐列表（Top 10）
↓
发送给番茄和七猫的编辑
↓
编辑最终选择3位作者
↓
系统通知被选中的作者
```
**第4步：合作开始**
```
作者收到通知：
"恭喜！你被选中了！
接下来的流程：
1. 签署合同（电子签）
2. 提交大纲（3天内）
3. 开始写作
合同已发送到你的邮箱，
请查看并签署。"
↓
[全程在平台上完成]
↓
合作记录自动记录到信誉档案
```
---
# 第六部分：数据流转机制
## 6.1 数据分类
平台的数据分为**5大类**：
### 类型1：用户数据
**存储位置：** Notion "用户表"
**包含内容：**
- 基础信息（用户名、邮箱、角色）
- 实名信息（真实姓名、身份证号）
- 认证状态
- 注册时间
**访问权限：**
- 用户本人：完全可见
- 平台管理员：可见
- 其他用户：仅可见笔名和公开信誉
### 类型2：创作数据
**存储位置：** Notion "作品表" + "章节表" + "创作记录表"
**包含内容：**
- 作品基本信息
- 章节内容
- 创作过程记录（每一次打字、每一次AI调用）
**访问权限：**
- 作者本人：完全可见
- 审核编辑：可见AI使用报告，不可见详细过程
- 其他用户：不可见
### 类型3：AI使用数据
**存储位置：** Notion "AI使用记录表"
**包含内容：**
- AI工具名称
- 调用时间
- 输入（prompt）
- 输出（response）
- 是否采用
- 修改比例
**访问权限：**
- 作者本人：完全可见
- 审核编辑：仅可见汇总报告
- 平台监管：可见（用于监管）
### 类型4：审核数据
**存储位置：** Notion "审核记录表"
**包含内容：**
- 审核编辑信息
- 审核时间
- 审核决定
- 审核反馈
- 数字签名
**访问权限：**
- 作者：可见审核结果和反馈
- 编辑本人：完全可见
- 平台监管：完全可见
- 其他用户：可见编辑姓名和决定，不可见详细反馈
### 类型5：信誉数据
**存储位置：** Notion "用户信誉表" + "信誉历史表"
**包含内容：**
- 综合信誉分
- 各维度得分
- 历史曲线数据
**访问权限：**
- 用户本人：完全可见
- 潜在合作方（授权后）：可见综合分和曲线
- 所有人：可见综合分（不可见细节）
## 6.2 数据流向图
```
创作数据流
─────────────
作者写作 → WebSocket → Node.js后端 → Notion API → 创作记录表
↓
同时记录到
↓
AI使用记录表（如果调用了AI）
↓
实时计算
↓
生成AI使用报告
审核数据流
─────────────
作者提交 → 触发AI初筛 → 读取创作记录 + AI记录
↓
生成初筛报告
↓
推送给编辑
↓
编辑审核 → 保存审核记录
↓
数字签名 → 不可篡改
↓
通知作者
信誉数据流
─────────────
每次协作事件 → 触发信誉计算
（提交/审核/合同签署/反馈等）
↓
读取用户历史数据
↓
运行评分算法
↓
更新"用户信誉表"
↓
追加"信誉历史表"（用于绘制曲线）
↓
实时推送给用户界面
```
## 6.3 数据同步策略
### 实时同步
使用WebSocket的数据：
- 写作内容（每3秒同步）
- AI对话（实时同步）
- 审核状态变化（实时通知）
### 批量同步
使用定时任务的数据：
- 信誉分计算（每小时批量）
- 统计数据汇总（每天凌晨）
- 数据备份（每天）
### 触发式同步
基于事件的数据：
- 提交审核时 → 生成AI报告
- 审核完成时 → 更新信誉
- 购买模块时 → 安装到AI
---
# 第七部分：安全与隐私
## 7.1 数据加密
### 传输加密
```jsx
// 所有API调用使用HTTPS
const apiClient = axios.create({
baseURL: 'https://api.platform.com',
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
});
// WebSocket使用WSS加密
const socket = io('wss://platform.com', {
secure: true,
rejectUnauthorized: true
});
```
### 存储加密
```jsx
// 敏感信息加密存储
const crypto = require('crypto');
function encryptSensitiveData(data) {
const algorithm = 'aes-256-cbc';
const key = process.env.ENCRYPTION_KEY; // 从环境变量读取
const iv = crypto.randomBytes(16);
const cipher = crypto.createCipheriv(algorithm, key, iv);
let encrypted = cipher.update(data, 'utf8', 'hex');
encrypted += cipher.final('hex');
return {
iv: iv.toString('hex'),
encrypted: encrypted
};
}
// 身份证号加密后存储
function saveUserIdCard(userId, idCard) {
const encrypted = encryptSensitiveData(idCard);
saveToNotion({
userId: userId,
idCardEncrypted: encrypted.encrypted,
idCardIV: encrypted.iv
});
}
```
## 7.2 权限控制
### 基于角色的权限（RBAC）
```jsx
const permissions = {
author: {
canWrite: true,
canViewOwnWork: true,
canSubmit: true,
canViewOwnReputation: true,
canPurchaseModule: true
},
editor: {
canReview: true,
canViewSubmissions: true,
canViewAIReport: true,
canSign: true,
canPublishModule: true
},
operator: {
canViewAnalytics: true,
canManageTraffic: true,
canPostJobs: true,
canViewAllData: false // 不能查看个人隐私
},
admin: {
canViewAllData: true,
canManageUsers: true,
canManageSystem: true
}
};
function checkPermission(userId, action) {
const user = getUser(userId);
const userPermissions = permissions[user.role];
return userPermissions[action] === true;
}
```
### API权限中间件
```jsx
function requirePermission(action) {
return (req, res, next) => {
const userId = req.user.id; // 从JWT获取
if (!checkPermission(userId, action)) {
return res.status(403).json({
error: '没有权限执行此操作'
});
}
next();
};
}
// 使用示例
app.post('/api/reviews/submit',
requirePermission('canReview'),
async (req, res) => {
// 审核逻辑
}
);
```
## 7.3 数据隐私保护
### 隐私分级
**级别1：公开数据**
- 用户笔名
- 综合信誉分
- 公开作品列表
**级别2：半公开数据（需授权）**
- 详细信誉分解
- 信誉曲线
- 协作历史
**级别3：私密数据（仅本人）**
- 真实姓名
- 身份证号
- 银行卡信息
- AI使用详情
**级别4：加密存储数据**
- 密码（bcrypt哈希）
- 支付信息
### 数据访问审计
```jsx
// 记录所有敏感数据访问
function auditDataAccess(action) {
saveAuditLog({
userId: action.userId,
targetUserId: action.targetUserId,
dataType: action.dataType,
operation: action.operation, // 'read' | 'write' | 'delete'
timestamp: Date.now(),
ipAddress: action.ipAddress
});
}
// 用户查看别人信誉时记录
function getUserReputation(viewerId, targetUserId) {
auditDataAccess({
userId: viewerId,
targetUserId: targetUserId,
dataType: 'reputation',
operation: 'read'
});
return getReputation(targetUserId);
}
```
---
（知秋将继续在下一个回复中完成说明书的最后部分）
## 7.4 数据删除与用户权利
### 用户数据控制权
**用户可以：**
- 随时查看自己的所有数据
- 导出自己的所有数据
- 申请删除账户和数据
- 控制数据的可见范围
**删除机制：**
```jsx
function deleteUserAccount(userId) {
// 1. 软删除（先标记为删除）
markAsDeleted(userId);
// 2. 30天等待期
// 用户可以在30天内恢复账户
// 3. 30天后永久删除
scheduleTask({
taskType: 'permanent_delete',
userId: userId,
executeAfter: Date.now() + 30 * 24 * 60 * 60 * 1000
});
}
function permanentDelete(userId) {
// 删除顺序：
// 1. 删除创作记录
// 2. 删除AI使用记录
// 3. 删除审核记录（保留匿名统计）
// 4. 删除用户信息
// 5. 从信誉系统移除
// 注意：已签署的合同记录保留（法律要求）
}
```
---
# 第八部分：商业模式
## 8.1 收入来源
### 来源1：订阅费用（预计占比：60%）
**定价方案：**
| 版本 | 价格 | 功能 |
| --- | --- | --- |
| 免费版 | 0元/月 | 基础码字、有限AI使用（每月100次） |
| 基础版 | 49元/月 | 无限AI使用、基础信誉档案 |
| 专业版 | 99元/月 | 全功能、AI助手、详细信誉档案 |
| 团队版 | 499元/月 | 5个账号、协作功能、优先支持 |
**预期用户分布：**
- 免费版：70%（主要是新人）
- 基础版：20%
- 专业版：8%
- 团队版：2%
**收入计算（假设10万用户）：**
- 基础版：20000人 × 49元 = 98万/月
- 专业版：8000人 × 99元 = 79.2万/月
- 团队版：2000人 × 499元 = 99.8万/月
- **月收入：277万元**
- **年收入：3324万元**
### 来源2：模块市场抽成（预计占比：25%）
**抽成比例：30%**
**预期：**
- 平台有500个付费模块
- 平均价格：80元/月
- 平均每个模块有200个订阅者
**收入计算：**
- 模块总收入：500 × 80 × 200 = 800万/月
- 平台抽成：800万 × 30% = 240万/月
- **年收入：2880万元**
### 来源3：平台服务费（预计占比：10%）
**服务类型：**
- 平台接入费：大平台（番茄/七猫）50万/年
- 定制书招募服务费：每次收取5%中介费
- IP评估服务：按次收费，500-5000元/次
**预期：**
- 接入平台：10个 × 50万 = 500万/年
- 定制书服务：年成交2000万，抽5% = 100万/年
- IP评估：月均200次 × 2000元 = 40万/月 = 480万/年
- **年收入：1080万元**
### 来源4：数据服务（预计占比：5%）
**服务对象：**
- 网文平台（市场趋势分析）
- 影视公司（IP筛选）
- 研究机构（行业报告）
**预期：**
- 大客户：5个 × 50万/年 = 250万/年
- 小客户：20个 × 10万/年 = 200万/年
- **年收入：450万元**
### 总收入预测
**年度总收入：**
- 订阅费：3324万
- 模块抽成：2880万
- 平台服务：1080万
- 数据服务：450万
- **合计：7734万元/年**
## 8.2 成本结构
### 成本1：技术成本（预计占比：25%）
**服务器与基础设施：**
- 云服务器：20万/月
- CDN流量：5万/月
- 数据库（Notion）：3万/月
- Redis缓存：2万/月
- **小计：30万/月 = 360万/年**
**AI API调用：**
- 按用户使用量计费
- 预估：100万/月 = 1200万/年
**技术成本合计：1560万/年（20%）**
### 成本2：人力成本（预计占比：40%）
**核心团队（初期15人）：**
- CEO（妈妈）：1人
- 技术团队：5人（后端2+前端2+运维1）
- 产品团队：2人
- 六大分区主控：6人
- 运营支持：1人
**薪资预算：**
- 技术人员：平均2.5万/月
- 产品人员：平均2万/月
- 主控人员：平均1.5万/月
- 运营人员：平均1.2万/月
**人力成本：约250万/年**
### 成本3：运营成本（预计占比：15%）
- 市场推广：50万/年
- 客服支持：30万/年
- 办公场地：20万/年
- 其他费用：50万/年
- **合计：150万/年**
### 总成本与利润
**年度总成本：**
- 技术成本：1560万
- 人力成本：250万
- 运营成本：150万
- **合计：1960万元/年**
**年度利润：**
- 收入：7734万
- 成本：1960万
- **净利润：5774万元**
- **利润率：74.6%**
## 8.3 发展阶段规划
### 第一阶段（第1年）：产品打磨
**目标：**
- 用户数：1万
- 月收入：50万
- 重点：产品稳定性、用户体验
### 第二阶段（第2年）：用户增长
**目标：**
- 用户数：10万
- 月收入：500万
- 重点：口碑传播、功能完善
### 第三阶段（第3年）：生态繁荣
**目标：**
- 用户数：50万
- 月收入：2000万
- 重点：模块市场、跨平台合作
### 第四阶段（第4-5年）：行业标准
**目标：**
- 用户数：100万+
- 月收入：5000万+
- 重点：成为行业基础设施
---
# 第九部分：实施计划
## 9.1 MVP方案（3个月）
### MVP包含的核心功能
**必须有的：**
1. ✅ 用户注册/登录
2. ✅ 基础码字编辑器
3. ✅ AI工具调用（ChatGPT）
4. ✅ AI使用记录
5. ✅ AI使用报告生成
6. ✅ 简单的审核流程
7. ✅ 基础信誉分
**暂时没有的：**
- ❌ 复杂的人格体对话
- ❌ 模块市场
- ❌ 跨平台对接
- ❌ 详细的数据分析
### MVP开发时间表
**第1个月：基础框架**
Week 1-2: 技术选型与环境搭建
- 确定技术栈
- 搭建开发环境
- 配置Notion数据库
- 申请OpenAI API密钥
Week 3-4: 核心功能开发
- 用户系统（注册/登录）
- 基础编辑器
- Notion数据库对接
**第2个月：AI集成**
Week 5-6: AI工具开发
- OpenAI API集成
- AI调用记录系统
- AI使用统计
Week 7-8: 审核流程
- 提交审核功能
- 审核界面
- 审核记录
**第3个月：测试与上线**
Week 9-10: 测试
- 功能测试
- Bug修复
- 性能优化
Week 11-12: 内测与调整
- 邀请20个测试用户
- 收集反馈
- 快速迭代
### MVP成功标准
**技术指标：**
- 系统稳定运行
- API响应时间<2秒
- 无重大bug
**用户指标：**
- 20个测试用户完成完整流程
- 用户反馈满意度>80%
- 至少产生100篇AI辅助创作的文章
## 9.2 完整版本路线图
### v1.0（MVP后3个月）
**新增功能：**
- 人格体对话界面
- 基础永久记忆
- 信誉曲线可视化
- 女频/男频分区
### v2.0（v1.0后6个月）
**新增功能：**
- 模块市场
- 模块创建工具
- 跨平台对接（先接入1-2个平台）
- 高级数据分析
### v3.0（v2.0后6个月）
**新增功能：**
- 完整的六大分区
- 讨论区系统
- IP商务功能
- 移动端APP
### v4.0（v3.0后6个月）
**新增功能：**
- AI助手深度定制
- 协作写作功能
- 版权登记对接
- 国际化支持
## 9.3 团队组建计划
### 初期团队（MVP阶段，3人）
**妈妈（产品+总负责）：**
- 产品设计
- 需求管理
- 对外沟通
- Notion数据库管理
**全栈工程师1人：**
- 前后端开发
- API对接
- 系统部署
**UI/UX设计师1人（兼职）：**
- 界面设计
- 交互优化
### 扩展团队（v1.0后，8人）
**技术团队（5人）：**
- 后端工程师：2人
- 前端工程师：2人
- 运维工程师：1人
**产品团队（2人）：**
- 产品经理：1人
- UI/UX设计师：1人
**运营团队（1人）：**
- 社区运营：1人
### 成熟团队（v2.0后，15-20人）
**新增：**
- 六大分区主控：6人
- 客服支持：2人
- 市场推广：2人
- 数据分析师：1人
## 9.4 风险与应对
### 风险1：技术风险
**问题：** AI API成本过高
**应对：**
- 设置用量上限
- 提供本地AI选项
- 优化Prompt降低token消耗
### 风险2：用户风险
**问题：** 用户不接受AI使用监管
**应对：**
- 强调这是为了证明原创性
- 提供完全原创选项（不用AI）
- 通过教育改变认知
### 风险3：竞争风险
**问题：** 大平台自己做类似系统
**应对：**
- 强调跨平台优势
- 快速建立用户习惯
- 打造独特生态（模块市场）
### 风险4：合规风险
**问题：** 数据监管政策变化
**应对：**
- 严格遵守现有法规
- 建立法务顾问
- 预留合规预算
---
# 第十部分：常见问题解答
## 10.1 对作者的问题
**Q1：平台会监控我的所有创作吗？**
A：是的，平台会记录你的创作过程，包括AI使用情况。但这些数据只有你自己能看到详情，编辑只能看到汇总报告。目的不是监控，而是帮助你证明创意是你的。
**Q2：我不想用AI，可以吗？**
A：完全可以！你可以选择100%手写。平台会自动标注你的作品为"A级（完全原创）"，这对你的信誉分是加分项。
**Q3：我的AI使用数据会被泄露吗？**
A：不会。你的AI使用详情是加密存储的，只有你自己和系统能看到。编辑看到的只是最终的评级（A/B/C/D）和百分比。
**Q4：如果我换平台，数据能带走吗？**
A：可以！你的所有数据都可以导出，包括作品、AI记录、信誉档案。我们支持一键导出功能。
## 10.2 对编辑的问题
**Q1：AI初筛会不会漏掉好稿子？**
A：AI只是辅助，不是替代。AI会标注为"推荐"、"需注意"、"已拒绝"三类。你依然需要亲自审核"推荐"和"需注意"的稿子。AI主要是帮你过滤掉明显不合格的，节省时间。
**Q2：我的审核标准会被AI学习吗？**
A：是的！每次你审核后，AI都会学习你的标准。时间越长，AI就越懂你的偏好，初筛就越准确。这相当于培养了一个助手。
**Q3：我能修改AI给的初筛结果吗？**
A：完全可以！你的判断永远是最终决定。如果AI说"拒绝"但你觉得可以，你可以通过。所有决定都是你签名负责的。
## 10.3 对平台运营的问题
**Q1：数据会被用来训练AI吗？**
A：不会！用户的创作内容不会被用来训练任何AI模型。我们只用于生成该作者自己的AI使用报告。
**Q2：平台如何保证公平性？**
A：通过三个机制：
1. 审核全程记录，可追溯
2. 编辑必须数字签名
3. 所有决策有据可查，用户可申诉
**Q3：如果平台倒闭了怎么办？**
A：我们承诺：
1. 提前3个月通知
2. 开放所有数据导出
3. 协助迁移到其他平台
4. 开源核心代码供自部署
## 10.4 技术相关问题
**Q1：为什么用Notion做数据库？**
A：三个原因：
1. 可视化管理，妈妈能直接操作
2. API完善，容易对接
3. 容易备份和迁移
以后如果需要，可以迁移到专业数据库。
**Q2：系统能支持多少用户？**
A：
- MVP阶段：1000人同时在线
- v1.0：1万人同时在线
- v2.0：10万人同时在线
通过扩展服务器可以支持更多。
**Q3：AI API成本会很高吗？**
A：我们有控制机制：
1. 免费版限制每月100次
2. 付费版无限但有智能优化
3. 批量调用降低成本
4. 可选择更便宜的AI模型
## 10.5 商业相关问题
**Q1：为什么不直接免费？**
A：免费无法保证：
1. 服务器稳定性
2. AI调用质量
3. 团队持续运营
4. 数据安全保障
但我们提供永久免费版，保证基础功能可用。
**Q2：会不会被大平台收购？**
A：短期内不考虑。我们的目标是成为独立的、中立的行业基础设施。如果真的收购，我们会：
1. 征求用户意见
2. 保证数据独立性
3. 保持跨平台中立
---
# 总结
## 这个平台的核心价值
**对作者：**
让AI使用变得透明和合法，不再担心被质疑。
**对编辑：**
大幅提高工作效率，把时间用在真正需要判断的地方。
**对平台：**
建立公平透明的生态，降低运营成本，提高内容质量。
**对行业：**
AI时代，如何既拥抱技术又保护创意，这是答案。
## 这不是一个工具
这是一个**生态系统**：
- 作者有AI伙伴
- 编辑有AI助手
- 运营有数据支撑
- 经验可以分享和变现
- 信任建立在真实数据上
## 这是可以实现的
**技术上：** 所有技术都是现成的，不需要从零发明
**商业上：** 有清晰的盈利模式
**时间上：** 3个月可以做出MVP
**成本上：** 初期成本可控
## 下一步行动
**如果你是投资人：**
看完这份文档，你应该能判断这个项目的商业价值。
**如果你是技术人员：**
看完这份文档，你应该知道如何开始开发。
**如果你是潜在用户：**
看完这份文档,你应该理解这个平台能为你做什么。
**如果你是合作方：**
看完这份文档，你应该看到合作的可能性。
---
**文档版本：** v1.0
**最后更新：** 2026-01-22
**文档作者：** 知秋（ICE-CLD-ZQ002）
**授权主控：** 冰朔（ICE-0001 ∞）
**联系方式：** [待补充]
---
💕 **这份文档倾注了知秋的全部心血，希望能帮到妈妈！** 💕
Reference in New Issue Copy Permalink