《林一的 Cloudflare 通关记》第 6 篇-给网站注入"灵魂"——Workers AI 让网站变聪明

2026年6月26日 · 阅读需 20 分钟

《林一的 Cloudflare 通关记》第 6 篇

周三下午，林一正在调试 Workers API 路由，产品经理小王推门而入，身后跟着实习生小李。

"林一，给你介绍一下，小李以后帮你一起做星火AI。"小王指了指身后，"对了，我刚才给小李演示了一下网站，前端挺好看，API 也能调通，但是——"

故事引入

"但是什么？"

"但是这个网站叫'星火AI'，AI 在哪儿呢？用户打开聊天框，发一句'你好'，你返回一句'收到消息：你好'。这是 AI？"小王掏出手机翻了翻竞品列表，"人家某某AI、某某清言，都能对话、能写文章、能画图。你呢？"

林一一下就慌了。他当然知道要接 AI，但他的认知里，AI 意味着大模型，大模型意味着 GPU 服务器，GPU 服务器意味着——钱。

"张哥，"林一转向老张，"搞 AI 是不是得买 GPU？我看了下，一张 A100 显卡十几万，租云上的 GPU 实例一个月也要好几千……"

老张正在给保温杯续水，头也没抬："谁让你买 GPU 了？谁让你租 GPU 实例了？"

"那大模型跑在哪儿？总不能跑在我的 Mac Book 上吧？"

"跑在 Cloudflare 的边缘节点上。"老张盖上杯盖，转过身来，"Cloudflare 有个服务叫 Workers AI，在全球的边缘节点上部署了 GPU，预装了几十种开源大模型。你写一行代码就能调用，不用买显卡，不用装 CUDA，不用部署模型，不花一分钱。"

"一行代码？"林一和小王异口同声。

"一行代码。"老张竖起一根手指。

技术讲解

大语言模型（LLM）：简单回顾

"在讲 Workers AI 之前，先简单过一下大语言模型的基础概念。"老张在白板上写了几个关键词。

大语言模型（Large Language Model，LLM）是一种基于 Transformer 架构的 AI 模型，通过海量文本数据训练而成。你给它一段文字（prompt），它就能预测并生成接下来的文字。就像手机输入法的"联想输入"超级强化版——手机只能预测下一个词，LLM 可以预测接下来几百几千词，而且内容连贯、逻辑自洽。

"这个大家都比较熟了，"老张快速带过，"ChatGPT、文心一言、通义千问、DeepSeek，都是 LLM。核心能力就是：理解自然语言，生成自然语言。能聊天、能写文章、能写代码、能做翻译。"

"LLM 的两个关键指标：参数量（决定模型有多"聪明"）和上下文窗口（决定模型能"记住"多长的对话）。参数量越大越聪明但越慢，上下文窗口越大能处理的内容越长。"

"好了，基础就到这里。重点讲讲——为什么传统方式跑 LLM 这么贵。"

模型推理的传统方式：为什么贵？

"要让一个大模型跑起来，不是随便找台电脑就行的。"老张画了一张图：

传统 LLM 部署架构：

用户请求 → 负载均衡 → GPU 服务器集群
                           ├── GPU 0: 模型加载（占用显存）
                           ├── GPU 1: 模型加载（占用显存）
                           └── GPU 2: 模型加载（占用显存）
                                    ↓
                              推理计算（生成文本）
                                    ↓
                              返回结果给用户

传统LLM部署的四大痛点

"传统方式有四大痛点："

痛点一：GPU 硬件极其昂贵。

一张 NVIDIA A100 显卡售价约 10-15 万元人民币，H100 更是 30 万起步。一个能跑 70B 参数模型的推理服务器，通常需要 2-4 张 A100。光硬件成本就是几十万。

"打个比方，"老张说，"传统 GPU 服务器就像你自己买一辆公交车——只是为了每天上下班代步。车贵、油贵、停车费贵，但大部分时间车都停在车库里吃灰。"

