零成本搭建 AI API：Cloudflare Workers AI 实战教程

AIEII

调用一次 GPT-5.4 的 API，100 万 token 输入要 $2，输出要 $8。Claude Opus 4.6 更贵，输入 $15，输出 $75。

如果你只是做一些轻量的 AI 功能，比如给博客加个自动摘要，给图片加个描述，给搜索加个语义理解，这些费用会快速叠加。

Cloudflare Workers AI 给了一条不要钱的路。

每天 10,000 次免费请求。文本生成、图片识别、翻译、嵌入向量、文本分类，全都有。部署在 Cloudflare 的边缘网络上，全球延迟低。

这篇文章从零开始，带你搭建自己的 AI API。不需要买服务器，不需要管 GPU，不需要填信用卡。

Workers AI 是什么

先说大背景。

Cloudflare 有一个 Workers 平台，本质上是一个 Serverless 运行环境。你写一小段 JavaScript 或 TypeScript 代码，上传到 Cloudflare，它会被部署到全球 300 多个数据中心。用户从哪个国家访问，就在离他最近的节点上运行。

Workers AI 是 Workers 平台上的 AI 推理服务。Cloudflare 在自己的数据中心部署了一批 AI 模型（主要是开源模型），你的 Worker 代码可以直接调用这些模型。

关键词：边缘推理。你的 AI 请求不需要跑到某个中心化的 GPU 集群，而是在离用户最近的节点上完成。延迟通常在 50-200ms。

这和传统的 AI API（OpenAI、Anthropic）的最大区别是：你不在用别人的 API，你在用自己的。代码是你的，接口是你设计的，数据不过第三方。

免费额度到底给了多少

这是大家最关心的部分。截至 2026 年 3 月，Workers AI 的免费额度是这样的：

资源	免费额度	说明
Workers 请求	100,000 次/天	包含 AI 和非 AI 请求
Workers AI 推理	10,000 Neurons/天	不同模型消耗不同 Neurons
KV 存储	100,000 次读/天	用于缓存
R2 存储	10 GB/月	存放图片等静态资源

关于 Neurons：Cloudflare 用 Neurons 作为统一计量单位。不同模型每次请求消耗的 Neurons 不同：

模型	类型	每次约消耗 Neurons
@cf/meta/llama-3.3-70b-instruct-fp8-fast	文本生成 (大)	50-300 (取决于 token 数)
@cf/meta/llama-3.2-3b-instruct	文本生成 (小)	5-30
@cf/meta/llama-3.2-11b-vision-instruct	图片理解	80-200
@cf/meta/m2m100-1.2b	翻译	10-30
@cf/baai/bge-large-en-v1.5	嵌入向量	2-5
@cf/microsoft/resnet-50	图片分类	3-8

粗略估算：如果你主要用小模型（3B 参数的 Llama），每天的免费额度大约能跑 300-500 次文本生成。如果用大模型（70B），大约 30-50 次。混合使用的话，日均 100-200 次请求完全没问题。

对于个人项目和小型应用，这个额度够了。 每天几百次的 AI 调用，足够支撑一个日活几十到几百人的产品。

支持的模型列表

Workers AI 目前支持的模型主要来自以下厂商：

文本生成 (LLM)：

Meta Llama 3.3 70B (旗舰)
Meta Llama 3.2 3B / 1B (轻量)
Mistral 7B
Google Gemma 2 9B
Qwen 2.5 系列
DeepSeek R1 Distill (推理增强)

视觉理解：

Llama 3.2 11B Vision
LLaVA (图片描述)

翻译：

M2M100 1.2B (支持 100+ 语种)

嵌入向量 (Embedding)：

BGE Large EN v1.5
BGE Base EN v1.5
BGE Small EN v1.5

文本分类 / 情感分析：

DistilBERT SST-2

图片分类：

ResNet-50

语音转文字 (STT)：

OpenAI Whisper (开源版)

图片生成：

