AI 视频 on 方糖猫Blog

口播视频自动剪辑：Whisper 词级时间轴 + LLM 视觉规划

Mon, 23 Feb 2026 12:00:00 +0800

口播视频自动剪辑：Whisper 词级时间轴 + LLM 视觉规划

我开发的 GeekCast Engine 是一个面向口播类视频的 AI 自动剪辑平台。用户上传一段口播视频后，系统自动完成转写、粗剪、视觉规划和成片渲染。这篇文章会重点拆解两个核心模块：Whisper 词级时间轴处理 和 LLM 视觉元素规划。

一、口播剪辑的核心痛点

口播视频通常是一个人对着镜头讲话，形式单一，但剪辑过程却很繁琐：

气口和语气词太多：「嗯」「啊」「这个」「那个」需要逐个删掉
节奏单调：长时间只有说话人画面，观众容易疲劳
信息密度不均：有些段落需要配合 B-roll、标题卡、代码块来强化表达
长视频处理困难：10 分钟以上的口播，人工剪辑耗时往往在数小时

我们的目标不是完全替代剪辑师，而是把重复、机械、规则明确的工作自动化，让人专注于创意和审校。

二、整体技术架构

flowchart TD
    A["口播视频上传"] --> B["Whisper 词级转写"]
    B --> C["LLM 语义分析 + 视觉规划"]
    C --> D["自动粗剪（删气口/语气词/冗余片段）"]
    D --> E["Remotion 组件化渲染"]
    E --> F["FFmpeg 后处理输出成片"]

整个流程里，最关键的两个环节是：

时间轴精度：决定了粗剪是否精准
视觉规划质量：决定了成片是否好看

三、Whisper 词级时间轴

3.1 为什么选择 Whisper

OpenAI Whisper 是目前开源语音识别模型中最成熟的选择之一，优势很明显：

支持 99 种语言，中文识别效果不错
提供 word-level timestamps（词级时间戳），这是自动剪辑的基础
模型大小可选，从小到大有 tiny/base/small/medium/large

3.2 词级时间戳的获取

Whisper 本身不直接输出词级时间戳，需要借助 whisper-timestamped 或 faster-whisper 等工具。我们用 faster-whisper，因为它：

推理速度更快
支持 VAD（语音活动检测），减少静音误判
对长音频更稳定

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cuda", compute_type="float16")

segments, info = model.transcribe(
    "input.mp3",
    word_timestamps=True,
    vad_filter=True,
    language="zh"
)

words = []
for segment in segments:
    for word in segment.words:
        words.append({
            "text": word.word,
            "start": word.start,
            "end": word.end,
            "probability": word.probability
        })

3.3 词级数据结构

转写完成后，每个词对应一个时间片段：

{
  "text": "大家好",
  "start": 0.32,
  "end": 0.98,
  "probability": 0.95
}

多个词可以聚合成句子、段落，形成完整的时间轴树：

Paragraph
  ├── Sentence 1
  │     ├── Word 1
  │     ├── Word 2
  │     └── Word 3
  └── Sentence 2
        ├── Word 4
        └── Word 5

3.4 气口和语气词删除

基于词级时间轴，我们可以做很多精细化编辑：

# 语气词列表
FILLER_WORDS = {"嗯", "啊", "这个", "那个", "就是", "然后", "对吧"}

def remove_fillers(words, filler_words=FILLER_WORDS):
    """删除单个语气词，保留相邻词的时间连续性"""
    result = []
    for w in words:
        if w["text"].strip() in filler_words:
            continue
        result.append(w)
    return result


def remove_long_pauses(words, threshold=0.8):
    """删除过长的停顿片段"""
    result = []
    for i, w in enumerate(words):
        if i > 0:
            gap = w["start"] - words[i-1]["end"]
            if gap > threshold:
                continue  # 也可以只压缩，不完全删除
        result.append(w)
    return result