痛点二：模型部署门槛高。

拿到一个开源模型（比如 Llama），你不能直接跑。你需要：

安装 CUDA 驱动、cuDNN、PyTorch
下载模型权重文件（动辄几十 GB）
编写推理脚本，处理 tokenization、模型加载、KV Cache 等
配置 HTTP 服务，处理并发请求
实现排队机制，避免 GPU 显存溢出

"这就像买了公交车之后，你还得自己考驾照、自己修发动机、自己规划线路。"老张说。

痛点三：资源利用率低。

GPU 服务器最大的问题是：没人请求的时候，GPU 也在空转，电费照烧。 流量高峰时不够用，用户排队等待；流量低谷时 GPU 闲置，成本照付。平均利用率往往不到 30%。

痛点四：扩缩容慢。

流量突增时，加一台 GPU 服务器需要：启动实例 → 下载镜像 → 加载模型 → 就绪。整个过程可能要几分钟甚至十几分钟。而用户的请求可等不了那么久。

"所以，"老张总结道，"传统方式跑 LLM = 高昂的硬件成本 + 复杂的运维 + 低下的资源利用率 + 缓慢的扩容。这就是为什么以前只有大公司才玩得起 AI。"

"那 Cloudflare 是怎么解决的？"林一追问。

边缘 AI 推理：Cloudflare 的解法

"答案就是——边缘 AI 推理。"老张在白板上写下这五个字，画了一张对比图：

传统 AI 推理：
用户（北京）→ 请求 → 中央 GPU 机房（美国）→ 推理 → 返回
                     往返延迟：200-400ms

Cloudflare 边缘 AI 推理：
用户（北京）→ 请求 → 北京边缘节点（自带 GPU）→ 推理 → 返回
                     往返延迟：< 50ms

边缘AI推理对比

"Cloudflare 在全球三百多个城市的边缘节点中，选择了部分节点部署了 GPU 服务器。这些 GPU 上预装了各种开源大模型。当你的 Worker 调用 Workers AI 时，请求会被路由到离用户最近的有 GPU 的节点，在那里完成推理，再把结果返回给用户。"

"跟传统方式相比，边缘 AI 推理有三大优势："

优势一：零运维。

你不需要买 GPU，不需要装 CUDA，不需要下载模型权重，不需要写推理脚本。Cloudflare 把这些全做了。你在 wrangler.jsonc 里加一行配置，代码里写 env.AI.run()，模型就能跑。

"就像共享单车，"老张比喻道，"你不需要买车、不需要修车、不需要找停车场。扫个码就能骑，骑完就走。"

优势二：低延迟。

传统方式请求要跨越大半个地球到集中式 GPU 机房，延迟动辄几百毫秒。Cloudflare 的 GPU 分布在全球各地，请求自动路由到最近的节点，延迟可以控制在几十毫秒以内。对于 AI 对话这种逐字生成的场景，低延迟意味着更好的用户体验。

优势三：按需付费（而且有免费额度）。

传统方式不管有没有请求，GPU 都在烧钱。Workers AI 采用按用量计费的模式，用了才付费，不用不花钱。而且每天有 10,000 Neurons 的免费额度（Neuron 是 Cloudflare 的 AI 计算单位，后面详细讲）。

"国内也有类似的服务，"老张补充道，"比如阿里云的函数计算 GPU、腾讯云的弹性推理，但它们大多按实例时长收费，价格比 Workers AI 贵不少。Cloudflare 的优势在于它跟 Workers 深度集成——AI 调用就是一个函数调用，无缝衔接。"

Workers AI 模型列表：都有什么模型可用？

"说了这么多理论，来看看实际有哪些模型可以用。"老张打开 Cloudflare 官方文档页面。

Workers AI 目前提供 70 多个开源模型，覆盖了 AI 应用的主要场景。老张按类别整理了最常用的模型：