Stable Diffusion XL (文生图)
Stable Diffusion XL Lightning (快速版)

模型列表一直在更新。Cloudflare 每个月都会加新模型。完整列表看 developers.cloudflare.com/workers-ai/models。

5 分钟快速上手

第一步：注册 Cloudflare 账号

如果你还没有 Cloudflare 账号，去 dash.cloudflare.com 注册一个。免费的，不需要绑信用卡。

第二步：安装 Wrangler CLI

Wrangler 是 Cloudflare 的命令行工具，用来创建、开发、部署 Workers。

npm install -g wrangler

安装完后登录：

wrangler login

会打开浏览器让你授权。点同意就行。

第三步：创建项目

wrangler init my-ai-api
cd my-ai-api

选择 “Hello World” Worker 模板就行。

第四步：写你的第一个 AI API

打开 src/index.ts（或 src/index.js），把内容替换成：

export interface Env {
  AI: Ai;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // 只接受 POST 请求
    if (request.method !== "POST") {
      return new Response("Send a POST request with { prompt: 'your question' }", {
        status: 405,
      });
    }

    const body = await request.json() as { prompt: string };

    if (!body.prompt) {
      return new Response(JSON.stringify({ error: "Missing prompt" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      });
    }

    // 调用 Llama 3.2 3B 模型
    const response = await env.AI.run("@cf/meta/llama-3.2-3b-instruct", {
      messages: [
        { role: "system", content: "You are a helpful assistant. Reply in the same language as the user." },
        { role: "user", content: body.prompt },
      ],
      max_tokens: 512,
    });

    return new Response(JSON.stringify(response), {
      headers: { "Content-Type": "application/json" },
    });
  },
};

第五步：配置 wrangler.toml

确保你的 wrangler.toml 里有 AI binding：

name = "my-ai-api"
main = "src/index.ts"
compatibility_date = "2024-01-01"

[ai]
binding = "AI"

第六步：本地测试

wrangler dev

打开另一个终端，测试一下：

curl -X POST http://localhost:8787 \
  -H "Content-Type: application/json" \
  -d '{"prompt": "用一句话解释什么是 Serverless"}'

你应该能看到 AI 的回复。

第七步：部署到线上

wrangler deploy

完成。你的 AI API 现在运行在 https://my-ai-api.<你的子域名>.workers.dev 上。全球可访问，免费。

从零到部署完成，如果顺利的话真的只要 5 分钟。 这就是 Serverless 的魅力。

实用场景 1：文本摘要 API

最常见的需求之一。给一段长文本，返回摘要。

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== "POST") {
      return new Response("POST { text, max_length? }", { status: 405 });
    }

    const { text, max_length = 200 } = await request.json() as {
      text: string;
      max_length?: number;
    };

    if (!text) {
      return new Response(JSON.stringify({ error: "Missing text" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      });
    }

    const response = await env.AI.run("@cf/meta/llama-3.2-3b-instruct", {
      messages: [
        {
          role: "system",
          content: `You are a text summarizer. Summarize the given text in under ${max_length} characters. Keep the key points. Reply in the same language as the input text.`,
        },
        { role: "user", content: text },
      ],
      max_tokens: 256,
    });

    return new Response(JSON.stringify({
      summary: response.response,
      original_length: text.length,
    }), {
      headers: { "Content-Type": "application/json" },
    });
  },
};

用法：

curl -X POST https://your-worker.workers.dev \
  -H "Content-Type: application/json" \
  -d '{
    "text": "这里放一篇长文章的内容...",
    "max_length": 150
  }'

适用场景：博客文章自动生成摘要、RSS 阅读器的内容预览、搜索结果片段生成。

实用场景 2：图片描述 API