3.5 时间轴漂移问题

实际使用中发现，Whisper 的词级时间戳在语速快、口音重、背景音乐干扰时会出现漂移。我们做了几个处理：

置信度过滤：识别概率低于 0.7 的词标记为待审校
句子级对齐：用 VAD 检测到的语音段和转写句子做二次对齐
人工修正入口：前端提供波形图 + 时间轴，允许用户微调

四、LLM 视觉规划

4.1 视觉元素类型

我们定义了口播视频中常用的几类视觉元素：

元素类型	作用	示例
标题卡	章节切换、强调重点	大标题 + 副标题
B-roll	缓解视觉疲劳，补充画面	相关图片/视频片段
引用卡	引用名人名言、数据	金句 + 出处
代码块	技术类口播展示代码	高亮代码片段
列表卡	展示多个要点	1/2/3 列表

4.2 LLM 规划任务

输入是一段按句子切分好的口播文本，输出是每个句子应该配什么视觉元素。Prompt 设计如下：

你是一名专业的口播视频剪辑师。请根据以下口播文案，为每个句子规划合适的视觉元素。

可用视觉元素：
- TitleCard: 标题卡，用于章节开头或强调核心观点
- BRoll: B-roll 画面，用于补充说明内容
- QuoteCard: 引用卡，用于展示名言、数据
- CodeBlock: 代码块，用于展示代码
- ListCard: 列表卡，用于展示多个要点
- TalkingHead: 保持说话人画面，不添加额外元素

口播文案：
{script}

请输出 JSON 数组，每个元素包含：
- sentence_index: 句子序号
- element_type: 视觉元素类型
- reason: 选择理由
- suggested_content: 建议展示的内容（如 B-roll 的画面描述、标题文字等）

4.3 输出结构化

LLM 返回的结果类似：

[
  {
    "sentence_index": 0,
    "element_type": "TitleCard",
    "reason": "开场需要点题",
    "suggested_content": "AI 自动剪辑实战"
  },
  {
    "sentence_index": 3,
    "element_type": "BRoll",
    "reason": "解释'时间轴'概念时需要补充画面",
    "suggested_content": "视频编辑软件中的时间轴界面"
  },
  {
    "sentence_index": 8,
    "element_type": "CodeBlock",
    "reason": "展示 Whisper 调用代码",
    "suggested_content": "faster_whisper 示例代码"
  }
]

4.4 与素材库联动

视觉规划中的 suggested_content 会作为查询条件，调用我们在第二篇文章中讲的 RAG 素材库，检索匹配的 B-roll、图片或文案片段。

def plan_and_retrieve(script: str):
    # 1. LLM 做视觉规划
    plan = llm.generate_visual_plan(script)

    # 2. 对每个 B-roll 规划项检索素材
    for item in plan:
        if item["element_type"] == "BRoll":
            item["materials"] = rag_retrieve(item["suggested_content"])

    return plan

五、长视频 Token 限制处理

口播视频动辄 10 分钟以上，对应的文案可能超过 3000 字，直接塞给 LLM 做视觉规划会触发 Token 限制，而且单次规划效果也不好。

我们的解决方案是：分段生成 + 本地组装。

5.1 分段策略

按段落切分：每段约 800-1200 字
保留上下文：每段开头会附带上一段的结尾摘要
独立规划：每段分别调用 LLM 做视觉规划
全局对齐：最后统一调整时间轴、样式和转场

def split_script(script: str, max_chars: int = 1000):
    """按段落切分文案，尽量保持段落完整性"""
    paragraphs = script.split('\n')
    chunks = []
    current = ""

    for p in paragraphs:
        if len(current) + len(p) > max_chars and current:
            chunks.append(current)
            current = p
        else:
            current += '\n' + p

    if current:
        chunks.append(current)

    return chunks

5.2 本地组装

分段规划完成后，需要在本地合并：