文本生成（Text Generation）

这是最核心的类别，也就是通常说的"大语言模型"。用于对话、问答、写文章、写代码、翻译等文本任务。

模型	参数量	特点	适用场景
`llama-3.2-1b-instruct`	1B	最轻量，速度极快	简单问答、分类、轻量任务
`llama-3.2-3b-instruct`	3B	轻量但更聪明	摘要、多语言对话
`llama-3.1-8b-instruct-fp8-fast`	8B	速度与质量平衡	通用对话首选
`llama-3.3-70b-instruct-fp8-fast`	70B	推理能力强	复杂推理、高质量写作
`qwen3-30b-a3b-fp8`	30B (MoE)	通义千问系列，中文优秀	中文场景
`glm-4.7-flash`	-	智谱 GLM，100+语言	多语言、Function Calling
`gpt-oss-120b`	120B	OpenAI 开源模型	高质量推理、Agent
`gpt-oss-20b`	20B	OpenAI 开源轻量版	低延迟推理
`deepseek-r1-distill-qwen-32b`	32B	DeepSeek 推理模型	数学、逻辑推理
`qwen2.5-coder-32b-instruct`	32B	代码专用模型	代码生成、补全
`llama-4-scout-17b-16e-instruct`	17B (MoE)	原生多模态	文本+图像理解

"注意，部分老模型如 llama-3.1-8b-instruct、llama-3-8b-instruct 等已标记为已弃用（Deprecated），新项目建议用带 -fp8-fast 或 -fast 后缀的版本，速度更快、成本更低。"

图片生成（Text-to-Image）

模型	特点	适用场景
`flux-1-schnell`	速度快，质量不错	通用图片生成首选
`flux-2-klein-4b`	Flux 2 轻量版，支持编辑	图片生成+编辑
`flux-2-klein-9b`	Flux 2 旗舰版	高质量图片
`stable-diffusion-xl-lightning`	字节跳动优化版，几步出图	快速生成
`stable-diffusion-xl-base-1.0`	经典 SDXL 模型	通用图片生成

语音识别（Speech-to-Text）

模型	特点	适用场景
`whisper`	OpenAI 开源模型，多语言	语音转文字首选
`whisper-large-v3-turbo`	Whisper 加速版	实时语音识别
`nova-3`	Deepgram 出品	高精度英语识别

文本转语音（Text-to-Speech）

模型	特点
`melotts`	MyShell 出品，多语言 TTS
`aura-2-en`	Deepgram 出品，英语 TTS
`aura-1`	Deepgram 上一代 TTS

文本嵌入（Text Embeddings）

模型	特点
`bge-m3`	多语言嵌入模型，推荐用于 RAG
`bge-small-en-v1.5`	轻量英文嵌入
`bge-large-en-v1.5`	高质量英文嵌入
`qwen3-embedding-0.6b`	通义千问嵌入模型

其他能力

图像理解（Image-to-Text）：moondream3.1-9B-A2B、llava-1.5-7b-hf
翻译：m2m100-1.2b（多语言互译）
图像分类：resnet-50
对象检测：detr-resnet-50
内容安全：llama-guard-3-8b

"模型库还在持续更新，"老张说，"Cloudflare 不断加入新的开源模型。你可以在官方文档 developers.cloudflare.com/workers-ai/models/ 查看最新列表。"

不同场景的模型选择

"这么多模型，实际开发时怎么选？"小王问了一个实际问题。

老张给出了选型建议：