给一张图片 URL，返回图片的文字描述。

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== "POST") {
      return new Response("POST { image_url, question? }", { status: 405 });
    }

    const { image_url, question = "Describe this image in detail." } =
      await request.json() as { image_url: string; question?: string };

    if (!image_url) {
      return new Response(JSON.stringify({ error: "Missing image_url" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      });
    }

    // 下载图片
    const imageResponse = await fetch(image_url);
    const imageBlob = await imageResponse.arrayBuffer();

    // 将图片转为 base64
    const base64 = btoa(
      String.fromCharCode(...new Uint8Array(imageBlob))
    );

    // 调用视觉模型
    const response = await env.AI.run(
      "@cf/meta/llama-3.2-11b-vision-instruct",
      {
        messages: [
          {
            role: "user",
            content: [
              { type: "text", text: question },
              {
                type: "image_url",
                image_url: { url: `data:image/jpeg;base64,${base64}` },
              },
            ],
          },
        ],
        max_tokens: 512,
      }
    );

    return new Response(JSON.stringify({
      description: response.response,
      image_url: image_url,
    }), {
      headers: { "Content-Type": "application/json" },
    });
  },
};

用法：

curl -X POST https://your-worker.workers.dev \
  -H "Content-Type: application/json" \
  -d '{
    "image_url": "https://example.com/photo.jpg",
    "question": "这张图片里有什么？用中文回答。"
  }'

适用场景：无障碍 alt text 自动生成、电商产品图描述、社交媒体图片审核、图片搜索的索引生成。

注意：图片不能太大。Workers 单次请求有 100MB 的内存限制和 30 秒的 CPU 时间限制（免费版）。建议在前端或上游先把图片压缩到 1MB 以内。

实用场景 3：文本翻译 API

M2M100 模型支持 100 多种语言之间的互译，不用经过英语中转。

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== "POST") {
      return new Response("POST { text, source_lang, target_lang }", { status: 405 });
    }

    const { text, source_lang = "en", target_lang = "zh" } =
      await request.json() as {
        text: string;
        source_lang?: string;
        target_lang?: string;
      };

    if (!text) {
      return new Response(JSON.stringify({ error: "Missing text" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      });
    }

    const response = await env.AI.run("@cf/meta/m2m100-1.2b", {
      text: text,
      source_lang: source_lang,
      target_lang: target_lang,
    });

    return new Response(JSON.stringify({
      translated_text: response.translated_text,
      source_lang,
      target_lang,
    }), {
      headers: { "Content-Type": "application/json" },
    });
  },
};

用法：

# 英译中
curl -X POST https://your-worker.workers.dev \
  -H "Content-Type: application/json" \
  -d '{
    "text": "The quick brown fox jumps over the lazy dog",
    "source_lang": "en",
    "target_lang": "zh"
  }'

# 日译中
curl -X POST https://your-worker.workers.dev \
  -H "Content-Type: application/json" \
  -d '{
    "text": "今日はいい天気ですね",
    "source_lang": "ja",
    "target_lang": "zh"
  }'

翻译质量怎么样？ 说实话，和 GPT-5.4 或 DeepL 比有差距。M2M100 是一个 1.2B 参数的模型，处理简单句子没问题，但复杂长句、习语、文化特定表达的翻译质量明显不如专业翻译服务。

适用场景：用户界面多语言切换、简短内容翻译（通知、标签、按钮文案）、翻译辅助（先用免费的跑一遍，再人工润色）。不适合文学翻译或正式商务文件。

实用场景 4：嵌入向量 API（语义搜索）

这个场景稍微高级一点，但非常实用。

