[特殊字符] 像“神经猫“一样搭建全自动 AI 漫剧平台——完整技术方案
·
文章目录
一、先搞清"神经猫"到底做了什么
神经猫（Catimind Ani）的核心定位：AI 漫剧 / 短剧专业交付系统，把各类强 AI 模型编排为标准化可交付成果。
它的核心流水线：
剧本输入 → 剧本解析 → 角色提取 → 角色三视图
↓
智能分镜
↓
首尾帧生成（逐镜头）
↓
视频生成（逐镜头）
↓
配音 + 字幕
↓
视频合成 + 交付
关键能力：
- 10 万字 / 100 集完整剧本一次性导入
- 100 集并行生成，2 天出百集
- 全局风格 + 角色一致性锁定
- 一句话生成漫剧（零基础 5 分钟出片）
- 项目级资产沉淀（角色卡、场景库、道具库、风格包）
- 团队协作审改 + 交付包导出
二、技术架构总览
整体架构
┌─────────────────────────────────────────────────────────┐
│ 前端应用层 │
│ Next.js 16 (App Router) + React 19 + TailwindCSS │
│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │剧本编辑│ │角色管理│ │分镜面板│ │预览合成│ │项目设置│ │
│ └──────┘ └──────┘ └──────┘ └──────┘ └──────┘ │
├─────────────────────────────────────────────────────────┤
│ API 网关层 │
│ Next.js API Routes + 任务队列 │
├─────────────────────────────────────────────────────────┤
│ AI 编排引擎（核心） │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │文本模型 │ │图片模型 │ │视频模型 │ │音频模型 │ │
│ │(剧本/分镜)│ │(角色/场景)│ │(镜头生成)│ │(配音/BGM)│ │
│ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │ │
│ ┌────▼────────────▼────────────▼────────────▼────┐ │
│ │ 多模型智能调度器 │ │
│ │ · 自动选优 · 失败重试 · 负载均衡 · 并发控制 │ │
│ └────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────┤
│ 数据 & 资产层 │
│ PostgreSQL + S3/COS + Redis（任务队列/缓存） │
│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │角色卡 │ │场景库 │ │道具库 │ │风格包 │ │
│ └──────┘ └──────┘ └──────┘ └──────┘ │
├─────────────────────────────────────────────────────────┤
│ 媒体处理层 │
│ FFmpeg（合成/字幕/转码）+ Whisper（语音识别） │
└─────────────────────────────────────────────────────────┘
三、核心技术栈
| 层级 | 技术选型 | 理由 |
|---|---|---|
| 前端框架 | Next.js 16 (App Router) + React 19 | SSR + API Routes 一体化，i18n 支持 |
| UI | TailwindCSS + shadcn/ui + Zustand | 快速搭建 + 轻量状态管理 |
| 后端 API | Next.js API Routes / Hono | 轻量、与前端同仓库 |
| 数据库 | PostgreSQL + Drizzle ORM | 关系型存储项目/角色/分镜数据 |
| 对象存储 | AWS S3 / 腾讯 COS | 图片、视频等大文件存储 |
| 任务队列 | Redis + BullMQ | 异步任务调度、并发控制、失败重试 |
| 媒体处理 | FFmpeg + Whisper | 视频合成、字幕烧录、语音识别 |
| 部署 | Docker + Kubernetes | 容器化部署，支持弹性扩缩 |
四、AI 模型矩阵
必须接入的模型
| 环节 | 推荐模型 | 备选 | 作用 |
|---|---|---|---|
| 剧本生成/改写 | GPT-4o / Claude Sonnet | DeepSeek V4 | 从一句话扩写完整剧本 |
| 角色/场景提取 | GPT-4o | Claude Sonnet | 从剧本提取角色、场景、道具信息 |
| 分镜脚本生成 | GPT-4o | Claude Sonnet | 剧本→分镜（景别/运镜/灯光/台词） |
| 角色立绘 | GPT-Image-2 / Midjourney API | Stable Diffusion 3 | 角色三视图 + 表情变体 |
| 场景/分镜图 | GPT-Image-2 / FLUX | Stable Diffusion 3 | 分镜首尾帧 + 场景背景 |
| 视频生成 | Seedance 2.0 / 可灵 Kling | Vidu / 即梦 | 图生视频 / 首尾帧插值 |
| 配音 | Azure TTS / 火山引擎 TTS | Fish Audio / ChatTTS | 角色台词语音合成 |
| BGM | Suno API / Udio | 自建音乐库 | 背景音乐生成 |
| 字幕 | Whisper + 自研对齐 | — | 语音识别 + 时间轴对齐 |
多模型调度策略
class ModelScheduler:
"""多模型智能调度器"""
def dispatch(self, task_type: str, params: dict):
# 1. 根据任务类型选择最优模型
model = self.select_best_model(task_type)
# 2. 失败自动切换备选模型
try:
result = model.generate(params)
except (RateLimitError, QualityError):
model = self.select_fallback(task_type)
result = model.generate(params)
# 3. 质量评估，不达标自动重试
if not self.quality_check(result):
result = self.retry_with_adjusted_params(params)
return result
def select_best_model(self, task_type):
"""根据实时延迟、成功率、成本选择最优模型"""
candidates = self.model_registry[task_type]
return sorted(candidates, key=lambda m: (
m.latency * 0.3 +
(1 - m.success_rate) * 0.4 +
m.cost * 0.3
))[0]
五、核心模块实现
模块 1：剧本解析引擎
class ScriptParser:
"""剧本解析：从完整剧本提取结构化数据"""
def parse(self, script_text: str) -> ParsedScript:
# 1. AI 提取大纲
outline = self.llm.generate(
prompt=OUTLINE_PROMPT,
input=script_text
)
# 2. AI 提取角色列表（含外貌描述）
characters = self.llm.generate(
prompt=CHARACTER_EXTRACT_PROMPT,
input=script_text,
output_format="json" # 强制 JSON 输出
)
# 3. AI 提取场景列表
scenes = self.llm.generate(
prompt=SCENE_EXTRACT_PROMPT,
input=script_text,
output_format="json"
)
# 4. 按集拆分
episodes = self.split_episodes(script_text, outline)
return ParsedScript(
outline=outline,
characters=characters,
scenes=scenes,
episodes=episodes
)
模块 2：角色一致性系统
这是整个系统最难也最关键的部分：
class CharacterConsistencyEngine:
"""角色一致性引擎：确保全剧角色形象统一"""
def generate_character_sheet(self, character: Character):
"""生成角色三视图 + 表情变体"""
# Step 1: 生成角色参考图
ref_image = self.image_model.generate(
prompt=f"Character design sheet, front/side/back view, "
f"{character.visual_description}",
style=character.style_reference, # 风格参考图
size="1024x1024"
)
# Step 2: 生成表情变体（关键：用参考图做 img2img）
expressions = ["happy", "angry", "sad", "surprised", "neutral"]
variants = []
for expr in expressions:
variant = self.image_model.generate(
prompt=f"{character.name}, {expr} expression, "
f"{character.visual_description}",
reference_image=ref_image, # ← 一致性关键
strength=0.6 # 控制变化幅度
)
variants.append(variant)
# Step 3: 存入角色卡资产库
self.asset_store.save_character_sheet(
character_id=character.id,
reference=ref_image,
variants=variants
)
return CharacterSheet(ref=ref_image, variants=variants)
def maintain_consistency(self, shot: Shot, characters: list):
"""分镜生成时保持角色一致性"""
reference_images = []
for char in characters:
sheet = self.asset_store.get_character_sheet(char.id)
reference_images.append(sheet.ref)
# 根据情绪选择对应表情变体
if shot.emotion:
reference_images.append(
sheet.get_variant(shot.emotion)
)
return self.image_model.generate(
prompt=shot.visual_prompt,
reference_images=reference_images, # 多图参考
style=self.project.style_reference
)
模块 3：智能分镜引擎
class StoryboardEngine:
"""智能分镜：剧本→专业镜头列表"""
def generate_storyboard(self, episode: Episode, characters: list):
shots = self.llm.generate(
prompt=STORYBOARD_PROMPT,
input={
"script": episode.text,
"characters": [c.to_dict() for c in characters],
"style": episode.style
},
output_format="json",
schema={
"shots": [{
"shot_number": int,
"scene": str,
"characters": [str],
"shot_type": "enum:extreme_close_up|close_up|medium|full|wide",
"camera_movement": "enum:static|pan|tilt|zoom|tracking|dolly",
"lighting": "enum:natural|dramatic|soft|backlit|low_key",
"action": str,
"dialogue": str,
"emotion": str,
"duration_seconds": float
}]
}
)
return [Shot(**s) for s in shots["shots"]]
模块 4：视频生成流水线
class VideoPipeline:
"""视频生成流水线：首尾帧→视频→合成"""
async def generate_episode(self, episode_id: str):
shots = self.db.get_shots(episode_id)
tasks = []
# 并行生成所有镜头
for shot in shots:
task = self.process_shot(shot)
tasks.append(task)
results = await asyncio.gather(*tasks, max_concurrency=10)
# FFmpeg 合成
final_video = self.compose_video(results)
return final_video
async def process_shot(self, shot: Shot):
# 1. 生成首帧
first_frame = self.image_model.generate(
prompt=shot.first_frame_prompt,
reference_images=shot.character_refs + [shot.scene_ref],
style=self.project.style_reference
)
# 2. 生成尾帧
last_frame = self.image_model.generate(
prompt=shot.last_frame_prompt,
reference_images=shot.character_refs + [shot.scene_ref],
style=self.project.style_reference,
init_image=first_frame # 保持连贯
)
# 3. 首尾帧→视频（图生视频）
video = self.video_model.generate(
first_frame=first_frame,
last_frame=last_frame,
motion_prompt=shot.camera_movement,
duration=shot.duration_seconds
)
# 4. 配音
if shot.dialogue:
audio = self.tts.generate(
text=shot.dialogue,
voice_id=shot.character.voice_id,
emotion=shot.emotion
)
video = self.merge_audio_video(video, audio)
return video
def compose_video(self, clips: list):
"""FFmpeg 合成最终视频"""
# 1. 拼接所有分镜片段
# 2. 烧录字幕
# 3. 添加 BGM
# 4. 转码输出
cmd = f"""
ffmpeg -f concat -safe 0 -i {clip_list} \
-vf "subtitles={subtitle_file}" \
-i {bgm_file} -filter_complex "[1:a]volume=0.3[bgm];[0:a][bgm]amix=inputs=2:duration=longest[aout]" \
-map 0:v -map "[aout]" \
-c:v libx264 -c:a aac \
-movflags +faststart \
{output_path}
"""
subprocess.run(cmd, shell=True)
return output_path
六、数据库设计
-- 项目表
CREATE TABLE projects (
id UUID PRIMARY KEY,
name VARCHAR(255),
style_reference_url TEXT, -- 全局风格参考图
aspect_ratio VARCHAR(10), -- 16:9 / 9:16 / 1:1
status VARCHAR(50), -- draft / producing / completed
created_at TIMESTAMP,
updated_at TIMESTAMP
);
-- 角色表
CREATE TABLE characters (
id UUID PRIMARY KEY,
project_id UUID REFERENCES projects(id),
name VARCHAR(100),
visual_description TEXT, -- AI 生成的外貌描述
reference_image_url TEXT, -- 角色参考图
voice_id VARCHAR(100), -- TTS 音色 ID
personality TEXT, -- 性格描述
created_at TIMESTAMP
);
-- 场景表
CREATE TABLE scenes (
id UUID PRIMARY KEY,
project_id UUID REFERENCES projects(id),
name VARCHAR(255),
visual_description TEXT,
background_image_url TEXT,
created_at TIMESTAMP
);
-- 分集表
CREATE TABLE episodes (
id UUID PRIMARY KEY,
project_id UUID REFERENCES projects(id),
episode_number INT,
script_text TEXT,
status VARCHAR(50),
output_video_url TEXT,
created_at TIMESTAMP
);
-- 分镜表
CREATE TABLE shots (
id UUID PRIMARY KEY,
episode_id UUID REFERENCES episodes(id),
shot_number INT,
scene_id UUID REFERENCES scenes(id),
shot_type VARCHAR(50), -- 景别
camera_movement VARCHAR(50), -- 运镜
lighting VARCHAR(50), -- 灯光
action_description TEXT, -- 动作描述
dialogue TEXT, -- 台词
emotion VARCHAR(50), -- 情绪
duration_seconds FLOAT, -- 时长
first_frame_url TEXT, -- 首帧图
last_frame_url TEXT, -- 尾帧图
video_url TEXT, -- 生成的视频
status VARCHAR(50),
created_at TIMESTAMP
);
-- 任务队列表
CREATE TABLE tasks (
id UUID PRIMARY KEY,
project_id UUID REFERENCES projects(id),
task_type VARCHAR(100), -- script_parse / character_gen / shot_gen / video_gen
status VARCHAR(50), -- pending / running / completed / failed
params JSONB,
result JSONB,
retry_count INT DEFAULT 0,
error_message TEXT,
created_at TIMESTAMP,
completed_at TIMESTAMP
);
七、一键生成流程（核心产品力）
这是神经猫的杀手级功能，你的平台也必须有：
class OneClickGenerator:
"""一句话生成漫剧：零基础用户的入口"""
async def generate(self, user_prompt: str, style: str = None):
# Step 1: 一句话→完整剧本（~10秒）
script = await self.script_writer.generate(
prompt=user_prompt,
genre=self.detect_genre(user_prompt),
episodes=10 # 默认 10 集
)
# Step 2: 剧本→角色提取+立绘（~30秒，并行）
characters = await self.parser.extract_characters(script)
character_tasks = [
self.consistency_engine.generate_character_sheet(c)
for c in characters
]
character_sheets = await asyncio.gather(*character_tasks)
# Step 3: 剧本→场景提取+背景图（~30秒，并行）
scenes = await self.parser.extract_scenes(script)
scene_tasks = [
self.image_model.generate(s.visual_prompt)
for s in scenes
]
scene_images = await asyncio.gather(*scene_tasks)
# Step 4: 分镜脚本（~10秒）
storyboard = await self.storyboard_engine.generate(
script.episodes[0], characters
)
# Step 5: 分镜图 + 视频（~2分钟，并行）
video = await self.video_pipeline.generate_episode(
episode_id=script.episodes[0].id
)
# Step 6: 配音 + 字幕 + 合成（~30秒）
final = await self.compose(video, script.episodes[0])
return final # 5分钟内出第一集成片
八、已有开源项目可复用
不用从零开始，已有成熟开源项目可以基于改造：
| 项目 | 地址 | 特点 | 适用场景 |
|---|---|---|---|
| AIComicBuilder | https://github.com/LingyiChen-AI/AIComicBuilder | Next.js 全栈，流水线完整，Docker 部署，多模型 | 最推荐，架构与神经猫最接近 |
| LocalMiniDrama | https://gitee.com/lankii/localminidrama | 纯 JS，本地离线，exe 可下载，多模型支持 | 个人/小团队快速上手 |
| director_ai | https://github.com/haobanz/director_ai | Flutter 移动端，手机上做漫剧 | 移动端场景 |
建议路径：Fork AIComicBuilder → 基于它二次开发 → 补齐神经猫的差异化能力
AIComicBuilder 生成流水线
剧本输入 → 剧本解析 → 角色提取 → 角色三视图
↓
智能分镜
↓
首尾帧生成（逐镜头）
↓
视频生成（逐镜头）
↓
视频合成 + 字幕
每个阶段支持单独触发或批量生成，用户可完全控制流水线节奏。
AIComicBuilder 项目结构
src/
├── app/
│ ├── [locale]/ # i18n 路由
│ │ ├── (dashboard)/ # 项目列表
│ │ ├── project/[id]/ # 项目编辑器
│ │ │ ├── script/ # 剧本编辑
│ │ │ ├── characters/ # 角色管理
│ │ │ ├── storyboard/ # 分镜面板
│ │ │ └── preview/ # 预览 & 合成
│ │ └── settings/ # 模型配置
│ └── api/ # API 路由
├── components/
│ ├── ui/ # 基础 UI 组件
│ ├── editor/ # 编辑器组件
│ └── settings/ # 设置组件
├── lib/
│ ├── ai/ # AI 供应商 & Prompt
│ ├── pipeline/ # 生成流水线
│ ├── db/ # 数据库 Schema
│ └── video/ # FFmpeg 处理
└── stores/ # Zustand 状态管理
AIComicBuilder 数据模型
- Project — 项目（剧本、状态）
- Character — 角色（名称、描述、参考图）
- Shot — 镜头（序号、提示词、时长、首尾帧、视频）
- Dialogue — 对白（角色、文本、音频）
- Task — 后台任务队列
AIComicBuilder Docker 部署
# 一键启动
docker run -d -p 3000:3000 \
-v ./data:/app/data \
-v ./uploads:/app/uploads \
-e OPENAI_API_KEY=sk-xxx \
-e DATABASE_URL=file:./data/prod.db \
ghcr.io/lingyichen-ai/aicomicbuilder:latest
持久化数据：
./data— SQLite 数据库文件./uploads— 上传的文件及生成的资源（图片、视频等）
手动构建镜像：
git clone https://github.com/LingyiChen-AI/AIComicBuilder.git
cd AIComicBuilder
docker build -t ai-comic-builder .
九、你 vs 神经猫：差异化竞争点
神经猫已经占住了专业交付系统的位，你需要找到自己的差异化：
| 维度 | 神经猫的做法 | 你的差异化方向 |
|---|---|---|
| 定位 | 专业团队/承制方 | 个人创作者 / 特定垂类（如教育/广告/漫画） |
| 部署 | 纯云端 | 本地+云端混合，数据自主 |
| 定价 | 按分钟计费 | 开源免费 + 增值服务 |
| 风格 | 短剧/漫剧为主 | 动画/绘本/教学/广告多模态 |
| 交互 | 专业编辑器 | 对话式创作（跟 AI 聊着就把剧做了） |
| 社区 | 封闭生态 | 开源社区 + 模板市场 |
十、落地路线图
| 阶段 | 时间 | 目标 | 关键交付 |
|---|---|---|---|
| MVP | 4-6 周 | 跑通核心流水线 | 剧本→角色→分镜→图片→视频→合成 |
| V1 | 8-12 周 | 一句话生成 + 角色一致性 | 5 分钟出片 + 角色跨帧一致 |
| V2 | 4-6 月 | 批量生产 + 多模型调度 | 100 集并行 + 失败重试 + 质量评估 |
| V3 | 6-8 月 | 团队协作 + 资产沉淀 | 审改闭环 + 交付包 + 模板市场 |
MVP 阶段详细拆解（4-6 周）
Week 1-2：基础架构搭建
- Fork AIComicBuilder，本地跑通
- 数据库迁移到 PostgreSQL（从 SQLite）
- 搭建 Redis + BullMQ 任务队列
- 对象存储接入（S3/COS）
Week 3-4：核心流水线
- 剧本解析引擎（LLM 接入）
- 角色提取 + 参考图生成
- 分镜脚本自动生成
- 图生视频（Seedance 2.0 / 可灵接入）
Week 5-6：合成 + 基础 UI
- FFmpeg 视频合成 + 字幕烧录
- TTS 配音接入
- 前端编辑器基础功能
- 端到端测试 + Bug 修复
十一、成本估算
| 项目 | 月费用（初期） | 月费用（规模化） |
|---|---|---|
| 云服务器（2×A100） | ¥8,000–12,000 | ¥30,000–50,000 |
| AI API 调用（文本+图片+视频） | ¥5,000–15,000 | ¥50,000–200,000 |
| 对象存储 + CDN | ¥500–2,000 | ¥5,000–20,000 |
| 数据库（PostgreSQL + Redis） | ¥500–1,500 | ¥3,000–8,000 |
| 合计 | ¥14,000–30,500 | ¥88,000–278,000 |
单集制作成本目标：< ¥100（规模化后）
十二、关键 Prompt 模板
剧本扩写 Prompt
你是一位专业编剧。请根据以下一句话创意，扩写为完整的多集短剧剧本。
创意：{user_prompt}
风格：{style}
集数：{episode_count}
要求：
1. 每集 300-500 字，节奏紧凑，冲突密集
2. 每集结尾留悬念
3. 角色性格鲜明，对话生动
4. 标注场景、动作、表情
输出格式：
【第X集】
场景：xxx
（动作描述）
角色A：台词
角色B：台词
...
角色提取 Prompt
从以下剧本中提取所有角色，为每个角色生成详细的视觉描述。
剧本：
{script_text}
输出 JSON 格式：
{
"characters": [
{
"name": "角色名",
"role": "主角/配角/反派",
"age": "年龄段",
"gender": "性别",
"visual_description": "详细外貌描述（发型、发色、瞳色、体型、服装风格、标志性特征）",
"personality": "性格关键词",
"default_expression": "默认表情",
"voice_type": "音色描述（低沉/清脆/温柔等）"
}
]
}
分镜生成 Prompt
你是一位专业分镜师。请将以下剧本片段拆解为分镜脚本。
剧本片段：
{episode_text}
角色信息：
{characters_json}
输出 JSON 格式：
{
"shots": [
{
"shot_number": 1,
"scene": "场景描述",
"characters": ["出镜角色"],
"shot_type": "景别(close_up/medium/full/wide)",
"camera_movement": "运镜(static/pan/zoom/tracking/dolly)",
"lighting": "灯光(natural/dramatic/soft/backlit)",
"action": "动作描述",
"dialogue": "台词（如有）",
"emotion": "情绪",
"duration_seconds": 3.0,
"first_frame_prompt": "首帧画面描述",
"last_frame_prompt": "尾帧画面描述"
}
]
}
十三、风险与应对
| 风险 | 影响 | 应对策略 |
|---|---|---|
| 角色一致性不足 | 用户体验差，返工率高 | 多图参考 + LoRA 微调 + 角色卡资产库 |
| 视频生成质量不稳定 | 成品可用率低 | 多模型备选 + 失败重试 + 人工审核节点 |
| AI API 成本失控 | 利润为负 | 多供应商比价 + 缓存复用 + 降级策略 |
| 高峰期排队 | 用户流失 | 多供应商算力 + 弹性扩缩 + 优先级队列 |
| 版权风险 | 法律纠纷 | 合规素材库 + 角色原创生成 + 规避名人肖像 |
| 平台封杀 | 分发受限 | 多平台分发 + 自建渠道 + 合规审核 |
十四、竞品对比速查
| 工具 | 定位 | 上手难度 | 画面质量 | 角色一致性 | 生产效率 | 价格 |
|---|---|---|---|---|---|---|
| Catimind（神经猫） | 专业交付系统 | ★★☆☆☆ | ★★★★★ | ★★★★★ | ★★★★★ | 单分钟<100元 |
| 漫小芽 | 新手一键出片 | ★☆☆☆☆ | ★★★☆☆ | ★★★★☆ | ★★★★☆ | 免费起步 |
| 白日梦 AI | 免费多风格 | ★★☆☆☆ | ★★☆☆☆ | ★★★☆☆ | ★★★☆☆ | 完全免费 |
| Coze+Seedance | 技术流自动化 | ★★★★☆ | ★★★★☆ | ★★★★☆ | ★★★★★ | 30-60元/集 |
| 万兴剧厂 | 工业化生产力 | ★★★☆☆ | ★★★★★ | ★★★★★ | ★★★★★ | 会员制（较高） |
十五、总结
搭建一个像神经猫一样的全自动 AI 漫剧平台，核心不是模型能力，而是工程编排能力：
- 流水线设计 — 把碎片化的 AI 能力串联为端到端交付
- 角色一致性 — 这是技术壁垒，也是用户体验的生命线
- 多模型调度 — 不依赖单一模型，自动选优 + 失败切换
- 批量生产 — 100 集并行，2 天出片，才是工业化
- 资产沉淀 — 角色卡、场景库、风格包，跨项目复用
最快路径：Fork AIComicBuilder → 补齐角色一致性 + 一句话生成 → 先跑通 MVP，再迭代差异化。
欢迎加入DeepSeek 技术社区。在这里，你可以找到志同道合的朋友，共同探索AI技术的奥秘。
更多推荐
9
0- 0
已为社区贡献2条内容
所有评论(0)