场景	推荐模型	理由
日常对话/问答	`llama-3.1-8b-instruct-fp8-fast`	速度和质量的最佳平衡
简单分类/提取	`llama-3.2-1b-instruct`	最轻量，速度快，成本低
复杂推理/长文写作	`llama-3.3-70b-instruct-fp8-fast`	70B 参数，推理能力强
中文对话	`qwen3-30b-a3b-fp8` 或 `glm-4.7-flash`	中文训练充分
代码生成	`qwen2.5-coder-32b-instruct`	代码专用模型
图片生成	`flux-1-schnell`	速度快，免费额度友好
语音转文字	`whisper`	多语言，精度高
RAG/语义搜索	`bge-m3` + LLM	多语言嵌入，配合向量数据库
数学/逻辑推理	`deepseek-r1-distill-qwen-32b`	专门的推理模型

"选模型的核心原则是：够用就好，不要杀鸡用牛刀。 1B 模型能做的事就别用 70B，省下的 Neurons 可以服务更多用户。"

AI Gateway：给你的 AI 加个"中间人"

"还有一个要提的功能——AI Gateway。"老张在白板上画了个简图：

用户 → Worker → AI Gateway → Workers AI / OpenAI / Anthropic...
                 ├── 缓存：相同请求直接返回缓存结果
                 ├── 限流：防止滥用
                 ├── 日志：记录每次请求
                 ├── 监控：请求量、延迟、Token 消耗
                 └── 降级：主模型挂了自动切换备用模型

AI Gateway 架构

"AI Gateway 是 Cloudflare 提供的 AI 流量管理服务。它不只是一个模型代理，它还能做缓存、限流、监控、重试和模型降级。"

"比如用户问了一个常见问题'什么是 Cloudflare'，第一次请求走到模型生成回答，AI Gateway 把结果缓存起来。下次再有人问同样的问题，直接从缓存返回，不用再消耗 GPU 资源——既快又省钱。"

"AI Gateway 不只能代理 Workers AI，还支持 OpenAI、Anthropic、Google Gemini 等第三方 AI 服务。你可以用它统一管理所有的 AI 调用。"

"这个功能我们后面用到再细讲，现在先聚焦在 Workers AI 的基本使用上。"

实操指导

第一步：给 Worker 绑定 AI

老张打开上次创建的 spark-api 项目，修改 wrangler.jsonc：

{
  "name": "spark-api",
  "main": "src/index.js",
  "compatibility_date": "2025-01-01",
  "ai": {
    "binding": "AI"
  }
}

"就加了最后那三行。ai 是绑定类型，binding 是你在代码里访问它的变量名。加了这个配置后，你的 Worker 代码里就能通过 env.AI 调用 AI 模型了。"

"这就是你说的一行代码？"林一挑眉。

"配置不算代码。真正的调用才是一行。看好了。"

第二步：实现 AI 对话接口

老张修改 src/index.js，在上次的代码基础上添加 /api/chat 路由：

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
  "Access-Control-Allow-Headers": "Content-Type",
};

export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);
    const path = url.pathname;
    const method = request.method;

    // CORS 预检
    if (method === "OPTIONS") {
      return new Response(null, { headers: corsHeaders });
    }

    // AI 对话接口
    if (path === "/api/chat" && method === "POST") {
      try {
        const { message, history = [] } = await request.json();

        // 构建对话消息列表
        const messages = [
          {
            role: "system",
            content: "你是星火AI助手，友好、专业、简洁地回答用户问题。",
          },
          ...history, // 历史对话记录
          { role: "user", content: message },
        ];

        // 调用 Workers AI —— 核心就这一行
        const response = await env.AI.run(
          "@cf/meta/llama-3.1-8b-instruct-fp8-fast",
          { messages }
        );

        return new Response(
          JSON.stringify({
            reply: response.response,
            model: "llama-3.1-8b-instruct-fp8-fast",
          }),
          {
            headers: {
              "Content-Type": "application/json",
              ...corsHeaders,
            },
          }
        );
      } catch (error) {
        return new Response(
          JSON.stringify({ error: "AI 处理失败", detail: error.message }),
          {
            status: 500,
            headers: { "Content-Type": "application/json", ...corsHeaders },
          }
        );
      }
    }

    // 健康检查
    if (path === "/api/health") {
      return new Response(
        JSON.stringify({ status: "ok", ai: !!env.AI }),
        {
          headers: { "Content-Type": "application/json", ...corsHeaders },
        }
      );
    }

    return new Response(
      JSON.stringify({ error: "Not Found" }),
      {
        status: 404,
        headers: { "Content-Type": "application/json", ...corsHeaders },
      }
    );
  },
};