**嵌入向量（Embedding）**是把文本转成一组数字（向量），语义相近的文本会得到相近的向量。有了向量，你就可以做语义搜索：用户搜"如何提高工作效率"，能匹配到"提升生产力的 10 个方法"，即使关键词完全不同。

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);
    const path = url.pathname;

    // 生成单个文本的向量
    if (path === "/embed" && request.method === "POST") {
      const { text } = await request.json() as { text: string };

      const response = await env.AI.run("@cf/baai/bge-large-en-v1.5", {
        text: [text],
      });

      return new Response(JSON.stringify({
        embedding: response.data[0],
        dimensions: response.data[0].length,
      }), {
        headers: { "Content-Type": "application/json" },
      });
    }

    // 批量生成向量
    if (path === "/embed-batch" && request.method === "POST") {
      const { texts } = await request.json() as { texts: string[] };

      if (!texts || texts.length === 0) {
        return new Response(JSON.stringify({ error: "Missing texts array" }), {
          status: 400,
          headers: { "Content-Type": "application/json" },
        });
      }

      // BGE 模型一次最多处理 100 条
      const batchSize = 100;
      const allEmbeddings: number[][] = [];

      for (let i = 0; i < texts.length; i += batchSize) {
        const batch = texts.slice(i, i + batchSize);
        const response = await env.AI.run("@cf/baai/bge-large-en-v1.5", {
          text: batch,
        });
        allEmbeddings.push(...response.data);
      }

      return new Response(JSON.stringify({
        embeddings: allEmbeddings,
        count: allEmbeddings.length,
        dimensions: allEmbeddings[0]?.length,
      }), {
        headers: { "Content-Type": "application/json" },
      });
    }

    // 计算两段文本的相似度
    if (path === "/similarity" && request.method === "POST") {
      const { text1, text2 } = await request.json() as {
        text1: string;
        text2: string;
      };

      const response = await env.AI.run("@cf/baai/bge-large-en-v1.5", {
        text: [text1, text2],
      });

      // 余弦相似度计算
      const vec1 = response.data[0];
      const vec2 = response.data[1];
      let dotProduct = 0;
      let norm1 = 0;
      let norm2 = 0;

      for (let i = 0; i < vec1.length; i++) {
        dotProduct += vec1[i] * vec2[i];
        norm1 += vec1[i] * vec1[i];
        norm2 += vec2[i] * vec2[i];
      }

      const similarity = dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));

      return new Response(JSON.stringify({
        similarity: similarity,
        text1,
        text2,
      }), {
        headers: { "Content-Type": "application/json" },
      });
    }

    return new Response("Routes: POST /embed, POST /embed-batch, POST /similarity", {
      status: 404,
    });
  },
};

用法：

# 生成向量
curl -X POST https://your-worker.workers.dev/embed \
  -H "Content-Type: application/json" \
  -d '{"text": "Cloudflare Workers is a serverless platform"}'

# 计算相似度
curl -X POST https://your-worker.workers.dev/similarity \
  -H "Content-Type: application/json" \
  -d '{
    "text1": "如何提高工作效率",
    "text2": "提升生产力的方法"
  }'
# 返回 similarity: 0.87 (高度相似)

适用场景：博客/文档站的"相关文章推荐"、知识库语义搜索、FAQ 自动匹配、内容去重检测。

搭配 Vectorize 更强：Cloudflare 还有一个 Vectorize 向量数据库（也有免费额度）。你可以把文章的向量存进 Vectorize，搜索时用用户查询的向量去做相似度匹配。这就是一个完整的 **RAG（检索增强生成）**的数据层了。

性能优化技巧

免费额度有限，每一次调用都要用在刀刃上。

技巧一：KV 缓存

对于相同或相似的请求，用 Workers KV 做缓存。

export interface Env {
  AI: Ai;
  CACHE: KVNamespace;
}

async function getCachedOrGenerate(
  env: Env,
  cacheKey: string,
  generator: () => Promise<string>
): Promise<string> {
  // 先查缓存
  const cached = await env.CACHE.get(cacheKey);
  if (cached) return cached;

  // 缓存未命中，调用 AI
  const result = await generator();

  // 写入缓存，24 小时过期
  await env.CACHE.put(cacheKey, result, { expirationTtl: 86400 });

  return result;
}

wrangler.toml 配置：

[[kv_namespaces]]
binding = "CACHE"
id = "your-kv-namespace-id"

