解密openclaw底层pi-mono架构系列一：7. pi-pods：把 GPU 服务器变成你的私有 AI 后端

最新推荐文章于 2026-08-20 18:52:12 发布

原创最新推荐文章于 2026-08-20 18:52:12 发布 · 589 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

aiagent

AI 时代程序员必备技能

Codex、Claude Code、Cursor、Hermes Agent、OpenClaw等工程化实战专栏，讲透 AI 如何接管脏活累活

一键订阅

解密openclaw底层pi-mono架构系列一：7. pi-pods：把 GPU 服务器变成你的私有 AI 后端

>>关注，点赞，转发私信发代码<<

不谈玄学，只讲落地。
我是一名深耕算法工程化一线的实践者，擅长将新技术、关键技术、AI/ML 技术从论文和 demo 转化为可规模化部署的生产系统。在这里,你看不到堆砌公式的理论空谈,只有真实项目中踩过的坑、趟过的路,每一篇文章都源自实战经验的提炼。我相信技术的价值在于解决真实问题,而不是制造焦虑。如果你也厌倦了"收藏即学会",渴望掌握让算法真正跑起来的硬核能力,那么这里就是你的技术补给站。

在这里插入图片描述

pi-pods：把 GPU 服务器变成你的私有 AI 后端

前六篇我们从底层到上层走通了整条链路：pi-ai（统一 LLM API）→ pi-agent-core（智能体运行时）→ pi-tui（终端 UI）→ pi-coding-agent（编程助手）→ pi-web-ui（浏览器聊天）→ pi-mom（Slack 智能体）。但有一个根本问题没解决——这些全都依赖别人的 API。如果你需要数据不出内网、需要极低成本跑百万 Token、需要微调自己的领域模型呢？这就是本篇主角 pi-pods。

为什么要自己部署 LLM
pi-pods 是什么
整体架构：从 CLI 到 GPU 到 API
vLLM：高性能推理引擎
pi pods CLI 命令详解
实战：用 pi-ai 连接本地 vLLM
实战：流式输出
实战：工具调用（Function Calling）
实战：多模型路由
成本对比与选型建议
总结与回顾

1. 为什么要自己部署 LLM

先问一个问题：你现在用 Claude API 或 OpenAI API 写代码、做翻译、跑智能体，一切正常——为什么还要折腾自己部署？

答案取决于你的场景：

场景	痛点	解决方案
医疗/金融/政务数据	数据不能发到外部 API	自托管，数据不出内网
日均百万 Token 调用	Claude API 费用爆炸	自托管，边际成本趋零
需要微调特定领域	云 API 不支持微调自己的数据	自托管，完全掌控模型
离线/边缘环境	没有互联网连接	本地 GPU 部署
学习研究开源模型	想了解模型内部机制	本地跑，随便折腾

核心思路：用开源模型 + 自己的 GPU，获得和云 API 一样的开发体验。

这正是 pi-pods 的设计目标。

2. pi-pods 是什么

一句话定义

pi-pods = GPU 服务器管理 CLI + vLLM 自动部署 + OpenAI 兼容 API

它做了三件事：

1. 管理 GPU 服务器    ← 一条命令创建、配置、销毁云 GPU 实例
2. 部署 vLLM 引擎     ← 自动安装 CUDA、vLLM，配置模型参数
3. 暴露 OpenAI API    ← 模型部署后，任何 OpenAI SDK 都能直接调用

类比理解

你要做的事	不用 pi-pods	用 pi-pods
租 GPU 服务器	登录云平台，手动选机型，等待开机	`pi pods setup dc1 "ssh root@1.2.3.4"`
安装推理框架	SSH 进去，装 CUDA、Python、vLLM，调半天参数	自动完成
启动模型	手写 vLLM 启动命令，配置 tensor parallel	`pi start Qwen/Qwen2.5-32B --name qwen`
调用模型	手动拼 curl 请求或写 SDK 代码	`pi agent qwen "你好"` 或用任何 OpenAI SDK
停止计费	手动登录云平台关机	`pi stop`

