企业官网建设流程全解析

1. 项目概述：一个真正“能干活”的桌面智能体，不是玩具

最近在某实验室做跨模型协同实验时，偶然看到 CoPaw 这个名字——不是某个大厂内部代号，也不是社区里小范围试用的 demo，而是直接把源码、文档、可执行包全量开源到 GitHub 的完整桌面 Agent 工具。我第一时间拉下代码、编译、跑通本地流程，连续三天把它嵌进我们正在做的三个不同方向的项目里：一个是某高校教育技术团队的课件自动生成系统，一个是某公司内部的多源工单摘要平台，还有一个是面向老年用户的语音指令转图文操作助手。结果出乎意料地稳：它不抢模型控制权，不强制绑定推理后端，也不要求你改写 prompt 模板；它只做一件事——把“用户说要干什么”和“当前有哪些模型可用”之间那层胶水，焊得严丝合缝。

CoPaw 的核心关键词就四个字：多模型自由接入。注意，是“自由”，不是“支持”。前者意味着你今天用 Qwen2-7B 做文本生成，明天换上 Phi-3-mini 处理轻量任务，后天再加一个本地部署的 Whisper.cpp 做语音转写，全程不用动 CoPaw 主体逻辑，只需在 config.yaml 里新增一段 5 行配置，重启一次进程。它不封装模型 API，不抽象推理接口，更不搞“统一模型网关”那种中间层——它本质上是一个运行时模型路由调度器 + 桌面级任务编排引擎。你给它一个自然语言指令（比如“把桌面上的会议录音转成带时间戳的文字，再提取三个关键结论”），它自动拆解为“语音转写 → 文本分段 → 关键点抽取”三步，分别调用对应模型，串起输入输出流，最后把结构化结果推到系统托盘弹窗或剪贴板。这不是 LLM 玩具，这是能嵌进日常办公流里的生产力插件。

适合谁参考？如果你正面临这些场景中的任意一种，CoPaw 就值得你花两小时搭起来试试：

• 你手头有多个开源模型（本地部署的、API 调用的、甚至还在训练中的），但每次换模型都要重写调用逻辑；
• 你想让非技术人员（比如行政、教务、客服）也能用自然语言触发复杂操作，而不是教他们点开哪个网页、填哪几个字段；
• 你在做模型能力对比实验，需要快速切换 backbone 并保持任务链路一致，避免因 SDK 差异引入噪声；
• 你厌倦了“一个模型一个前端”的碎片化体验，想要一个统一入口，背后却能随时替换技术栈。

它不解决“模型好不好”的问题，但彻底解决了“模型怎么用得顺”的问题。接下来我会从设计底层逻辑开始，一层层拆给你看：为什么它敢叫“自由接入”，这个“自由”到底自由在哪儿，又自由到什么程度。

2. 设计思路拆解：不做模型搬运工，只当任务翻译官

2.1 为什么放弃“统一模型抽象层”这条路？

市面上不少 Agent 框架一上来就定义 IModel 接口，要求所有模型实现 chat()、generate()、embed() 三个方法。听起来很干净，实操中全是坑。我拿自己踩过的三个典型例子说明：

• API 模型的 rate limit 和 token 计费逻辑差异巨大：OpenAI 的 gpt-4o 按输入+输出总 token 计费，而某国产大模型 API 却按“请求次数”阶梯计价，且对长上下文有硬性截断。如果强行塞进同一个 IModel 接口，要么在调用前预估 token（不准），要么在返回后解析 error message（不可靠），最终导致任务失败时根本不知道是模型崩了、配额超了，还是网络抖动。

• 本地模型的资源占用模式完全不同：Qwen2-7B 在 24G 显存卡上可以常驻加载，但 Phi-3-mini 启动只要 1.2G 显存，却对 CPU 内存带宽更敏感；而 Whisper.cpp 根本不占 GPU，纯 CPU 推理，启动延迟却高达 800ms。如果所有模型都要求“常驻服务”，Phi-3-mini 白白占着显存，Whisper.cpp 却每次调用都要冷启动，整体响应慢得无法接受。

