企业官网建设流程全解析

• 人工智能
• 大模型
• AI Agent
• 工作流自动化
• RAG

Pocket Flow 是一个仅 100 行的极简 LLM 框架，其官方德语版文档（cookbook/pocketflow-batch/translations/README_GERMAN.md）完整介绍了框架的设计理念与入门路径，而其中最典型的实战示例就是 Batch 批量翻译：一个TranslateTextNode即可把 Markdown 文档同时翻译成中文、西班牙语、日语、德语、俄语、葡萄牙语、法语、韩语 8 种语言并落盘保存。读完本文，你将掌握 Pocket Flow 的核心抽象（Graph）、BatchNode/BatchFlow的批量处理机制，并能够复现、扩展这套多语言文档翻译流水线。

Pocket Flow 是什么：一个 100 行的 LLM 框架

德语版 README 开篇即点明项目定位：Pocket Flow 是一个 100 行 的极简 LLM 框架（"100-zeiliges minimalistisches LLM-Framework"），并归纳了三个核心卖点：

• 轻量（Leichtgewichtig）：整个框架只有 100 行代码，无冗余依赖（Kein Ballast）、无供应商绑定（keine Anbieterbindung）。
• 表达力强（Ausdrucksstark）：框架虽小，却足以支撑主流 LLM 应用模式——Agent、Multi-Agent、Workflow、RAG 等。
• Agent 化编程（Agenten-basiertes Programmieren）：让 AI 编程助手（如 Cursor）基于这套框架"让 Agent 构建 Agent"，官方称其为 LLM 应用开发最快的范式。

安装方式

德语 README 提供了两种安装路径，二选一即可：

# 方式一：通过 pip 安装 pip install pocketflow # 方式二：直接把 pocketflow/__init__.py 复制进项目（仅 100 行）

两种方式的效果等价——框架的全部实现都收敛在 pocketflow/init.py 这一个文件里。仓库中的 setup.py 与 tests 目录则分别负责打包发布与功能验证。

与其他框架的对比：官方 README 中的数据

德语 README 附有一张对比表，列出 LangChain、CrewAI、SmolAgent、LangGraph、AutoGen 与 PocketFlow 在抽象层级、Wrapper 数量、代码行数与体积上的差异。该表为项目官方文档自述，此处仅如实转述关键结论：这些主流框架往往同时提供应用级与供应商级 Wrapper，代码量从 7K 到 405K 行不等、体积从 +26MB 到 +198MB；而 PocketFlow 只有 Graph 这一种抽象，不提供任何应用级或供应商级 Wrapper，代码 100 行、体积约 +56KB。这组数字的意图是强调"极简抽象 + 由你自由组合"的设计哲学，而非宣称某个方案绝对更优——取舍取决于具体场景。

核心抽象：一切 LLM 应用都是一个 Graph

德语 README 用一句话概括了框架的底层逻辑：那 100 行代码 抓住了 LLM 框架的核⼼抽象——Graph。从 Graph 出发，Agent、Workflow、RAG 等设计模式都只是图上的不同编排方式。

三个基类与三阶段生命周期

打开 pocketflow/init.py 可以看到整套抽象：

• BaseNode：所有节点的基类，持有params（参数）与successors（后继节点映射）两个属性，并提供prep/exec/post三个可覆写方法，以及>>（默认连线）与-（条件连线）两个运算符重载。
• Node：在BaseNode基础上增加max_retries（最大重试次数，默认 1）与wait（重试等待秒数，默认 0），exec抛异常时自动按max_retries重试，最终仍失败则交给exec_fallback处理。
• Flow：图的编排器。它持有start_node，在_orch中循环执行"取后继节点 →set_params→ 运行节点 → 用返回的 Action 查询下一跳"，直到没有后继节点为止。

每个节点的一次运行都遵循三阶段生命周期：

def _run(self, shared): p = self.prep(shared) # 1. 从共享存储中准备输入 e = self._exec(p) # 2. 执行核心逻辑（含重试） return self.post(shared, p, e) # 3. 处理结果并返回 Action

shared是一个跨节点共享的字典（shared store），节点之间通过它传递数据；params则通过set_params注入，用于区分节点在不同上下文中的行为。条件分支通过node - "action" >> next_node声明，Flow.get_next_node依据节点返回的 Action 字符串查找对应的后继。

Flow 与 Batch 的关系

当节点没有后继时，直接node.run(shared)即可；当存在多条连线时，必须用Flow驱动（源码中Node.run检测到存在 successors 会发出 "Node won't run successors. Use Flow." 警告）。这一设计保证了"单节点独立执行"与"整图编排执行"两种模式的清晰边界，也让批量处理有了两种完全不同的实现层次——这正是下文 Batch 翻译示例的关键。