关键认知：pi-pods 不是一个推理框架，它是一个"GPU 服务器管家"，底层用 vLLM 做推理。

3. 整体架构：从 CLI 到 GPU 到 API

源码结构

packages/pods/src/
├── main.ts               # CLI 入口，解析命令
├── commands/
│   ├── setup.ts          # ① pi pods setup —— 配置 GPU 服务器
│   ├── start.ts          # ② pi start —— 启动模型
│   ├── stop.ts           # ③ pi stop —— 停止模型
│   ├── list.ts           # ④ pi list —— 列出运行中的模型
│   ├── agent.ts          # ⑤ pi agent —— 与模型对话
│   └── shell.ts          # ⑥ pi shell —— SSH 进入服务器
├── providers/
│   ├── datacrunch.ts     # DataCrunch GPU 提供商
│   ├── runpod.ts         # RunPod GPU 提供商
│   └── vast.ts           # Vast.ai GPU 提供商
└── vllm/
    ├── setup.ts          # vLLM 安装和配置
    ├── start.ts          # 启动 vLLM 服务
    └── models.ts         # 预定义模型配置（已知模型自动选参数）

系统架构

你的电脑（本地）                    GPU 服务器（云端或本地）
┌─────────────────┐              ┌──────────────────────────────────┐
│  pi pods CLI    │──── SSH ────→│  Ubuntu 24.04 + CUDA 12.x       │
│  pi-ai SDK      │              │                                  │
│  OpenAI SDK     │── HTTP ────→│  vLLM 推理引擎                    │
│  你的应用代码    │    :8000     │   ├── Qwen2.5-32B (GPU 0-1)     │
└─────────────────┘              │   └── DeepSeek-R1  (GPU 2-3)    │
                                 │                                  │
                                 │  4x NVIDIA A100 80GB             │
                                 └──────────────────────────────────┘

两个关键点：

pi CLI 通过 SSH 管理服务器——安装软件、启动/停止模型、查看日志
模型通过 HTTP 端口暴露 OpenAI 兼容 API——任何 SDK 都能调用，代码零修改

4. vLLM：高性能推理引擎

pi-pods 底层使用 vLLM 作为推理引擎。为什么选 vLLM 而不是 Ollama 或 llama.cpp？

特性	vLLM	Ollama	llama.cpp
定位	生产级推理服务器	本地便捷工具	底层推理库
吞吐量	极高（PagedAttention）	中等	中等
并发支持	原生高并发	单用户为主	需自建服务层
API 兼容	OpenAI 完全兼容	OpenAI 兼容	需封装
工具调用	原生支持	部分支持	不支持
适合场景	多人/生产/高并发	个人本地使用	嵌入式/边缘

vLLM 的核心技术——PagedAttention：

传统推理引擎为每个请求预分配固定大小的 KV Cache 显存，即使请求很短也浪费大量显存。vLLM 借鉴操作系统的分页内存管理，将 KV Cache 分成固定大小的"页"，按需分配和回收，显存利用率提升 2-4 倍。

传统方式：                         vLLM PagedAttention：
┌────────────────────────┐        ┌──────┬──────┬──────┐
│ 请求A: ████░░░░░░░░░░░ │        │ A:██ │ B:██ │ C:██ │  ← 按需分配
│ 请求B: ██░░░░░░░░░░░░░ │        │ A:██ │ B:█░ │ 空闲 │
│ 请求C: ██████░░░░░░░░░ │        │ A:█░ │ C:██ │ C:██ │
│ 大量显存浪费！          │        │ 零浪费！高并发！      │
└────────────────────────┘        └──────┴──────┴──────┘

vLLM 启动参数速查

pi-pods 会自动为已知模型配置最佳参数，但理解这些参数有助于调优：