统一句子索引
统一视觉风格（字体、配色、动画）
处理段与段之间的转场
生成最终的 Remotion 渲染数据

六、Remotion 组件化渲染

6.1 为什么用 Remotion

Remotion 让我们可以用 React 组件来描述视频画面，非常契合「视觉元素 = 组件」的思路。

每个视觉元素对应一个 React 组件：

// 标题卡组件
export const TitleCard: React.FC<{ title: string; subtitle: string }> = ({ title, subtitle }) => {
  return (
    <AbsoluteFill style={{ backgroundColor: '#111', justifyContent: 'center', alignItems: 'center' }}>
      <h1 style={{ color: '#fff', fontSize: 80 }}>{title}</h1>
      <p style={{ color: '#aaa', fontSize: 36 }}>{subtitle}</p>
    </AbsoluteFill>
  );
};

6.2 渲染流程

flowchart TD
    A["视觉规划结果"] --> B["生成 Remotion composition（每个视觉元素对应一个组件实例）"]
    B --> C["Remotion 渲染为视频文件"]
    C --> D["FFmpeg 后处理：合成音频、加字幕、转码、多分辨率输出"]

6.3 多分辨率输出

平台需要同时支持横屏（16:9）和竖屏（9:16），我们在 Remotion 组件内部做响应式布局：

const { width, height } = useVideoConfig();
const isVertical = height > width;

七、踩过的坑

7.1 Whisper 模型选择纠结

tiny 速度最快但准确率太低
large 准确率最高但显存和速度压力大
最终我们选 small 做默认模型，large 做可选质量模式

7.2 LLM 规划风格不一致

同一个文案多次调用 LLM，返回的视觉规划可能风格差异很大。我们做了：

Prompt 里加入平台风格示例
视觉元素类型和样式模板固定
对返回结果做规则校验和兜底

7.3 代码块渲染需要特殊处理

代码块里的长行、特殊字符、换行等都会影响 Remotion 渲染。我们专门封装了一个 CodeBlock 组件，处理：

自动换行和字体缩放
语法高亮
行号显示

八、效果与反思

目前 GeekCast Engine 能在一分钟左右完成 5-10 分钟口播视频的自动粗剪和视觉规划，最终成片需要人工简单审校即可发布。

量化效果（待补充真实数据）：

10 分钟口播视频，人工剪辑平均 X 小时，自动剪辑约 X 分钟
气口和语气词删除覆盖率约 X%
LLM 视觉规划采纳率约 X%

反思：

自动剪辑还不能做到 100% 无人工，但已经能替代 60%-70% 的重复劳动
视觉规划比粗剪更难，未来需要结合用户反馈做迭代优化
长视频场景下，分段策略和上下文保留是关键

九、总结

口播视频自动剪辑是把 ASR、LLM、视频渲染三项技术串联起来的典型 AI 工程场景。几个关键经验：

词级时间轴是粗剪的基础，Whisper + faster-whisper 是性价比较高的方案
LLM 视觉规划要把输出结构固定，Prompt 设计决定可控性
长视频必须分段处理，本地组装时注意风格和转场一致性
Remotion 让视频渲染工程化，组件化思路适合多变的视觉需求

如果你也在做 AI 视频生成或自动剪辑相关的项目，欢迎交流 Whisper 调优和 LLM 规划的经验。

LangChain 入门笔记：AI 视频生成实战

Fri, 28 Nov 2025 11:00:00 +0800

LangChain 入门笔记：AI 视频生成实战

最近重新刷了吴恩达和 Harrison Chase 主讲的《LangChain for LLM Application Development》。这门课不长，但把 LangChain 的"为什么存在"讲得很透：它不是让你写更多胶水代码，而是把 LLM 调用、提示工程、上下文管理、工具调用这些重复模式抽象成可组合的组件。这篇文章整理课程里的核心原理，并落到我们最熟悉的 AI 视频生成场景，给出可直接跑的 Demo。