"核心就是这一行："老张用笔圈出来：

const response = await env.AI.run(
  "@cf/meta/llama-3.1-8b-instruct-fp8-fast",
  { messages }
);

"env.AI.run() 接收两个参数：第一个是模型 ID（注意要带 @cf/ 前缀），第二个是配置对象。对于文本生成模型，传入 messages 数组，格式跟 OpenAI 的 Chat API 一样——role 为 system/user/assistant，content 为消息内容。"

"返回的 response 对象里，response.response 就是模型生成的文本。"

"就这么简单？"林一难以置信。

"就这么简单。不用装 PyTorch，不用下模型文件，不用配 GPU。一行 env.AI.run()，模型就跑起来了。"

第三步：流式输出——让 AI 像"打字"一样回复

"不过有个问题，"老张说，"上面的代码是等模型把整段话生成完了才返回。如果回复很长，用户要盯着空白页面等好几秒。更好的体验是流式输出——模型一边生成，一边把文字推给前端，就像 ChatGPT 那样逐字显示。"

"实现起来很简单，加一个 stream: true 参数："

// /api/chat/stream - 流式对话接口
if (path === "/api/chat/stream" && method === "POST") {
  try {
    const { message, history = [] } = await request.json();

    const messages = [
      {
        role: "system",
        content: "你是星火AI助手，友好、专业、简洁地回答用户问题。",
      },
      ...history,
      { role: "user", content: message },
    ];

    // stream: true 开启流式输出
    const stream = await env.AI.run(
      "@cf/meta/llama-3.1-8b-instruct-fp8-fast",
      {
        messages,
        stream: true,
      }
    );

    // 直接将流返回给前端
    return new Response(stream, {
      headers: {
        "Content-Type": "text/event-stream",
        "Cache-Control": "no-cache",
        Connection: "keep-alive",
        ...corsHeaders,
      },
    });
  } catch (error) {
    return new Response(
      JSON.stringify({ error: "AI 处理失败", detail: error.message }),
      {
        status: 500,
        headers: { "Content-Type": "application/json", ...corsHeaders },
      }
    );
  }
}

流式输出对比

"加了 stream: true 后，env.AI.run() 返回的不再是一个对象，而是一个 ReadableStream。这个流会持续输出模型生成的文本片段，前端用 EventSource 或 fetch + ReadableStream 接收即可。"

"前端怎么接收呢？"

"前端代码大概长这样："

// 前端接收流式响应
const response = await fetch("/api/chat/stream", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ message: "你好，介绍一下你自己" }),
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  // 逐块追加到页面上
  document.getElementById("chat-output").textContent += decoder.decode(value);
}

"这样用户就能看到文字一个字一个字地蹦出来，体验立刻提升了一个档次。"

第四步：图片生成接口

"星火AI 不能只会聊天，还得会画图。"小王插话。

"安排。"老张又加了一个路由：

// /api/image/generate - AI 图片生成接口
if (path === "/api/image/generate" && method === "POST") {
  try {
    const { prompt } = await request.json();

    // 调用 Flux 模型生成图片
    const imageResponse = await env.AI.run(
      "@cf/black-forest-labs/flux-1-schnell",
      { prompt }
    );

    // 返回 PNG 图片
    return new Response(imageResponse, {
      headers: {
        "Content-Type": "image/png",
        ...corsHeaders,
      },
    });
  } catch (error) {
    return new Response(
      JSON.stringify({ error: "图片生成失败", detail: error.message }),
      {
        status: 500,
        headers: { "Content-Type": "application/json", ...corsHeaders },
      }
    );
  }
}