python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-32B-Instruct \     # ① 模型路径（HuggingFace ID 或本地路径）
  --host 0.0.0.0 \                          # ② 监听所有网卡
  --port 8000 \                             # ③ 服务端口
  --tensor-parallel-size 2 \                # ④ 张量并行：用几块 GPU
  --max-model-len 32768 \                   # ⑤ 最大上下文长度
  --gpu-memory-utilization 0.90 \           # ⑥ GPU 显存利用率（留 10% 给系统）
  --enable-auto-tool-choice \               # ⑦ 启用工具调用
  --tool-call-parser hermes \               # ⑧ 工具调用解析器（Qwen 系列用 hermes）
  --served-model-name my-model              # ⑨ API 中使用的模型名

参数	含义	常用值
`--tensor-parallel-size`	用几块 GPU 并行推理	32B→2, 72B→4, 480B→8
`--max-model-len`	最大上下文 Token 数	4096~131072
`--gpu-memory-utilization`	显存利用率	0.85~0.95
`--enable-auto-tool-choice`	启用 Function Calling	需要工具调用时加

5. pi pods CLI 命令详解

5.1 配置 GPU 服务器

# 设置环境变量（HuggingFace Token 用于下载模型）
export HF_TOKEN=your_huggingface_token
export PI_API_KEY=your_api_key          # 任意字符串，用于 API 认证

# 方式 1：配置云 GPU 服务器（DataCrunch 为例）
pi pods setup dc1 "ssh root@1.2.3.4" \
  --mount "sudo mount -t nfs nfs.datacrunch.io:/models /mnt/hf-models"

# 方式 2：配置本地 GPU 服务器
pi pods setup local "ssh root@192.168.12.178"

setup 做了什么？

① SSH 连接到服务器
② 检测 GPU 型号和数量
③ 安装/更新 vLLM（支持 release/nightly/gpt-oss 版本）
④ 配置模型存储路径（NFS 挂载或本地路径）
⑤ 保存配置到本地 ~/.pi/ 目录

5.2 管理 Pod

pi pods                    # 列出所有配置的 Pod（* 标记当前活跃的）
pi pods active dc2         # 切换活跃 Pod
pi pods remove dc1         # 移除 Pod 配置
pi shell                   # SSH 进入当前活跃 Pod
pi ssh "nvidia-smi"        # 在 Pod 上执行单条命令

5.3 启动模型

# 已知模型 —— pi 自动选择最佳 vLLM 参数
pi start Qwen/Qwen2.5-Coder-32B-Instruct --name qwen

# 自定义 vLLM 参数
pi start deepseek-ai/DeepSeek-V3 --name deepseek --vllm \
  --tensor-parallel-size 4 --trust-remote-code

# 控制资源使用
pi start Qwen/Qwen2.5-32B-Instruct --name qwen \
  --memory 90% \        # GPU 显存使用率
  --context 32k \       # 上下文窗口
  --gpus 2              # 使用 GPU 数量

5.4 使用模型

# 单次查询
pi agent qwen "解释什么是 Transformer"

# 交互式对话（带文件系统工具）
pi agent qwen -i

# 查看模型列表和状态
pi list

# 查看模型日志
pi logs qwen

5.5 停止模型

pi stop qwen              # 停止指定模型
pi stop                   # 停止所有模型（释放 GPU 显存）

6. 实战：用 pi-ai 连接本地 vLLM

pi-pods 部署好模型后，暴露的是 OpenAI 兼容 API——这意味着前几章学过的 pi-ai 直接能用，只需改一个 baseUrl。

这是最核心的认知：部署归部署，调用归调用，代码不需要改。

下面用实际可运行的代码演示。我们连接的是本地 vLLM 服务器（http://192.168.12.178:8383），跑的模型是 Qwen2.5-32B-Instruct。

代码：01-connect-vllm.ts

/**
 * 示例 07-01: 连接本地 vLLM 服务器
 * 运行: tsx 07-pi-pods/01-connect-vllm.ts
 */
import { completeSimple } from "@mariozechner/pi-ai";
import type { Model, Context } from "@mariozechner/pi-ai";

// ① 配置 vLLM 服务器地址和模型
const VLLM_BASE_URL = process.env.VLLM_BASE_URL || "http://192.168.12.178:8383/v1";
const MODEL_ID = process.env.VLLM_MODEL_ID || "Qwen2.5-32B-Instruct";