一、LangChain 解决什么问题？

在直接调用 OpenAI / Claude / 国产大模型 API 时，我们通常会写出这样的代码：

import openai

messages = [
    {"role": "system", "content": "你是一位短视频脚本专家。"},
    {"role": "user", "content": "主题是'如何用 LangChain 生成视频脚本'，风格轻松，30 秒左右。"}
]
resp = openai.chat.completions.create(model="gpt-4o", messages=messages)
script = resp.choices[0].message.content

这段代码能跑，但问题很明显：

提示词散落在各处，难以复用和版本管理；
输出是字符串，需要手写解析逻辑；
多轮对话、上下文记忆要自己拼 messages；
一旦涉及"检索素材 → 生成脚本 → 检查合规 → 输出结构化数据"，代码就会迅速膨胀成面条。

LangChain 的核心思想：把 LLM 应用里的常见模式抽象成标准组件，让你像搭积木一样拼装工作流。

可以把它理解成：

LangChain = 模型接口统一层 + 提示模板 + 输出解析 + 记忆 + 链式调用 + 工具/Agent 编排

二、课程核心内容回顾

吴恩达这门课围绕 6 个模块展开，也是 LangChain 最基础的 6 个能力：

模块	作用	视频生成场景映射
Models	统一不同 LLM 的调用接口	切换 GPT-4o / Claude / 国产模型时无需改业务代码
Prompts	模板化管理提示词	脚本生成、分镜描述、标题优化的模板复用
Output Parsers	把自然语言输出转成结构化数据	解析 JSON 分镜、时间轴、素材清单
Memory	维护多轮对话状态	用户反复修改脚本时保留上下文
Chains	把多个 LLM/工具步骤串成链	“主题 → 大纲 → 脚本 → 分镜 → 渲染参数"流水线
Agents	让 LLM 决定调用哪些工具	Agent 自主判断需要检索素材还是生成画面描述

下面逐一看原理和代码。

三、核心组件原理与示例

3.1 Models & Prompts：统一接口与模板复用

LangChain 用 ChatOpenAI、ChatAnthropic 等类封装模型，并用 ChatPromptTemplate 管理提示词模板。

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o", temperature=0.7)

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位短视频脚本专家，擅长把技术概念写成{style}风格的口播脚本。"),
    ("human", "主题是：{topic}，时长控制在{duration}秒，需要{scene_count}个分镜。")
])

messages = prompt.invoke({
    "style": "轻松幽默",
    "topic": "LangChain 如何自动生成视频脚本",
    "duration": 30,
    "scene_count": 3
})

response = llm.invoke(messages)
print(response.content)

好处：

提示词与业务数据解耦，模板可复用、可版本化；
切换模型只需改一行 ChatOpenAI → ChatAnthropic；
支持批量 batch、流式 stream、异步 ainvoke 等高级调用方式。

3.2 Output Parsers：从文本到结构化数据

视频生成流程需要结构化输出，例如：

{
  "scenes": [
    {"time": "0-10s", "narration": "...", "visual": "...", "bgm": "..."}
  ],
  "title": "...",
  "tags": ["..."]
}

LangChain 提供 PydanticOutputParser，让模型按指定 Schema 输出。

from pydantic import BaseModel, Field
from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.prompts import PromptTemplate

class Scene(BaseModel):
    time_range: str = Field(description="时间区间，如 0-10s")
    narration: str = Field(description="口播文案")
    visual: str = Field(description="画面描述，用于后续生成图片/视频")
    bgm_mood: str = Field(description="背景音乐情绪")

class VideoScript(BaseModel):
    title: str
    scenes: list[Scene]
    tags: list[str]

parser = PydanticOutputParser(pydantic_object=VideoScript)