• 输入输出格式存在语义鸿沟：同样是“总结文档”，Qwen2 需要传入 system prompt + user content，而某些专用摘要模型只接受 raw text + max_length 参数；语音转写模型输入是 wav 二进制流，输出却是 SRT 字符串。如果统一成“text in → text out”，语音模型就得额外包装一层 HTTP 服务来接收 base64，再转成 wav 文件——这不仅增加 IO 开销，还让错误定位变成噩梦（到底是网络传输丢了 bytes，还是模型解码出错？）

CoPaw 的解法很直接：不抽象模型，只抽象任务。它把“模型”降级为“可执行单元（Executor）”，每个 Executor 只需声明三件事：

1. 它能处理什么类型的任务（task_type），比如speech_to_text、text_summarize、image_caption；
2. 它接受什么格式的输入（input_schema），用 JSON Schema 描述，例如{ "audio_bytes": { "type": "string", "format": "base64" } }；
3. 它输出什么格式（output_schema），同样用 JSON Schema，例如{ "segments": { "type": "array", "items": { "type": "object", "properties": { "start": { "type": "number" }, "end": { "type": "number" }, "text": { "type": "string" } } } } }。

提示：这种设计让模型彻底“去人格化”。CoPaw 不关心你是 Qwen 还是 Llama，只关心你能不能在 5 秒内把 base64 音频转成带时间戳的文本数组。模型提供方只需按 schema 写好适配器，剩下的路由、超时、重试、日志，全部由 CoPaw 统一兜底。

2.2 “自由接入”的真实含义：运行时热插拔 + 配置即代码

很多人看到“多模型接入”第一反应是“配置文件里写几个 URL”。CoPaw 的自由远不止于此。它的接入方式分为三级，逐级提升灵活性：

• L1：HTTP API 模型直连
  最简单，适合已部署好的模型服务。在executors/目录下新建whisper-api.yaml：

  name: whisper-api-prod task_type: speech_to_text endpoint: "http://localhost:8000/transcribe" method: POST input_schema: audio_bytes: { type: string, format: base64 } output_schema: segments: { type: array, items: { type: object, properties: { start: { type: number }, end: { type: number }, text: { type: string } } } } timeout: 30

  CoPaw 启动时会自动发现该文件，构建一个 HTTP Client 实例，后续所有speech_to_text任务都会被路由至此。关键点在于：这个文件可以随时增删，无需重启 CoPaw 进程。你删掉它，相关任务立刻报“no executor found”；你新建一个whisper-api-staging.yaml指向测试环境，CoPaw 会在 2 秒内自动加载，新任务立即可选。

• L2：本地 CLI 模型封装
  适合没有 HTTP 服务、但有命令行工具的模型（如whisper.cpp、llama.cpp）。新建executors/whisper-cli.yaml：

  name: whisper-cli-local task_type: speech_to_text command: ["./whisper", "-f", "{input.audio_path}", "-otxt", "-osrt"] input_schema: audio_path: { type: string, description: "本地音频文件绝对路径" } output_schema: srt_content: { type: string } working_dir: "/path/to/whisper.cpp"

  CoPaw 会为每次任务创建临时目录，把输入数据（如 base64 解码后的 wav）写入该目录，然后执行 command，捕获 stdout/stderr。它甚至能处理 stdin 输入：把command改成["./llama", "-p", "{input.prompt}"]，CoPaw 会把 prompt 字符串通过管道传给 llama 进程。这种模式下，模型更新只需替换二进制文件，CoPaw 完全无感。