Batch 教程：把 Markdown 文档翻译成 8 种语言

德语 README 的入门教程表中，Batch 被标记为初级（☆☆☆）示例："Ein Batch-Prozessor, der Markdown-Inhalte in mehrere Sprachen übersetzt"（一个将 Markdown 内容翻译成多种语言的批处理器）。项目英文原版 cookbook/pocketflow-batch/README.md 给出了完整功能描述：

• 并行地把 Markdown 内容翻译成多种语言；
• 把翻译结果保存到指定输出目录；
• 保持原始 Markdown 格式（链接、代码块）不被破坏。

快速开始三步

在cookbook/pocketflow-batch目录下依次执行：

# 1. 安装依赖（pocketflow、anthropic、pyyaml） pip install -r requirements.txt # 2. 配置 Anthropic API Key export ANTHROPIC_API_KEY="your-api-key-here" # 3. 运行翻译流程 python main.py

requirements.txt 只有三个依赖：pocketflow>=0.0.1、anthropic>=0.15.0、pyyaml>=6.0，与框架"无冗余依赖"的定位一致。

TranslateTextNode：整个批处理的唯一节点

main.py 中，整个批量翻译只定义了一个继承自BatchNode的节点TranslateTextNode，并通过三个方法完成全部工作：

class TranslateTextNode(BatchNode): def prep(self, shared): text = shared.get("text", "(No text provided)") languages = shared.get("languages", ["Chinese", "Spanish", "Japanese", "German", "Russian", "Portuguese", "French", "Korean"]) # 为每种语言构造一个 (text, lang) 批次 return [(text, lang) for lang in languages] def exec(self, data_tuple): text, language = data_tuple prompt = f""" Please translate the following markdown file into {language}. But keep the original markdown format, links and code blocks. Directly return the translated text, without any other text or comments. Original: {text} Translated:""" result = call_llm(prompt) print(f"Translated {language} text") return {"language": language, "translation": result} def post(self, shared, prep_res, exec_res_list): output_dir = shared.get("output_dir", "translations") os.makedirs(output_dir, exist_ok=True) for result in exec_res_list: language, translation = result["language"], result["translation"] filename = os.path.join(output_dir, f"README_{language.upper()}.md") with open(filename, "w", encoding="utf-8") as f: f.write(translation) print(f"Saved translation to {filename}")

这三个方法精确对应BatchNode的语义：

1. prep(shared)：从共享存储读取text与languages，返回一个可迭代对象——这里是 8 个(text, lang)元组组成的列表；
2. exec(item)：对每个元组调用一次 LLM。Prompt 中显式要求"保留原始 Markdown 格式、链接和代码块，直接返回译文"，这是保持文档结构完整的关键设计；
3. post(shared, prep_res, exec_res_list)：接收全部 8 个执行结果组成的列表exec_res_list，用os.makedirs(..., exist_ok=True)创建输出目录，再按README_{语言大写}.md命名规则逐文件写盘。

主程序从仓库根目录的 README.md 读取源文本，构造共享存储，并用两行代码完成整个图的装配与执行：

translate_node = TranslateTextNode(max_retries=3) flow = Flow(start=translate_node) flow.run(shared)

注意max_retries=3：对应 pocketflow/init.py 中Node._exec的重试循环——LLM 调用偶发失败时，同一翻译任务会自动重试最多 3 次，无需手写任何异常处理。

call_llm：极简的模型调用封装

utils.py 中的call_llm是唯一的 LLM 封装，固定使用claude-3-7-sonnet-20250219模型，并通过 Anthropic 的thinking参数开启扩展思考（budget_tokens=16000、max_tokens=20000）：

def call_llm(prompt): client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY", "your-api-key")) response = client.messages.create( model="claude-3-7-sonnet-20250219", max_tokens=20000, thinking={"type": "enabled", "budget_tokens": 16000}, messages=[{"role": "user", "content": prompt}] ) return response.content[1].text

返回值取response.content[1].text（索引 1 对应 thinking 模式下的正文内容）。main.py中还使用time.perf_counter()对 8 种语言的顺序翻译进行了耗时统计，方便与并行版本做基准对比。

运行输出示例

README.md记录了典型输出形态——每完成一种语言打印一行，最终汇总到translations目录：

Translated Chinese text Translated Spanish text ... Saved translation to translations/README_CHINESE.md Saved translation to translations/README_JAPANESE.md ... === Translation Complete === Translations saved to: translations ============================

仓库中 translations 目录下的 8 份README_*.md（含本文所依据的德语版 README_GERMAN.md）就是该流程的真实产物，验证了"输出文件按目标语言命名"的约定。

深入 BatchNode：一次 prep，多次 exec