// ② 构造自定义 Model 对象 —— 指向 vLLM 的 OpenAI 兼容接口
const vllmModel: Model<"openai-completions"> = {
  id: MODEL_ID,
  name: MODEL_ID,
  api: "openai-completions",           // ← vLLM 兼容 OpenAI 格式
  provider: "vllm",
  baseUrl: VLLM_BASE_URL,             // ← 指向你的 vLLM 服务器
  reasoning: false,
  input: ["text"],
  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },  // 自托管无 API 费用
  contextWindow: 32768,
  maxTokens: 4096,
  compat: {
    supportsStore: false,
    supportsDeveloperRole: false,
    supportsUsageInStreaming: true,
  },
};

// ③ 构造对话上下文
const context: Context = {
  systemPrompt: "你是一个运行在本地 GPU 服务器上的 AI 助手，回答简洁准确。",
  messages: [
    {
      role: "user",
      content: "用一句话解释：什么是 vLLM？它和 Ollama 有什么区别？",
      timestamp: Date.now(),
    },
  ],
};

// ④ 调用 —— 和调用 Claude/GPT 完全相同的 API！
const reply = await completeSimple(vllmModel, context, {
  apiKey: "not-needed",                // vLLM 默认不需要 API Key
});

const text = reply.content
  .filter((c) => c.type === "text")
  .map((c) => (c as { type: "text"; text: string }).text)
  .join("");

console.log("AI 回复:", text);
console.log(`tokens: ${reply.usage.input} in / ${reply.usage.output} out`);
console.log("费用: $0（自托管，零 API 费用！）");

运行结果

vLLM 服务器: http://192.168.12.178:8383/v1
模型: Qwen2.5-32B-Instruct

问题: 什么是 vLLM？它和 Ollama 有什么区别？

AI 回复: vLLM 是一个高性能的 LLM 推理引擎，通过 PagedAttention 技术实现高吞吐量
和低延迟；而 Ollama 是一个本地运行的大模型运行工具，侧重于易用性和本地部署，
两者在定位和核心技术上不同。

--- 使用量 ---
输入 tokens: 49
输出 tokens: 60
费用: $0（自托管，零 API 费用！）

注意看代码中标注的 ①②③④，核心就四步：

配置 baseUrl —— 指向 vLLM 地址
构造 Model 对象 —— api: "openai-completions" 告诉 pi-ai 用 OpenAI 协议
构造 Context —— 和之前用 Claude/MiniMax 完全一样
调用 completeSimple —— 和之前完全一样！

这就是 pi-ai 统一 API 的价值——换个 baseUrl，代码不改。

7. 实战：流式输出

长回复场景下，等待完整响应太慢了。流式输出让用户看到"AI 在打字"，体验好得多。

代码：02-streaming-vllm.ts

/**
 * 示例 07-02: vLLM 流式输出
 * 运行: tsx 07-pi-pods/02-streaming-vllm.ts
 */
import { streamSimple } from "@mariozechner/pi-ai";
import type { Model, Context } from "@mariozechner/pi-ai";

const VLLM_BASE_URL = process.env.VLLM_BASE_URL || "http://192.168.12.178:8383/v1";
const MODEL_ID = process.env.VLLM_MODEL_ID || "Qwen2.5-32B-Instruct";

// Model 对象构造省略（和 01 相同）...

const context: Context = {
  systemPrompt: "你是一个技术教练，擅长用简洁的中文解释复杂概念。",
  messages: [
    {
      role: "user",
      content: "请用 5 个要点，解释为什么企业要自己部署大语言模型而不是直接用云 API？",
      timestamp: Date.now(),
    },
  ],
};

// 流式调用 —— 逐字输出
const eventStream = streamSimple(vllmModel, context, { apiKey: "not-needed" });