• L3：Python 函数级接入（最灵活）
  适合需要深度定制逻辑的场景，比如调用本地 PyTorch 模型、做预处理/后处理、或集成数据库查询。在executors/下建custom_qa.py：

  from copaw.executor import Executor import torch from transformers import AutoModelForQuestionAnswering, AutoTokenizer class LocalQaExecutor(Executor): def __init__(self, model_name="distilbert-base-cased-distilled-squad"): self.tokenizer = AutoTokenizer.from_pretrained(model_name) self.model = AutoModelForQuestionAnswering.from_pretrained(model_name) self.model.eval() def execute(self, inputs): # inputs 是 dict，符合 input_schema 定义 inputs_enc = self.tokenizer( inputs["question"], inputs["context"], return_tensors="pt", truncation=True, max_length=512 ) with torch.no_grad(): outputs = self.model(**inputs_enc) answer_start = torch.argmax(outputs.start_logits) answer_end = torch.argmax(outputs.end_logits) + 1 answer = self.tokenizer.convert_tokens_to_string( self.tokenizer.convert_ids_to_tokens(inputs_enc["input_ids"][0][answer_start:answer_end]) ) return {"answer": answer.strip()}

  对应的custom_qa.yaml只需声明：

  name: local-qa-distilbert task_type: question_answering module: "executors.custom_qa:LocalQaExecutor" input_schema: question: { type: string } context: { type: string } output_schema: answer: { type: string }

注意：L3 模式下，CoPaw 会动态 import 模块并实例化对象，整个 Python 环境完全隔离。你在一个 executor 里装了 torch 2.3，另一个 executor 用 torch 2.1，互不影响。这才是真正的“自由”——自由到你可以为每个模型配独立虚拟环境。

2.3 任务编排引擎：不是 workflow，而是“意图流图”

CoPaw 的任务调度不是传统 workflow 引擎（如 Airflow、Prefect）那种 DAG 图。它没有“节点”“边”“依赖关系”的概念，而是基于用户原始指令的语义解析 + 执行器能力匹配，实时生成执行路径。

举个真实案例：用户输入“把微信聊天记录截图里的文字提出来，再总结成三点”。CoPaw 的解析流程如下：

1. 意图识别（Intent Parsing）：
   使用内置轻量 NLP 模型（基于 Sentence-BERT 微调）将指令向量化，与预设的 200+ 任务意图向量比对，得到 top-3 匹配：

   • ocr_extract_text（相似度 0.92）
   • text_summarize（相似度 0.87）
   • image_to_text（相似度 0.76）

2. 能力匹配（Capability Matching）：
   查询当前已注册的 Executor 列表，筛选出能处理ocr_extract_text的（如paddleocr-local）、能处理text_summarize的（如qwen2-7b-local），并检查它们的 input_schema 是否兼容：

   • paddleocr-local要求image_bytes: base64，而用户上传的是 PNG 文件，CoPaw 自动完成 base64 编码；
   • qwen2-7b-local要求text: string，而 OCR 输出是{"text_lines": [...]}，CoPaw 调用内置json_to_text转换器，把数组拼成段落。

3. 路径生成（Path Generation）：
   不是固定模板，而是根据输入数据形态动态组装：

   User Input (PNG file) ↓ [auto encode to base64] paddleocr-local → output: {"text_lines": ["你好", "今天开会吗？"]} ↓ [json_to_text converter] qwen2-7b-local → input: "你好\n今天开会吗？" → output: "1. 问候语；2. 提出会议询问"

这个过程没有预定义 DAG，所有连接都是 runtime 生成的。你新增一个text_to_speechExecutor，下次用户说“把总结读给我听”，路径就自动延长一节。这才是面向真实用户需求的弹性。

3. 核心细节与实操要点：从零搭建一个可用环境

3.1 环境准备：最低硬件要求与依赖管理

CoPaw 本身是 Python 3.10+ 应用，核心依赖极轻（<5MB），但 Executor 的硬件需求取决于你接入的模型。以下是实测可行的最低配置方案：

实操心得：我建议新手从CLI Executor入手，因为零 Python 环境污染。先装好whisper.cpp和llama.cpp，验证它们能在终端跑通，再让 CoPaw 调用。这样即使 CoPaw 崩溃，你也能直接在命令行复现问题，排查路径极短。