要真正理解上面的翻译节点，需要回到框架源码与官方文档层面。项目文档 docs/core_abstraction/batch.md 对BatchNode的定义是：它继承Node，但改变了prep与exec的契约——

• prep(shared)返回一个可迭代对象（列表、生成器等）；
• exec(item)对该可迭代对象中的每个元素调用一次；
• post(shared, prep_res, exec_res_list)在所有元素处理完毕后，接收结果列表并返回 Action。

源码层面的实现只有一行，却点明了批处理的本质：

class BatchNode(Node): def _exec(self, items): return [super(BatchNode, self)._exec(i) for i in (items or [])]

即prep产出的列表被逐个送入exec，每个元素都独立享有Node的重试能力（max_retries/wait），最终汇总为结果列表交给post。这正是翻译示例中"一次 prep 产出 8 个任务、exec 并行处理、post 批量写盘"的底层机制。

docs/core_abstraction/batch.md同时强调：BatchNode与BatchFlow是两个不同层次的批处理。BatchFlow用于"用不同参数反复重放整个子 Flow"，它的prep返回的不是待处理数据，而是参数字典列表（如[{"filename": "a.txt"}, ...]），子 Flow 中的节点通过self.params读取这些参数，且子节点可以是普通Node而无需是BatchNode。测试用例 tests/test_batch_flow.py 中的NestedBatchFlow（外层按 group、内层按 item 双层迭代）则演示了 BatchFlow 嵌套合并参数的完整行为。翻译场景因为"每种语言只需一次 LLM 调用、无需子流程重放"，所以用BatchNode更直接；若任务升级为"每个文件都要跑一段多步翻译流程"，则应切换到BatchFlow。

从顺序到并行：AsyncParallelBatchNode

德语 README 的教程表中还列出了一个关联示例 Parallel："Eine parallele Ausführungsdemo, die 3-fache Beschleunigung zeigt"（展示 3 倍加速的并行执行演示）。该示例与批量翻译同源——cookbook/pocketflow-parallel-batch/main.py 用AsyncParallelBatchNode实现了同样的 8 语言翻译，只是把exec换成exec_async、把Flow换成AsyncFlow，并在post_async中优先用aiofiles异步写盘（缺失时回退同步写）。

框架源码为其提供了直接支撑——并行的关键在 pocketflow/init.py 的这一行：

class AsyncParallelBatchNode(AsyncNode, BatchNode): async def _exec(self, items): return await asyncio.gather(*(super(AsyncParallelBatchNode, self)._exec(i) for i in items))

asyncio.gather让所有批内任务的exec_async并发执行，因此"8 种语言翻译"在 I/O 密集的 LLM 调用场景下可从顺序版的逐次等待变为并发完成。两个示例在各自main.py中都打印了time.perf_counter()耗时，可以直接对照体验顺序（BatchNode）与并行（AsyncParallelBatchNode）两种模式的实际差异。此外框架还提供AsyncBatchNode（异步但顺序）与AsyncBatchFlow/AsyncParallelBatchFlow，分别对应异步世界里的顺序批处理与并行批处理，语义与同步版本一一对应。

教程生态与延伸阅读

德语 README 用一张难度表列出了完整的入门教程体系，本文只挑其中与本主题密切相关的列出（其余可浏览 cookbook 目录）：

若想从"用起来"走向"造出来"，建议按以下顺序深入仓库：

1. 通读核心实现 pocketflow/init.py（100 行，建议逐行阅读）；
2. 阅读核心抽象文档 docs/core_abstraction/batch.md、docs/core_abstraction/flow.md、docs/core_abstraction/node.md；
3. 运行测试验证行为：tests/test_batch_node.py（数组分块求和、map-reduce 流水线、空数组边界）与 tests/test_batch_flow.py（空输入、单元素、异常传播、嵌套 BatchFlow、自定义参数）。

另外，德语 README 提到 Pocket Flow 原生是 Python 实现，社区还维护了 TypeScript、Java、C++、Go 等语言移植版本（这些仓库不在当前仓库内，仅作了解）。

总结

从德语版 README 出发，这条技术路径非常清晰：Pocket Flow 用 100 行代码定义了"节点 + 图"的最小抽象，BatchNode在单节点内实现"一次 prep、逐项 exec、汇总 post"的批处理能力；cookbook/pocketflow-batch把这一能力落地为一个可运行的 8 语言 Markdown 翻译工具，AsyncParallelBatchNode又将其升级为并发执行。当你需要处理"大批量同构任务"（多文件翻译、多文档摘要、多轮评估）时，这条"定义 prep 产出任务列表 → exec 处理单个任务 → post 汇总写盘"的套路可以直接复用；而一旦任务内部还有多步流程，BatchFlow及其嵌套能力就是下一步的自然延伸。

• 人工智能
• 大模型
• AI Agent
• 工作流自动化
• RAG