prompt = PromptTemplate(
    template="根据主题生成短视频脚本。\n{format_instructions}\n主题：{topic}\n时长：{duration}秒\n",
    input_variables=["topic", "duration"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

chain = prompt | llm | parser
result = chain.invoke({"topic": "LangChain 自动生成短视频", "duration": 30})
print(result.model_dump_json(indent=2))

注意：LLM 不一定 100% 返回合法 JSON，生产环境建议加 RetryOutputParser 或兜底解析。

3.3 Memory：多轮修改不再"失忆”

做视频脚本时，用户常会说：“前面不错，但把第二段改得更口语化一点”。没有记忆，LLM 会从头生成，丢失已确认的片段。

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

memory = ConversationBufferMemory()
conversation = ConversationChain(llm=llm, memory=memory)

conversation.predict(input="帮我写一个 30 秒的 LangChain 短视频脚本")
conversation.predict(input="第二段太正式了，改成口语化一些")
print(memory.load_memory_variables({}))

LangChain 还提供 ConversationBufferWindowMemory（只保留最近 N 轮）、ConversationSummaryMemory（摘要历史）等，适用于长会话场景。

3.4 Chains：把多个步骤串成流水线

视频生成的一个典型链：

主题 → 生成标题 → 生成脚本 → 生成分镜 → 输出结构化渲染参数

用 LCEL（LangChain Expression Language）可以非常直观地表达：

from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# 子链 1：生成标题
title_prompt = ChatPromptTemplate.from_template("为'{topic}'写一个 20 字以内的爆款标题")
title_chain = title_prompt | llm | StrOutputParser()

# 子链 2：根据标题和主题生成脚本
script_prompt = ChatPromptTemplate.from_template(
    "标题：{title}\n主题：{topic}\n时长：{duration}秒\n请生成 3 个分镜的脚本。"
)
script_chain = script_prompt | llm | StrOutputParser()

# 组合
full_chain = (
    {"topic": RunnablePassthrough(), "duration": RunnablePassthrough()}
    | RunnablePassthrough.assign(title=title_chain)
    | RunnablePassthrough.assign(script=script_chain)
)

result = full_chain.invoke({"topic": "LangChain 视频生成", "duration": 30})
print(result)

LCEL 的 | 运算符让数据流像 Unix 管道一样清晰，这也是 LangChain 从 0.1 到 0.2/0.3 版本最重要的设计演进。

3.5 RAG：用本地素材库增强脚本生成

做批量短视频时，通常有沉淀的素材库（文案库、分镜库、音乐库）。LangChain 的 RAG 组件可以让模型先检索再生成：

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains.combine_documents import create_stuff_documents_chain

# 1. 构建向量库
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(
    ["分镜案例 1：开头用悬念钩子...", "爆款标题公式：数字+痛点+解决方案..."],
    embedding=embeddings
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# 2. 构建 RAG Chain
prompt = ChatPromptTemplate.from_messages([
    ("system", "参考以下素材生成脚本：\n\n{context}"),
    ("human", "主题：{topic}，时长：{duration}秒")
])

rag_chain = create_stuff_documents_chain(llm, prompt) | {
    "topic": lambda x: x["topic"],
    "context": retriever
}

# 实际调用时先检索文档，再塞入 prompt

在方糖猫 AI 短视频平台的工程实现中，我们会把 RAG 检索结果和 LangGraph 状态机结合，实现"检索 → 生成 → 人工审核 → 渲染"的完整闭环。

3.6 Agents：让 LLM 自己决定下一步

当流程不是固定流水线，而是需要动态决策时，Agent 更有优势。例如：

判断用户输入是否需要检索素材库；
根据脚本内容决定调用文生图还是文生视频工具；
调用外部 API 查询热点话题。

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.tools import tool

@tool
def generate_image(description: str) -> str:
    """根据画面描述生成一张图片，返回图片 URL。"""
    # 实际接入 DALL·E / Midjourney / Stable Diffusion
    return f"https://fake-img.example.com?prompt={description}"

@tool
def generate_video_clip(description: str, duration: int) -> str:
    """根据画面描述生成一段视频片段，返回视频 URL。"""
    return f"https://fake-video.example.com?prompt={description}&duration={duration}"

tools = [generate_image, generate_video_clip]

agent_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位 AI 视频导演，能调用工具生成图片或视频。"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_openai_tools_agent(llm, tools, agent_prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

agent_executor.invoke({
    "input": "我要一个 30 秒关于 LangChain 的短视频，先出 3 张分镜图，再合成视频。"
})

四、Demo：一个可扩展的"AI 视频脚本生成器"

下面把上面所有组件串起来，做一个最小的可运行 Demo。它的输出是一份结构化脚本，后续可以无缝接到 Remotion、FFmpeg 或视频生成 API。

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.runnables import RunnablePassthrough
from pydantic import BaseModel, Field

os.environ["OPENAI_API_KEY"] = "your-api-key"

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

class Scene(BaseModel):
    time_range: str
    narration: str
    visual: str
    tool: str = Field(description="生成该分镜所需工具：image 或 video")

class VideoProject(BaseModel):
    title: str
    target_platform: str
    scenes: list[Scene]

parser = PydanticOutputParser(pydantic_object=VideoProject)

title_chain = (
    ChatPromptTemplate.from_template("为'{topic}'写一个适合{platform}的爆款标题")
    | llm
    | StrOutputParser()
)

script_prompt = ChatPromptTemplate.from_template(
    """为平台"{target_platform}"生成短视频脚本。
{format_instructions}
标题：{title}
主题：{topic}
时长：{duration}秒
要求：每个分镜标注用 image（图片）还是 video（视频片段）生成。
"""
)

script_chain = (
    RunnablePassthrough.assign(title=title_chain)
    | script_prompt.partial(format_instructions=parser.get_format_instructions())
    | llm
    | parser
)

project = script_chain.invoke({
    "topic": "LangChain 如何帮助 AI 视频创作",
    "platform": "抖音",
    "target_platform": "抖音",
    "duration": 30
})

print(project.model_dump_json(indent=2, ensure_ascii=False))

下一步可以扩展的方向：

把 Scene.visual 传给 DALL·E / Stable Diffusion / 可灵 / Pika 生成画面；
用 pydub + gTTS 合成配音，或用 CosyVoice 克隆音色；
用 Remotion 或 MoviePy 把图片、视频、字幕、BGM 合成为成片；
接入 LangGraph 做状态持久化和人工审核节点（参考我之前写的 LangGraph 入门笔记）。

五、分布式场景下的运行方案

当 LangChain 应用从本地脚本走向生产环境，单进程运行肯定不够。AI 视频生成是典型的长链路任务：脚本生成、素材检索、文生图、文生视频、配音、渲染，每一步都可能耗时数秒到数分钟。分布式架构的关键是：让 LangChain 推理层保持无状态，把状态交给任务队列和持久化存储。

关键设计点

LangChain 服务无状态化 不保存用户会话到本地内存，所有上下文通过 state 参数或 Redis 传入。这样任意 Worker 都可以处理任意任务，方便水平扩展。
任务队列解耦 用 Celery、RQ 或自研 Worker 消费 RocketMQ/Redis Stream。一个任务对应一次视频生成链路，失败可以重试，不会阻塞 API 网关。
持久化中间状态 把每个阶段的结果（脚本 JSON、分镜图 URL、视频片段 URL）写入数据库。如果 Worker 崩溃，可以从上一个阶段恢复，而不是从头执行。
LangGraph 的分布式友好性 LangGraph 的 State 天然适合持久化。可以配置 checkpointer 把状态快照到 Redis/Postgres，实现断点续跑：

from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import StateGraph

builder = StateGraph(VideoGenState)
# ... 添加节点和边 ...
graph = builder.compile(checkpointer=MemorySaver())

生产环境建议把 MemorySaver 替换为 PostgresSaver 或 RedisSaver，让不同 Worker 共享状态。

六、服务器异常恢复方案

AI 视频生成链路长、依赖多（LLM API、素材库、视频生成服务、对象存储），任何一环抖动都会导致失败。异常恢复不是简单 try/except，而是要从架构层面保证可观测、可重试、可续跑。

1. 分级重试策略

异常类型	处理方式	示例
LLM API 限流 / 超时	指数退避重试 3 次	`tenacity` 或 LangChain 内置 `max_retries`
第三方服务不可用	降级或转人工审核	视频生成失败时返回占位图 + 提示
Worker 进程崩溃	队列自动重发，幂等消费	Celery `acks_late=True`
数据格式错误	进入死信队列，人工处理	JSON 解析失败

LangChain 调用模型时建议统一封装：

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def invoke_with_retry(chain, inputs):
    return chain.invoke(inputs)

2. 幂等性设计

同一个视频生成任务可能因为网络超时被重复投递。给每个任务分配唯一 task_id，在数据库里记录 PENDING → PROCESSING → SUCCESS/FAILURE 状态。Worker 消费前先看状态，避免重复执行。

def process_video_task(task_id: str, inputs: dict):
    if db.get_status(task_id) in ("SUCCESS", "PROCESSING"):
        return db.get_result(task_id)

    db.set_status(task_id, "PROCESSING")
    try:
        result = video_chain.invoke(inputs)
        db.set_status(task_id, "SUCCESS", result=result)
        return result
    except Exception as e:
        db.set_status(task_id, "FAILURE", error=str(e))
        raise

3. 死信队列（DLQ）

重试仍然失败的任务进入死信队列，由告警系统通知运维或产品人员处理。DLQ 里的任务可以手动重跑、补数据或退款。

4. 状态快照与断点续跑

结合 LangGraph 的 checkpointer，每个节点执行完后自动保存状态。Worker 重启后，可以根据 thread_id 恢复到最近的 checkpoint：

config = {"configurable": {"thread_id": task_id}}
# 首次执行
graph.invoke(initial_state, config=config)

# Worker 重启后继续执行
state = graph.get_state(config)
graph.invoke(None, config=config)  # 从 checkpoint 继续

七、如何实现高并发

AI 视频生成场景的高并发，核心矛盾是：LLM API 调用有速率限制，但用户请求可能突增。不能简单堆机器，需要把 IO 等待和计算分离。

1. 异步调用释放线程

LangChain 支持 ainvoke、abatch、astream，配合 asyncio 可以大幅提升吞吐：

import asyncio

async def batch_generate(tasks):
    results = await script_chain.abatch(tasks)
    return results

# 并发处理 20 个脚本生成请求
tasks = [{"topic": t, "duration": 30} for t in topic_list]
results = asyncio.run(batch_generate(tasks))

注意：底层 HTTP 客户端（如 httpx）需要配置连接池，避免每次请求新建连接。

2. 流式响应降低首字节延迟

对于长文本生成，使用 astream 把结果逐步返回给用户，避免长时间阻塞：

async for chunk in chain.astream({"topic": "LangChain 高并发"}):
    print(chunk, end="", flush=True)

3. 限流与背压

模型侧限流：根据 OpenAI/Claude 的 RPM/TPM 限制，用令牌桶算法控制请求速率。
队列侧背压：当队列堆积超过阈值时，API 网关返回 429 Too Many Requests，保护下游 Worker。

import asyncio
from asyncio import Semaphore

sem = Semaphore(10)  # 同时最多 10 个 LLM 调用

async def limited_invoke(inputs):
    async with sem:
        return await chain.ainvoke(inputs)

4. 缓存常用结果

很多提示词是重复的（比如热门模板、常见分镜描述）。可以用 Redis 缓存 prompt_hash → result，命中时直接返回，不走 LLM：

import hashlib

def get_cache_key(inputs: dict) -> str:
    return hashlib.sha256(json.dumps(inputs, sort_keys=True).encode()).hexdigest()

key = get_cache_key(inputs)
if cached := redis.get(key):
    return json.loads(cached)

result = chain.invoke(inputs)
redis.setex(key, 3600, json.dumps(result))

5. 水平扩展与资源隔离

CPU 密集型步骤（如 FFmpeg 渲染、图片后处理）放到独立 Worker 池，避免阻塞 LLM 推理线程。
GPU 密集型步骤（如文生视频）单独部署 GPU 节点，通过队列按需调度。
API 网关层用 Nginx/Envoy 做负载均衡，无状态 LangChain 服务可以快速扩容。

八、学完这门课的几点体会

不要神化 LangChain：它本质是高阶胶水，帮你少写重复代码，但不会让模型变得更聪明。复杂的业务逻辑仍然需要自己设计。
优先用 LCEL：新项目中尽量用 Runnable + | 组合链，比旧的 LLMChain、SequentialChain 更灵活、更易调试。
结构化输出是工程关键：视频、电商、客服等场景都需要把 LLM 输出转成 JSON，PydanticOutputParser 是必备技能。
Agent 不是银弹：固定流程用 Chain，动态决策才用 Agent。Agent 调试成本高，要配合观察日志和工具描述优化。

九、参考资源

吴恩达 & Harrison Chase 官方课程：LangChain for LLM Application Development
中文笔记与代码：awesome-LangChain-for-LLM-Application-Development
我之前的相关笔记：LangGraph 入门：给传统工程师的 Agent 状态与编排指南

这篇文章把吴恩达课程的核心内容和我自己在 AI 视频生成项目里的经验做了结合。如果你也在用 LangChain 做视频、口播剪辑或 Agent 工作流，欢迎留言交流。

AI 视频 on 方糖猫Blog

口播视频自动剪辑：Whisper 词级时间轴 + LLM 视觉规划

口播视频自动剪辑：Whisper 词级时间轴 + LLM 视觉规划

一、口播剪辑的核心痛点

二、整体技术架构

三、Whisper 词级时间轴

3.1 为什么选择 Whisper

3.2 词级时间戳的获取

3.3 词级数据结构

3.4 气口和语气词删除

3.5 时间轴漂移问题

四、LLM 视觉规划

4.1 视觉元素类型

4.2 LLM 规划任务

4.3 输出结构化

4.4 与素材库联动

五、长视频 Token 限制处理

5.1 分段策略

5.2 本地组装

六、Remotion 组件化渲染

6.1 为什么用 Remotion

6.2 渲染流程

6.3 多分辨率输出

七、踩过的坑

7.1 Whisper 模型选择纠结

7.2 LLM 规划风格不一致

7.3 代码块渲染需要特殊处理

八、效果与反思

九、总结

LangChain 入门笔记：AI 视频生成实战

LangChain 入门笔记：AI 视频生成实战

一、LangChain 解决什么问题？

二、课程核心内容回顾

三、核心组件原理与示例

3.1 Models & Prompts：统一接口与模板复用

3.2 Output Parsers：从文本到结构化数据

3.3 Memory：多轮修改不再"失忆”

3.4 Chains：把多个步骤串成流水线

3.5 RAG：用本地素材库增强脚本生成

3.6 Agents：让 LLM 自己决定下一步

四、Demo：一个可扩展的"AI 视频脚本生成器"

五、分布式场景下的运行方案

推荐架构

关键设计点

六、服务器异常恢复方案

1. 分级重试策略

2. 幂等性设计

3. 死信队列（DLQ）

4. 状态快照与断点续跑

七、如何实现高并发

1. 异步调用释放线程

2. 流式响应降低首字节延迟

3. 限流与背压

4. 缓存常用结果

5. 水平扩展与资源隔离

八、学完这门课的几点体会

九、参考资源