效果：假设你的 API 有 30% 的请求是重复的（很常见，比如热门文章的摘要），缓存能直接省掉 30% 的 AI 调用。KV 的读取速度在 1-5ms，比 AI 推理快几百倍。

技巧二：流式输出

对于文本生成，使用 Server-Sent Events (SSE) 流式返回结果。用户体验更好（不用等整段话生成完才看到），而且如果用户中途关闭连接，可以提前终止生成，节省 token。

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const { prompt } = await request.json() as { prompt: string };

    const stream = await env.AI.run("@cf/meta/llama-3.2-3b-instruct", {
      messages: [
        { role: "system", content: "You are a helpful assistant." },
        { role: "user", content: prompt },
      ],
      max_tokens: 512,
      stream: true,  // 开启流式
    });

    return new Response(stream, {
      headers: {
        "Content-Type": "text/event-stream",
        "Cache-Control": "no-cache",
        "Connection": "keep-alive",
      },
    });
  },
};

前端消费这个流也很简单：

const response = await fetch("/api/chat", {
  method: "POST",
  body: JSON.stringify({ prompt: "你好" }),
});

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

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const chunk = decoder.decode(value);
  // 解析 SSE 数据，追加到页面
  console.log(chunk);
}

技巧三：模型选择策略

不是所有请求都需要最大的模型。

function selectModel(task: string, textLength: number): string {
  // 短文本 + 简单任务 → 用小模型
  if (textLength < 200 && ["classify", "translate", "extract"].includes(task)) {
    return "@cf/meta/llama-3.2-1b-instruct";  // 1B, 极快
  }

  // 中等复杂度 → 用 3B 模型
  if (textLength < 2000) {
    return "@cf/meta/llama-3.2-3b-instruct";  // 3B, 平衡
  }

  // 复杂任务或长文本 → 用大模型
  return "@cf/meta/llama-3.3-70b-instruct-fp8-fast";  // 70B, 最强
}

1B 模型每次消耗约 2-5 Neurons，70B 模型消耗 50-300 Neurons。对于简单的文本分类或关键词提取，用 1B 模型的效果和 70B 差别不大，但成本差了 50 倍。

技巧四：错误处理和重试

AI 模型推理偶尔会失败（冷启动、过载、超时）。加一个简单的重试机制：

async function runWithRetry(
  env: Env,
  model: string,
  input: any,
  maxRetries = 2
): Promise<any> {
  for (let i = 0; i <= maxRetries; i++) {
    try {
      return await env.AI.run(model, input);
    } catch (error: any) {
      if (i === maxRetries) throw error;

      // 模型冷启动或过载，等一下重试
      if (error.message?.includes("overloaded") || error.message?.includes("timeout")) {
        await new Promise(r => setTimeout(r, 1000 * (i + 1)));
        continue;
      }

      // 其他错误直接抛出
      throw error;
    }
  }
}

和其他免费 AI API 对比

Workers AI 不是唯一的免费选项。来看看市场上还有哪些。

Groq

Groq 用自研的 LPU 芯片做推理，速度极快。免费额度给得也不少：

Llama 3.3 70B：每分钟 30 次请求，每天约 14,400 次
推理速度：约 330 token/秒，比大多数 GPU 推理快 5-10 倍

优势：速度是 Groq 的核心卖点。如果你的场景对延迟极度敏感（实时对话、游戏 NPC），Groq 的体验明显优于 Workers AI。

劣势：只有 LLM 文本生成。没有图片理解、没有翻译模型、没有嵌入向量。而且 Groq 的免费额度是"每分钟"限制而不是"每天"限制，突发流量容易被限速。

Together AI

Together AI 提供多种开源模型的托管推理：

免费额度：$5 注册奖励（约 500 万 token for Llama 3 8B）
模型丰富度：支持 100+ 开源模型
支持微调：可以上传自己的数据微调模型

优势：模型选择最丰富，支持微调。如果你需要用一个冷门的开源模型，Together 很可能有。

劣势：免费额度是一次性的 $5 credit，用完就没了。不像 Workers AI 和 Groq 每天刷新。长期免费使用不太现实。