安装步骤（macOS/Linux，Windows 类似）：

# 1. 创建独立虚拟环境（强烈建议！） python3.10 -m venv copaw-env source copaw-env/bin/activate # Windows: copaw-env\Scripts\activate # 2. 安装 CoPaw（PyPI 官方包） pip install copaw # 3. 初始化工作目录 copaw init ~/my-copaw-workspace cd ~/my-copaw-workspace # 4. 查看默认配置 cat config.yaml # 你会看到默认启用了内置的 demo executors，如 echo、sleep

此时运行copaw run，CoPaw 会启动 Web UI（默认 http://localhost:8080），但所有 Executor 都是 mock 的。下一步才是关键：接入真实模型。

3.2 接入第一个真实模型：Whisper.cpp 语音转写

这是最典型的 CLI Executor 场景。我们以 macOS 为例（Linux 同理，Windows 需用.exe路径）：

步骤 1：编译 whisper.cpp

git clone https://github.com/ggerganov/whisper.cpp cd whisper.cpp make clean && make -j4 # 编译主程序 ./models/download-ggml-model.sh tiny.en # 下载英文小模型（约 75MB）

步骤 2：编写 Executor 配置在executors/目录下新建whisper-tiny-en.yaml：

name: whisper-tiny-en-local task_type: speech_to_text command: [ "./main", "-m", "./models/ggml-tiny.en.bin", "-f", "{input.audio_path}", "-otxt", "-osrt", "-of", "{output_dir}/result" ] input_schema: audio_path: { type: string, description: "音频文件绝对路径，支持 wav/mp3" } output_schema: srt_content: { type: string, description: "SRT 字幕内容" } working_dir: "/path/to/whisper.cpp" # 替换为你实际的路径 timeout: 120

步骤 3：编写输出处理器（让 CoPaw 能读取 SRT）CLI 工具输出的是文件，但 CoPaw 需要返回 JSON。我们在executors/下建srt_reader.py：

import os from copaw.executor import Executor class SrtReader(Executor): def execute(self, inputs): # inputs 包含 output_dir，即 whisper.cpp 写入的目录 srt_path = os.path.join(inputs["output_dir"], "result.srt") if not os.path.exists(srt_path): raise FileNotFoundError(f"SRT file not found: {srt_path}") with open(srt_path, "r", encoding="utf-8") as f: content = f.read() return {"srt_content": content}

对应srt_reader.yaml：

name: srt-reader task_type: srt_parse module: "executors.srt_reader:SrtReader" input_schema: output_dir: { type: string } output_schema: srt_content: { type: string }

步骤 4：测试执行启动 CoPaw：copaw run --log-level debug
打开 Web UI，点击“New Task”，选择speech_to_text，上传一个 10 秒内的英文语音（如手机录的“Hello, this is a test”），提交。
你会在终端看到类似日志：

DEBUG:executor:Running command: ['./main', '-m', './models/ggml-tiny.en.bin', '-f', '/var/folders/.../test.wav', '-otxt', '-osrt', '-of', '/var/folders/.../result'] DEBUG:executor:Command finished in 3.2s, exit code: 0 DEBUG:executor:Reading SRT from /var/folders/.../result.srt

结果会显示在 UI 上，形如：

1 00:00:00,000 --> 00:00:01,200 Hello, this is a test

注意事项：

• working_dir必须是 whisper.cpp 的根目录，否则./main找不到模型；
• command中的{input.audio_path}是 CoPaw 自动替换的占位符，你不需要手动拼接路径；
• 如果遇到Permission denied，给main加执行权限：chmod +x main；
• 中文语音请下载ggml-base.zh.bin并修改配置，tiny 模型中文效果较差，base 模型更稳。

3.3 接入第二个模型：Qwen2-7B 本地大模型

这是 Python Executor 的典型用法。我们用transformers+accelerate实现零代码改动接入。

步骤 1：安装模型依赖