for await (const event of eventStream) {
  switch (event.type) {
    case "text_delta":
      process.stdout.write(event.delta);       // ← 逐字打印，不换行
      break;
    case "done":
      console.log(`\ntokens: ${event.message.usage.input} in / ${event.message.usage.output} out`);
      break;
    case "error":
      console.error("\nvLLM 错误:", event.error.errorMessage);
      break;
  }
}

运行结果

AI 正在输出（流式）:

1. **数据安全与隐私控制**
企业敏感数据无需上传至第三方服务器，避免数据泄露风险，尤其符合金融、医疗等
强监管行业的合规要求。

2. **完全掌控模型行为与输出**
可定制模型训练和推理逻辑，确保输出内容符合企业价值观、业务规范。

3. **降低长期成本与依赖风险**
云 API 按调用次数收费，高频使用成本高昂；自部署后，边际成本趋近于零。

4. **支持私有化与离线部署**
可在内网、边缘设备或离线环境中运行，适用于网络受限场景。

5. **可深度优化与集成**
可针对企业特定业务场景进行微调和优化，无缝嵌入现有系统。

--- 完成 ---
停止原因: stop
tokens: 50 in / 229 out

和 completeSimple 的区别：streamSimple 返回异步迭代器，每收到一个字就触发 text_delta 事件，实时输出。

8. 实战：工具调用（Function Calling）

工具调用是构建 Agent 的基础能力。Qwen2.5 系列原生支持 Function Calling，vLLM 自动处理工具调用的格式转换。

代码：03-tool-calling-vllm.ts

/**
 * 示例 07-03: vLLM 工具调用
 * 运行: tsx 07-pi-pods/03-tool-calling-vllm.ts
 */
import { completeSimple, Type } from "@mariozechner/pi-ai";
import type { Context, ToolResultMessage, AssistantMessage, ToolCall } from "@mariozechner/pi-ai";

// ① 定义工具：查询 GPU 服务器状态
const tools = [
  {
    name: "get_gpu_status",
    description: "获取 GPU 服务器的运行状态",
    parameters: Type.Object({
      server_id: Type.String({ description: "服务器 ID" }),
    }),
  },
  {
    name: "get_model_info",
    description: "获取指定模型的详细信息",
    parameters: Type.Object({
      model_name: Type.String({ description: "模型名称" }),
    }),
  },
];

// ② 工具实现（模拟返回 GPU 状态数据）
function executeToolCall(toolCall: ToolCall): string {
  if (toolCall.name === "get_gpu_status") {
    return JSON.stringify({
      server_id: toolCall.arguments.server_id,
      gpus: [
        { id: 0, name: "A100 80GB", utilization: "87%", memory: "72.3/80GB" },
        { id: 1, name: "A100 80GB", utilization: "85%", memory: "71.8/80GB" },
      ],
      uptime: "3天12小时",
    });
  }
  if (toolCall.name === "get_model_info") {
    return JSON.stringify({
      model_name: toolCall.arguments.model_name,
      parameters: "32B", quantization: "FP16",
      context_window: 32768,
    });
  }
  return JSON.stringify({ error: "未知工具" });
}

// ③ 构建对话（带工具定义）
const context: Context = {
  systemPrompt: "你是一个 GPU 服务器运维助手。",
  messages: [{
    role: "user",
    content: "帮我查看 gpu-server-01 的状态，以及 Qwen2.5-32B 的信息。",
    timestamp: Date.now(),
  }],
  tools,                           // ← 传入工具定义
};

// ④ 工具调用循环（和第 1 章的 03-tool-calling.ts 完全一样！）
let turn = 1;
while (true) {
  const reply: AssistantMessage = await completeSimple(vllmModel, context, { apiKey: "not-needed" });
  context.messages.push(reply);

  const toolCalls = reply.content.filter((c): c is ToolCall => c.type === "toolCall");
  if (toolCalls.length === 0) {
    // 没有工具调用 → AI 给出最终回答
    const text = reply.content.filter(c => c.type === "text").map((c: any) => c.text).join("");
    console.log("AI 最终回答:", text);
    break;
  }

  // 执行工具，把结果喂回去
  for (const tc of toolCalls) {
    console.log(`调用工具: ${tc.name}`, tc.arguments);
    const result = executeToolCall(tc);
    context.messages.push({
      role: "toolResult", toolCallId: tc.id, toolName: tc.name,
      content: [{ type: "text", text: result }], isError: false, timestamp: Date.now(),
    });
  }
}