HuggingFace Inference API

HuggingFace 是开源模型的大本营，也提供免费的推理 API：

免费额度：低速推理，约 1000 次/天（不稳定）
模型数量：理论上所有 HuggingFace Hub 上的模型都能调用

优势：模型数量无敌。你在论文里看到的任何模型，大概率在 HuggingFace 上能找到。

劣势：免费推理速度慢（经常排队 10-30 秒），稳定性差（高峰期超时），没有 edge 部署（延迟高）。作为实验和原型验证可以，生产环境不太靠谱。

对比总结

维度	Workers AI	Groq	Together AI	HuggingFace
免费额度	10K Neurons/天	14K+ 次/天	$5 一次性	~1K 次/天
额度刷新	每天	每天	不刷新	每天
推理速度	中等	极快	中等	慢
模型种类	中等 (20+)	少 (LLM only)	丰富 (100+)	海量
多模态	是	否	部分	是
边缘部署	是 (全球 300+)	否	否	否
生产可用	是	是	是	风险高
搭配存储	KV/R2/D1/Vectorize	无	无	无

我的选择逻辑：

要搭建完整的 AI 应用（API + 缓存 + 存储 + 向量搜索）→ Workers AI，生态最完整
只需要最快的 LLM 文本生成 → Groq
需要特定模型或微调 → Together AI
做实验、跑 Demo → HuggingFace

限制和注意事项

Workers AI 不是万能的。在决定用它之前，你需要知道这些限制。

1. 模型能力天花板。

Workers AI 上最强的文本模型是 Llama 3.3 70B。这个模型很好，但和 GPT-5.4、Claude Opus 4.6 比，在复杂推理、创意写作、长文本理解方面有明显差距。如果你的场景需要顶级模型能力（比如写一篇深度分析报告，或者做复杂的多步推理），Workers AI 目前满足不了。

2. 上下文长度有限。

大多数模型的上下文窗口在 4K-8K token。Llama 3.3 70B 支持 128K，但在 Workers 环境下受限于内存和超时时间，实际可用上下文大约在 16K-32K token。和 GPT-5.4 的 110 万 token、Gemini 的 100 万 token 差了两个数量级。

3. 冷启动延迟。

如果一个模型最近没被调用过，第一次请求可能有 3-10 秒的冷启动延迟。热了之后正常延迟在 100-500ms。对于实时对话场景，冷启动可能导致用户体验不好。

解决办法：写一个定时触发器（Cron Trigger），每 5 分钟给模型发一个空请求保持热度。

# wrangler.toml
[triggers]
crons = ["*/5 * * * *"]

export default {
  async scheduled(event: ScheduledEvent, env: Env) {
    // 保温请求
    await env.AI.run("@cf/meta/llama-3.2-3b-instruct", {
      messages: [{ role: "user", content: "ping" }],
      max_tokens: 1,
    });
  },
  // ... fetch handler
};

4. 没有微调能力。

Workers AI 目前不支持上传自定义数据微调模型。你只能用现有的模型。如果你需要一个针对特定领域优化的模型（医疗、法律、金融），Workers AI 不是好选择。

5. 中文能力参差不齐。

Llama 系列模型的中文能力在进步，但和专门做中文的 Qwen、DeepSeek 比还有差距。Workers AI 上也有 Qwen 2.5 系列，中文任务可以优先选这个。

进阶：组合多个模型构建 AI 工作流

单个模型的能力有限，但把多个模型串起来，效果能翻倍。

示例：智能内容处理流水线

假设你有一个内容平台，用户上传图片 + 文字。你想自动完成：