pip install transformers accelerate torch sentence-transformers

步骤 2：下载并量化模型（节省显存）

# 使用 huggingface-hub 下载（需登录） huggingface-cli login # 下载 Qwen2-7B-Instruct（约 4.5GB） git lfs install git clone https://huggingface.co/Qwen/Qwen2-7B-Instruct # 量化到 INT4（需 bitsandbytes） python -c " from transformers import AutoModelForCausalLM, BitsAndBytesConfig import torch bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type='nf4') model = AutoModelForCausalLM.from_pretrained('Qwen/Qwen2-7B-Instruct', quantization_config=bnb_config, device_map='auto') model.save_pretrained('./qwen2-7b-int4') "

步骤 3：编写 Executorexecutors/qwen2_local.py：

from copaw.executor import Executor from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline import torch class Qwen2LocalExecutor(Executor): def __init__(self, model_path="./qwen2-7b-int4"): self.tokenizer = AutoTokenizer.from_pretrained(model_path) self.model = AutoModelForCausalLM.from_pretrained( model_path, torch_dtype=torch.float16, device_map="auto" ) self.pipe = pipeline( "text-generation", model=self.model, tokenizer=self.tokenizer, max_new_tokens=512, do_sample=True, temperature=0.7 ) def execute(self, inputs): # inputs 是 dict，包含 'prompt' 字符串 messages = [ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": inputs["prompt"]} ] prompt = self.tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True ) outputs = self.pipe(prompt) response = outputs[0]["generated_text"][len(prompt):].strip() return {"response": response}

executors/qwen2_local.yaml：

name: qwen2-7b-int4-local task_type: text_generate module: "executors.qwen2_local:Qwen2LocalExecutor" input_schema: prompt: { type: string, description: "用户输入的提示词" } output_schema: response: { type: string, description: "模型生成的回复" }

步骤 4：组合任务链现在你有两个 Executor：whisper-tiny-en-local（语音转文本）和qwen2-7b-int4-local（文本生成）。在 Web UI 中，你可以：

• 先提交语音，得到srt_content；
• 复制srt_content，新建一个text_generate任务，把字幕内容粘贴进prompt；
  或者，用 CoPaw 的Task Chain功能（高级版）一键串联：

# chains/meeting-summary.yaml name: meeting-summary-chain steps: - task_type: speech_to_text executor: whisper-tiny-en-local input: { audio_path: "{input.audio_file}" } - task_type: text_generate executor: qwen2-7b-int4-local input: { prompt: "请将以下会议记录总结为三点：{prev_step.output.srt_content}" } output: { summary: "{prev_step.output.response}" }

上传音频，CoPaw 自动执行两步，返回三点总结。

实操心得：

• 量化模型首次加载较慢（约 90 秒），但之后所有请求都在内存中，响应 < 2 秒；
• 如果显存不足，把device_map="auto"改成device_map={"": "cpu"}，用 CPU 推理（速度慢 5 倍，但能跑）；
• apply_chat_template是 Qwen2 必需的，其他模型（如 Llama3）需用对应 template，CoPaw 不干涉，由 Executor 自行处理。

3.4 桌面集成：不只是 Web UI，更是系统级插件

CoPaw 的一大亮点是原生桌面支持。它不是 Electron 套壳，而是用 Tauri（Rust + WebView2）构建，体积仅 45MB，启动 < 1 秒。

启用桌面模式：

copaw run --desktop # 启动原生桌面应用

你会看到一个极简窗口，左上角是任务输入框，右下角是系统托盘图标。关键功能：

• 全局快捷键：默认Cmd/Ctrl + Space呼出浮动输入框，不打断当前工作流；
• 剪贴板监听：当检测到图片/音频文件被复制，自动弹出“OCR”或“语音转写”按钮；
• 文件拖拽：直接把 MP3/WAV/PNG 拖进窗口，自动识别类型并推荐 Executor；
• 结果推送：任务完成后，结果可一键复制到剪贴板、保存为文件、或发送到指定 App（如 Obsidian、Notion 的 API 端点）。