运行结果

--- 第 1 轮 LLM 调用 ---
  调用工具: get_gpu_status { server_id: 'gpu-server-01' }
  调用工具: get_model_info { model_name: 'Qwen2.5-32B' }

--- 第 2 轮 LLM 调用 ---

AI 最终回答:
### GPU 服务器状态 (gpu-server-01)
- GPU 0: A100 80GB | 利用率 87% | 显存 72.3/80GB
- GPU 1: A100 80GB | 利用率 85% | 显存 71.8/80GB
- 运行时间: 3天12小时

### 模型信息 (Qwen2.5-32B)
- 参数量: 32B | 量化: FP16 | 上下文窗口: 32,768

重点：工具调用代码和第 1 章用 Claude/MiniMax 时完全一样。只是底层模型从云 API 换成了自托管的 Qwen，上层代码零修改。这就是 OpenAI 兼容 API 的威力。

9. 实战：多模型路由

实际生产中，你可能同时部署多个模型：小模型处理简单问答（快速、省 GPU），大模型处理复杂推理。pi-pods 支持在同一台服务器上运行多个模型，分配不同的 GPU 和端口。

部署多模型

# 4 块 A100：2 块给 Qwen-32B，2 块给 DeepSeek
pi start Qwen/Qwen2.5-32B-Instruct --name qwen --gpus 2    # 端口 8000
pi start deepseek-ai/DeepSeek-R1 --name deepseek --gpus 2   # 端口 8001

代码：04-multi-model-router.ts（核心逻辑）

// ① 模型注册表 —— 每个模型一个 vLLM 端点
const registry = [
  {
    model: createVllmModel("Qwen2.5-32B-Instruct", "http://gpu:8000/v1"),
    tags: ["chat", "code", "reasoning"],
    description: "通用 32B 模型",
  },
  {
    model: createVllmModel("Qwen2.5-Coder-32B", "http://gpu:8001/v1"),
    tags: ["code"],
    description: "代码专用模型",
  },
];

// ② 简单路由：根据关键词选择模型
function selectModel(question: string): ModelEntry {
  const codeKeywords = ["代码", "编程", "函数", "bug", "实现"];
  if (codeKeywords.some(k => question.includes(k))) {
    return registry.find(e => e.tags.includes("code"))!;
  }
  return registry[0]; // 默认通用模型
}

// ③ 使用
const entry = selectModel("用 Python 实现 LRU 缓存");
const reply = await completeSimple(entry.model, context, { apiKey: "not-needed" });

运行结果

═══════════════════════════════════════════════════
问题: 用 Python 实现一个简单的 LRU 缓存
路由 → Qwen2.5-32B-Instruct (通用 32B 模型)

回答:
class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = OrderedDict()
    def get(self, key):
        if key not in self.cache: return -1
        self.cache.move_to_end(key)
        return self.cache[key]
    ...

(tokens: 33 in / 399 out)

═══════════════════════════════════════════════════
问题: 分析一下：自托管 LLM 和云 API 各自的优劣？
路由 → Qwen2.5-32B-Instruct (通用 32B 模型)

回答: [详细的优劣对比分析...]

(tokens: 39 in / 709 out)

10. 成本对比与选型建议

详细成本计算

场景：团队 5 人，日均总消耗 2M Token

方案 A：Claude API
  输入: 1M × $15/M = $15/天
  输出: 1M × $75/M = $75/天
  月费: $90 × 30 = $2,700

方案 B：自托管 Qwen2.5-32B (2x A100)
  GPU 费用: $3.2/h × 10h/天 = $32/天
  月费: $32 × 22 (工作日) = $704

  节省: ($2,700 - $704) / $2,700 = 74%

选型决策树