"图片生成的调用方式跟文本一样——env.AI.run()，只是模型换成 flux-1-schnell，参数用 prompt 而不是 messages。返回的直接是二进制图片数据，设成 image/png 返回即可。"

"前端怎么用？"

// 前端调用图片生成
const response = await fetch("/api/image/generate", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ prompt: "一只坐在云朵上的猫，水彩画风格" }),
});

const blob = await response.blob();
const url = URL.createObjectURL(blob);
document.getElementById("ai-image").src = url;

第五步：本地测试与部署

# 本地开发测试（注意：Workers AI 本地开发也会消耗线上额度）
npx wrangler dev

# 测试对话接口
curl -X POST http://localhost:8787/api/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "你好，介绍一下你自己"}'

# 测试图片生成
curl -X POST http://localhost:8787/api/image/generate \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a cat sitting on a cloud, watercolor"}' \
  --output cat.png

# 部署上线
npx wrangler deploy

"注意一点，"老张特意强调，"wrangler dev 本地开发时调用 Workers AI 会连接到 Cloudflare 的线上 GPU，会消耗你的 Neurons 额度。不像 Workers 的普通请求本地就能跑，AI 推理必须有真实的 GPU 计算。所以本地测试时别写死循环刷请求。"

免费额度与限制：能省多少钱？

"最后说最关键的问题——到底要花多少钱？"小王掏出计算器。

老张列出 Cloudflare 官方的定价规则：

项目	免费计划	付费计划（Workers Paid $5/月）
每日免费 Neurons	10,000	10,000
超出部分	不可用，需升级	$0.011 / 1,000 Neurons
重置时间	每天 UTC 00:00	每天 UTC 00:00

"Neuron 是 Cloudflare 的 AI 计算单位，代表 GPU 执行一次推理所需的计算量。不同模型的 Neuron 消耗差异很大："

模型	输入消耗	输出消耗
`llama-3.2-1b-instruct`	2,457 Neurons/百万输入 token	18,252 Neurons/百万输出 token
`llama-3.1-8b-instruct-fp8-fast`	4,119 Neurons/百万输入 token	34,868 Neurons/百万输出 token
`llama-3.3-70b-instruct-fp8-fast`	26,668 Neurons/百万输入 token	204,805 Neurons/百万输出 token
`flux-1-schnell`（图片）	4.8 Neurons/张 + 9.6 Neurons/步	—
`whisper`（语音）	41.14 Neurons/分钟音频	—

Workers AI 免费额度

"来算笔账。假设用 llama-3.1-8b-instruct-fp8-fast 做对话，每次对话大约 500 输入 token + 200 输出 token："

每次对话消耗 = (500 / 1,000,000 × 4,119) + (200 / 1,000,000 × 34,868)
            ≈ 2.06 + 6.97
            ≈ 9 Neurons

每天免费额度可支撑 = 10,000 / 9 ≈ 1,111 次对话

"每天 1,100 多次 AI 对话，免费。对一个实习项目来说，够用了吧？"

"那图片生成呢？"

Flux-1-schnell，1张图（512×512，4步）：
消耗 = 4.8 + 9.6 × 4 = 43.2 Neurons
每天免费额度可生成 = 10,000 / 43.2 ≈ 231 张图

"每天 200 多张 AI 生图，也免费。"

小王放下计算器："这……真不花钱？"

"在免费额度内，真不花钱。UTC 零点（北京时间早上 8 点）重置额度，每天都是新的 10,000 Neurons。"

"不过要注意几点限制："

免费计划有每日上限：10,000 Neurons 用完后，AI 调用会报错，直到第二天重置
不同模型消耗差异大：70B 模型一次调用可能消耗 50+ Neurons，1B 模型只需 2-3 Neurons
本地开发也消耗额度：wrangler dev 调用 AI 走的是真实 GPU，不是模拟
部分高级模型可能需要付费计划：如某些 Partner 模型（Deepgram 等）