自定义快捷键与行为：
编辑config.yaml中的desktop区块：

desktop: hotkey: "Ctrl+Alt+T" # 修改全局呼出键 clipboard_monitor: true auto_open_result: false # 完成后不自动弹窗，只通知 result_actions: - name: "Copy to Clipboard" shortcut: "Cmd+C" action: "copy" - name: "Save as Markdown" shortcut: "Cmd+S" action: "save" format: "markdown"

注意：桌面模式下，所有 Executor 仍运行在后台 Python 进程中，Tauri 只负责 UI 和 IPC 通信。这意味着你可以在桌面 UI 中调用 GPU 模型，而 UI 本身不卡顿——这是 Electron 无法做到的。

4. 实操过程详解：从单任务到多模型协同工作流

4.1 单任务调试：如何读懂 CoPaw 的日志与错误

CoPaw 的日志设计极度面向调试。当你执行一个任务失败时，不要慌，按以下顺序查：

第一步：看 Web UI 或桌面端的红色错误框
它会显示最简信息，如：
Failed to execute task: No executor found for task_type 'speech_to_text'
→ 说明你没配置任何speech_to_textExecutor，检查executors/目录下是否有对应 YAML 文件。

第二步：查终端日志（关键！）
启动时加--log-level debug，失败任务会输出完整 trace：

ERROR:task:Task 12345 failed at step 1 DEBUG:executor:Trying to match task_type 'speech_to_text' with 3 executors... DEBUG:executor:whisper-tiny-en-local: input_schema mismatch - missing 'audio_path' DEBUG:executor:paddleocr-local: task_type mismatch - 'ocr_extract_text' != 'speech_to_text' DEBUG:executor:echo-demo: task_type mismatch - 'echo' != 'speech_to_text' ERROR:task:No matching executor found

这里清楚告诉你：whisper-tiny-en-local的 input_schema 要求audio_path，但你传入的是audio_bytes（base64 字符串）。解决方案：在 YAML 中把input_schema改成：

input_schema: audio_bytes: { type: string, format: base64 }

然后在command中用base64命令解码：

command: [ "bash", "-c", "echo '{input.audio_bytes}' | base64 -d > /tmp/audio.wav && ./main -m ./models/ggml-tiny.en.bin -f /tmp/audio.wav -otxt -osrt -of {output_dir}/result" ]

第三步：用copaw debug命令单步执行
这是最强大的调试工具。假设你有一个任务 ID12345，运行：

copaw debug 12345 --step 0 # 查看原始输入 copaw debug 12345 --step 1 # 查看 Executor 1 的输入（已转换后） copaw debug 12345 --step 2 # 查看 Executor 1 的输出

它会打印出每一步的完整 JSON 数据，包括所有中间变量。你甚至可以用--inject注入假数据测试：

copaw debug 12345 --step 1 --inject '{"audio_path":"/tmp/test.wav"}'

实操心得：我养成了一个习惯——每次新增 Executor，必先用copaw debug测试其输入输出 schema 是否与文档一致。很多问题（如字段名大小写、嵌套层级）都在这一步暴露，比上线后抓瞎强十倍。

4.2 多模型协同：构建一个“会议纪要自动化流水线”

这才是 CoPaw 的价值所在。我们用前面接入的两个模型，加上一个免费的 OCR 工具，打造端到端流水线。

需求：
用户拍一张会议白板照片（PNG），CoPaw 自动：

1. OCR 提取文字；
2. 用 Qwen2 总结为三点；
3. 用 Whisper 把会议录音（MP3）转字幕；
4. 把 OCR 文字 + 字幕合并，让 Qwen2 生成完整纪要。

步骤 1：接入 PaddleOCR（CLI 模式）
下载 PaddleOCR inference 模型（约 150MB）：

wget https://paddleocr.bj.bcebos.com/PP-OCRv4/english/en_PP-OCRv4_rec_infer.tar tar -xf en_PP-OCRv4_rec_infer.tar