你需要 LLM 服务
    │
    ├── 数据能发到外部吗？
    │   ├── 不能 → 自托管（pi-pods）
    │   └── 能 ─→ 日均 Token 消耗量？
    │               ├── < 10万 → 云 API（划算）
    │               ├── 10万~100万 → 看预算，都行
    │               └── > 100万 → 自托管（划算）
    │
    ├── 需要微调吗？
    │   ├── 是 → 自托管
    │   └── 否 → 看上面
    │
    └── 需要离线运行吗？
        ├── 是 → 自托管
        └── 否 → 看上面

GPU 提供商对比

提供商	A100 80GB 单价	优势	劣势
DataCrunch	~$1.6/h	欧洲节点，便宜	地区有限
RunPod	~$1.8/h	全球节点，界面好用	稍贵
Vast.ai	~$1.0/h	社区 GPU，最便宜	稳定性不如前两个
自有服务器	一次性购买	长期最便宜	前期投入大

11. 总结与回顾

本章核心概念

概念	一句话解释
pi-pods	GPU 服务器管家，一条命令部署模型
vLLM	高性能推理引擎，用 PagedAttention 提升吞吐
OpenAI 兼容 API	vLLM 暴露和 OpenAI 相同的接口，SDK 零修改
tensor parallel	一个模型拆到多块 GPU 上并行推理
Model 对象	pi-ai 中的模型配置，改 baseUrl 就能切换自托管

全系列回顾

走到这里，我们完整走了一遍 pi-mono 的七个核心包：

第 1 章 pi-ai         ← 统一 LLM API，一套代码调所有模型
第 2 章 pi-agent-core  ← 智能体运行时，工具 + 事件 + 状态
第 3 章 pi-tui         ← 终端 UI 框架，漂亮的命令行界面
第 4 章 pi-coding-agent ← 终端编程助手，AI 帮你写代码
第 5 章 pi-web-ui      ← 浏览器聊天组件，Web 端 AI 体验
第 6 章 pi-mom         ← Slack 智能体，常驻团队协作
第 7 章 pi-pods        ← GPU 服务器管理，自托管 LLM 部署  ← 你在这里

这七个包形成了一个完整的 AI 应用开发栈：

应用层:   pi-coding-agent / pi-mom / pi-web-ui   ← 直接面向用户
          ─────────────────────────────────────
框架层:   pi-agent-core（智能体）+ pi-tui（UI）  ← 构建应用的积木
          ─────────────────────────────────────
接口层:   pi-ai（统一 API）                       ← 屏蔽模型差异
          ─────────────────────────────────────
基础设施:  pi-pods（GPU 管理）+ vLLM              ← 模型运行的地基

pi-pods 是这个栈的地基——有了它，上层所有应用都可以从云 API 无缝切换到自托管模型。

练习题

连接测试：修改 01-connect-vllm.ts 中的 VLLM_BASE_URL，连接到你自己的 vLLM 服务器
成本计算：如果你的团队日均消耗 500K Token，计算使用 Claude API vs 自托管 Qwen2.5-32B 的月费差异
模型对比：用同一个问题分别调用不同模型（如本地 Qwen vs 云端 Claude），对比回答质量和速度
自动停机：写一个脚本，在每天 20:00 自动执行 pi stop 停止所有模型，节省 GPU 费用

可运行示例一览

文件	npm script	功能
`07-pi-pods/01-connect-vllm.ts`	`npm run 07:connect`	连接 vLLM，基础对话
`07-pi-pods/02-streaming-vllm.ts`	`npm run 07:stream`	流式输出
`07-pi-pods/03-tool-calling-vllm.ts`	`npm run 07:tools`	工具调用
`07-pi-pods/04-multi-model-router.ts`	`npm run 07:router`	多模型路由

运行方式：

cd examples
npm run 07:connect    # 基础连接
npm run 07:stream     # 流式输出
npm run 07:tools      # 工具调用
npm run 07:router     # 多模型路由

# 自定义 vLLM 地址
VLLM_BASE_URL=http://your-gpu:8000/v1 npm run 07:connect