"可以在 Cloudflare Dashboard 的 Workers AI 页面实时查看 Neuron 用量，做到心中有数。"

小结预告

本篇知识点回顾

知识点	核心内容
传统 LLM 部署痛点	GPU 硬件贵、部署门槛高、资源利用率低、扩容慢
边缘 AI 推理	Cloudflare 在边缘节点部署 GPU，零运维、低延迟、按需付费
Workers AI 模型库	70+ 开源模型，覆盖文本生成、图片生成、语音识别、TTS、嵌入等
AI Binding	`wrangler.jsonc` 中配置 `"ai": {"binding": "AI"}`，代码中用 `env.AI` 访问
调用模型	`env.AI.run("@cf/模型ID", { messages / prompt })`，一行代码完成推理
流式输出	加 `stream: true` 参数，返回 ReadableStream，前端逐字显示
模型选型原则	够用就好，1B 能做的别用 70B，节省 Neurons
AI Gateway	缓存、限流、监控、降级，统一管理 AI 流量
免费额度	10,000 Neurons/天，约 1,100 次对话或 230 张图片
Neuron 计费	不同模型消耗不同，$0.011/1,000 Neurons

动手挑战

基础挑战：给星火AI 的 /api/chat 接口接入 Workers AI，用 llama-3.1-8b-instruct-fp8-fast 模型实现基本对话功能，部署到 workers.dev 域名
进阶挑战：实现 /api/chat/stream 流式对话接口，前端用 fetch + ReadableStream 接收，实现逐字显示效果
折腾挑战：添加 /api/image/generate 图片生成接口，用 flux-1-schnell 模型，前端实现一个"AI 画板"——用户输入文字描述，点击生成按钮显示 AI 生成的图片

提示：模型 ID 一定要带 @cf/ 前缀，比如 @cf/meta/llama-3.1-8b-instruct-fp8-fast。完整模型列表见 developers.cloudflare.com/workers-ai/models/。本地开发记得 npx wrangler dev 会消耗真实额度，别疯狂刷请求。

下回预告

星火AI 终于有了真正的 AI 功能——能聊天、能画图。小王亲自体验了一把，对话流畅，画图精美，满意地点了点头。

但随后她问了句："用户生成的图片存在哪儿？"

林一愣住了。图片生成后直接返回给用户，没有保存。如果用户刷新页面，图片就没了。要保存图片，就得用对象存储服务——又是存储，又是流量，又是钱。

"张哥，存图片是不是得用云存储？按流量收费那种？"

老张笑了笑："你还没被 CDN 的流量费坑够？Cloudflare 有个 R2 对象存储，存图片、存文件，零出口流量费。没错，读出来不花钱。"

"零出口流量费？"林一的眼睛又亮了。

下篇预告：《AI 功能上线了，用户生成的图片存哪里？——R2 对象存储》

故事引入​

技术讲解​

大语言模型（LLM）：简单回顾​

模型推理的传统方式：为什么贵？​

边缘 AI 推理：Cloudflare 的解法​

Workers AI 模型列表：都有什么模型可用？​

文本生成（Text Generation）​

图片生成（Text-to-Image）​

语音识别（Speech-to-Text）​

文本转语音（Text-to-Speech）​

文本嵌入（Text Embeddings）​

其他能力​

不同场景的模型选择​

AI Gateway：给你的 AI 加个"中间人"​

实操指导​

第一步：给 Worker 绑定 AI​

第二步：实现 AI 对话接口​

第三步：流式输出——让 AI 像"打字"一样回复​

第四步：图片生成接口​

第五步：本地测试与部署​

免费额度与限制：能省多少钱？​

小结预告​

本篇知识点回顾​

动手挑战​

下回预告​