executors/paddleocr.yaml：

name: paddleocr-en-rec task_type: ocr_extract_text command: [ "python3", "./tools/infer/predict_system.py", "--image_dir", "{input.image_path}", "--rec_model_dir", "./en_PP-OCRv4_rec_infer/", "--use_gpu", "False" ] input_schema: image_path: { type: string } output_schema: text_lines: { type: array, items: { type: string } } working_dir: "/path/to/PaddleOCR"

步骤 2：编写合并与生成 Chain
chains/meeting-minutes.yaml：

name: full-meeting-minutes steps: # Step 1: OCR 白板 - task_type: ocr_extract_text executor: paddleocr-en-rec input: { image_path: "{input.whiteboard_path}" } # Step 2: 语音转写 - task_type: speech_to_text executor: whisper-tiny-en-local input: { audio_path: "{input.audio_path}" } # Step 3: 合并并生成纪要 - task_type: text_generate executor: qwen2-7b-int4-local input: { prompt: | 你是一名专业会议秘书。请根据以下两部分材料，生成一份正式会议纪要： 【白板内容】 {prev_step_1.output.text_lines | join('\n')} 【会议录音】 {prev_step_2.output.srt_content} 要求：1. 标题为'会议纪要'；2. 分'时间地点'、'参会人员'、'讨论要点'、'待办事项'四部分；3. 语言简洁正式。 } output: { minutes: "{prev_step_3.output.response}" }

步骤 3：桌面端一键触发
在桌面应用中，拖入白板 PNG 和会议 MP3，选择full-meeting-minutesChain，点击运行。
CoPaw 自动：

• 启动 PaddleOCR（CPU，约 8 秒）；
• 启动 Whisper.cpp（CPU，约 15 秒）；
• 启动 Qwen2（GPU，约 3 秒）；
• 最终返回 Markdown 格式纪要，可直接复制进 Word。

注意事项：

• Chain 中prev_step_1指向前一步，prev_step_2指向前两步，序号从 1 开始；
• join('\n')是 Jinja2 模板语法，CoPaw 内置支持，把数组转成换行字符串；
• 所有步骤并行启动（除非显式声明depends_on），但输出按顺序注入，确保数据流正确。

4.3 性能调优：让多模型流水线不卡顿

多模型并发时，最常见问题是 GPU 显存爆满或 CPU 过载。CoPaw 提供三层次调控：

层次 1：Executor 级并发控制
在 Executor YAML 中设置：

concurrency: 1 # 同一 Executor 最多 1 个实例在跑 max_queue_size: 5 # 等待队列最多 5 个任务

例如 Whisper.cpp 是 CPU 密集型，设concurrency: 2即可压满双核；Qwen2 是 GPU 密集型，必须设concurrency: 1，否则 OOM。

层次 2：全局资源限制
config.yaml中：

resources: gpu_memory_limit_mb: 12000 # 限制 CoPaw 进程可见的 GPU 显存（需 nvidia-smi 支持） cpu_cores: 4 # 限制最大 CPU 核数 memory_mb: 8192 # 限制最大内存

层次 3：任务优先级与超时
在提交任务时指定：

copaw run --task-type text_generate --priority high --timeout 60 ...

高优先级任务会跳过队列，直接抢占资源；超时任务会被强制 kill，释放资源。

实测数据：在我的 M2 Ultra（64GB RAM + 64 核 CPU）上，同时跑：

• 1 个 Whisper.cpp（CPU）
• 1 个 Qwen2-7B（GPU，12GB 显存）
• 1 个 PaddleOCR（CPU）
• 2 个echomock 任务
  整体响应稳定，GPU 利用率 85%，CPU 平均负载 3.2/64，内存占用 4.1GB。
  关键技巧：把 CPU 型 Executor（Whisper、OCR）的working_dir设为/tmp，避免 SSD 频繁读写拖慢 IO。

5