图片描述生成（视觉模型）
文本 + 图片描述合并，生成摘要（LLM）
摘要翻译成英文（翻译模型）
生成嵌入向量用于搜索（Embedding 模型）

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const { text, image_url } = await request.json() as {
      text: string;
      image_url?: string;
    };

    let fullContent = text;

    // Step 1: 如果有图片，生成描述
    if (image_url) {
      const imageResponse = await fetch(image_url);
      const imageBlob = await imageResponse.arrayBuffer();
      const base64 = btoa(String.fromCharCode(...new Uint8Array(imageBlob)));

      const visionResult = await env.AI.run(
        "@cf/meta/llama-3.2-11b-vision-instruct",
        {
          messages: [{
            role: "user",
            content: [
              { type: "text", text: "Describe this image concisely in Chinese." },
              { type: "image_url", image_url: { url: `data:image/jpeg;base64,${base64}` } },
            ],
          }],
          max_tokens: 200,
        }
      );

      fullContent += `\n\n[图片内容: ${visionResult.response}]`;
    }

    // Step 2: 生成中文摘要
    const summaryResult = await env.AI.run(
      "@cf/meta/llama-3.2-3b-instruct",
      {
        messages: [
          { role: "system", content: "用中文写一段 100 字以内的摘要，提取核心信息。" },
          { role: "user", content: fullContent },
        ],
        max_tokens: 200,
      }
    );
    const summary_zh = summaryResult.response;

    // Step 3: 翻译成英文
    const translationResult = await env.AI.run("@cf/meta/m2m100-1.2b", {
      text: summary_zh,
      source_lang: "zh",
      target_lang: "en",
    });
    const summary_en = translationResult.translated_text;

    // Step 4: 生成嵌入向量 (中英文各一个)
    const embeddingResult = await env.AI.run("@cf/baai/bge-large-en-v1.5", {
      text: [summary_zh, summary_en],
    });

    return new Response(JSON.stringify({
      summary_zh,
      summary_en,
      embedding_zh: embeddingResult.data[0],
      embedding_en: embeddingResult.data[1],
      models_used: 4,
      total_neurons_estimate: "~150-300",
    }), {
      headers: { "Content-Type": "application/json" },
    });
  },
};

这个流水线用了 4 个模型，一次请求完成了 4 个任务。 如果用商业 API（GPT-4o Vision + GPT-4o + DeepL + OpenAI Embedding），同样的事情大概要花 $0.02-0.05。用 Workers AI，免费。

更复杂的场景：RAG 搜索

如果你搭配 Vectorize（Cloudflare 的向量数据库）和 D1（SQLite 数据库），可以构建一个完整的 RAG 系统：

索引阶段：文章内容 → Embedding 模型 → 向量存入 Vectorize，元数据存入 D1
搜索阶段：用户查询 → Embedding 模型 → 在 Vectorize 中找最相似的 5 篇文章 → 从 D1 取出原文
生成阶段：原文 + 用户问题 → LLM → 生成带引用的回答

整个系统跑在 Cloudflare 的边缘网络上，免费额度内，延迟在 200-500ms。这在一年前还需要自己租 GPU 服务器、部署向量数据库、写一堆胶水代码才能做到。

最后：什么时候该用，什么时候不该

适合用 Workers AI 的场景：

个人项目、Side Project、原型验证
轻量 AI 功能（摘要、分类、翻译、搜索）
需要全球低延迟的 API
已经在用 Cloudflare 生态（Workers + KV + R2 + D1）
预算为零但想加 AI 功能

不适合用 Workers AI 的场景：

需要顶级模型能力（复杂推理、创意写作）
高并发生产环境（日均 10 万+请求）
需要微调自定义模型
需要超长上下文（10 万 token+）
对中文能力要求极高的场景

Workers AI 不会取代 OpenAI 或 Anthropic 的 API。它解决的是另一个问题：当你不需要最强的模型，只需要一个够用的、免费的、部署简单的 AI 能力时，它是目前最好的选择。

就像不是每个网站都需要 AWS，不是每个 AI 功能都需要 GPT-5.4。

选对工具，比选最贵的工具重要得多。

本文首发于 aieii.com，一个关注 AI 工具与趋势的中文内容平台。