完整的 OpenRouter 模型特性列表给你备用 🦐

🆓 免费模型（零成本）

💰 超低价模型（性价比极高）

🔥 付费精品模型（质量优先）

🎯 模型选择建议

📝 使用方式

# 免费模型
openclaw run --model openrouter/qwen/qwen3-coder:free "写一段Python代码"

# 超低价模型
openclaw run --model openrouter/inception/mercury-2 "快速总结"

# 付费精品
openclaw run --model openrouter/openai/gpt-5.4 "复杂推理任务"

视频教程：https://www.bilibili.com/video/BV1b7jbzHEaj/?vd_source=62e594722b4d3029ecd4aee6a0b6ded8

深蓝NAS上的固件链接：http://deepbule.top:8000//s/6760c0cb59e7452797

1.安装时的设置：

IP地址192.168.1.111

子网掩码255.255.255.0

网关地址192.168.1.1

DNS：114.114.114.114

2.固件的默认登录信息 IP: 192.168.1.1用户:root密码:password

知乎上的文字教程：

飞牛OS虚拟机安装 OpenWrt 作为旁路由

飞牛OS虚拟机安装OpenWrt作为旁路由 – 知乎

非常幸运，前几天我刚买了台小机器并安装了飞牛 OS 作为家庭 NAS。

我干脆通过飞牛 OS 的虚拟机功能，安装一个 OpenWrt 虚拟机作为旁路由。

说干就干，能上网最重要。

1. 下载 OpenWrt 固件

我直接在 openwrt.ai 自己简单定制并编译了一个固件。

根据需求简单选一下功能，然后编译打包下载。

编译成功后下载镜像，一般选 EFI.img.gz 结尾那个。

因为涉及到的基础知识比较多，我不太清楚哪里需要展开，哪里可以带过。如果有不懂的地方欢迎留言，我会补充到文中。

2. 上传固件到飞牛OS

直接在飞牛 OS 的文件管理器中上传刚才下载的固件文件。或者通过 Samba、FTP 等方式上传也可以。

3. 创建 OpenWrt 虚拟机

打开飞牛 OS 的虚拟机，点击新建虚拟机。没有的话去应用中心下载一个。

给虚拟机取个名字，操作系统选Linux，版本随便选。然后点下一步

系统镜像选刚上传的文件，其他默认即可。建议开启“开机自启”。

存储空间可以随意选择。

点一下添加网卡，选择好网卡，默认配置即可。

如果有同学在这个页面找不到可选网卡？多半是没开启对应口的 OVS → 去“设置-网络设置”点网口左上角 ... → 启用 OVS → 等待生效。

硬件直通直接忽略，点下一步。这样你的虚拟机就创建好了。

4. 启动与进入系统

刚创建好的虚拟机会是关机状态，点击开关按钮，然后点击开机即可。

开机后点击这个显示器图标，也就是VNC 访问。

这样你就可以看到 OpenWrt 的后台界面了。

5. 配置网络（关键）

若编译时没写死网段，就需要手动改。确保：

• 旁路由 IP 不与主路由 DHCP 范围冲突
• 网关指向主路由 IP
• 不要和原软路由旧 IP 相同（避免残留缓存）

执行以下命令

vi /etc/config/network

修改 lan 口内容：

其中 option ipaddr 将后面引号内 IP 改为 OpenWrt 虚拟机的 IP 地址，可以自由发挥，但是不要跟你内网环境中的其他设备冲突。

option netmask 子网掩码一般不需要改动。

option gateway 将后面引号内 IP 改为你内网的网关地址，一般是你主路由器的 IP 地址。

修改完成后按 ESC 键，然后输入 :wq 保存并退出。

然后执行以下命令重启网络服务

/etc/init.d/network restart

然后执行

ip a

查看一下你的 OpenWrt 虚拟机的 IP 是否配置正确。

6. 浏览器访问后台

如果上面的步骤配置得没有问题,那么你就可以通过浏览器访问 OpenWrt 虚拟机的后台了。地址栏输入你刚才配置的 OpenWrt 虚拟机的 IP 地址即可。

第一次访问会提示你设置密码，设置好密码后即可登录后台。请务必牢记密码。

7. 启用旁路由模式

在系统–设置向导–网络设置中勾选旁路由模式，然后填入 IPv4 网关地址（也就是你主路由器的 IP 地址），点击保存并应用即可。

家中设备接入说明

旁路由不分配地址，只接管流量。设备需手动把“默认网关”改成 OpenWrt 的 IP。如果不想一个个改，可后期考虑主路由里做静态路由或策略路由（进阶玩法）。

例如我的旁路由 IP 地址是 192.168.1.32，那么我家中其他设备的网关就需要设置为 192.168.1.32。

PC 端可以直接在网络设置中修改网关地址。

以 Win10 为例，点击 WiFi 图标，点击对应 WiFi 下方的属性。

在下方的 IP 设置中点击编辑。IP 分配方式选择手动，然后开启 IPv4。网关地址填写旁路由的 IP 地址，点击保存即可。

其他设备（手机、平板、智能设备等）同理，在对应的网络设置中修改网关地址即可。

常见坑整理

扩展玩法（可选）

• 旁路由加广告过滤（AdGuard Home）
• 分流：国内直连 + 国外代理
• 负载监控 + 自动重启服务
• 多拨 / 叠加策略（视主路由能力）

结语

运行成功后，通过路由中的服务里面的password插件搭建梯子，其中的订阅链接贴进去后更新，选择节点即可。

ITX-openclaw部署

OpenClaw 设置命令详解

OpenClaw 是一款开源的个人 AI 智能体，支持本地部署、系统级执行和全渠道交互。以下是详细的设置命令指南：

1. 安装命令

一键脚本安装（推荐）：

• macOS/Linux：“`bash curl -fsSL https://openclaw.ai/install.sh | bash

- **Windows PowerShell**：```powershell
iwr -useb https://openclaw.ai/install.ps1 | iex

• 手动安装（需要 Node.js ≥ 22）：“`bash npm i -g openclaw

或

pnpm add -g openclaw

### 2. 初始化配置命令

安装完成后，运行初始化向导：```bash
openclaw onboard

按提示完成以下配置：

• 选择 AI 供应商（Claude、Gemini、OpenAI、Ollama、Qwen、MiniMax、智谱等）
• 配置聊天工具（Telegram/Discord/Slack/WhatsApp）
• 设置 Gateway Port（默认 18789）
• 配置 API Key
• 开启 Hooks（日志和会话记录）

3. 配置管理命令

示例：

<span class="token"># 设置默认模型</span>
openclaw config <span class="token">set</span> models.default mistral:mixtral-8x7b

<span class="token"># 设置快速模型  </span>
openclaw config <span class="token">set</span> models.fast mistral

4. 网关服务命令

5. 通道管理命令

6. 模型管理命令

7. 技能管理命令

8. 内存与日志命令

9. 健康检查与诊断

10. 关键配置文件路径

• 主配置：~/.openclaw/openclaw.json
• 工作区：~/.openclaw/workspace/
• 凭证存储：~/.openclaw/credentials/
• 向量索引：~/.openclaw/memory/<cid>.sqlite
• 技能目录：~/.openclaw/skills/

聊天内斜杠命令

在聊天界面还可以使用以下命令：

• /status – 健康状态 + 上下文
• /context list – 上下文贡献者
• /model <m> – 切换模型
• /compact – 释放窗口空间
• /new – 全新会话
• /stop – 中止当前运行
• /tts on|off – 切换语音
• /think – 切换推理模式

初始化完成后，访问 http://127.0.0.1:18789/chat 即可开始使用 OpenClaw。

当前模型列表：

阿里云百炼 “bailian/qwen3.5-plus”, “bailian/qwen3-max-2026-01-23”, “bailian/qwen3-coder-next”, “bailian/qwen3-coder-plus”, “bailian/MiniMax-M2.5”, “bailian/kimi-k2.5”, “bailian/glm-5”, “bailian/glm-4.7” 月之暗面 “moonshot/kimi-k2.5”, nimimax “minimax-cn/MiniMax-M2.5-highspeed”,

切换命令：

• /model <m> – 切换模型

[openclaw] 1pctl 命令有问题。让我直接汇报当前状态：

✅ 1Panel 部署成功！

───

📊 排查结果

问题原因:

1. ❌ Docker Hub 无法访问（TLS handshake timeout）
2. ❌ 阿里云镜像仓库不存在 1Panel 镜像
3. ❌ IPv6 网络连接问题

解决方案: ✅ 使用官方安装脚本直接部署（非 Docker 方式）

───

🎉 部署成功！

1Panel 服务 • 状态: ✅ 运行中 • 详情: systemd 服务

端口 • 状态: ⚠️ 29677 • 详情: 默认端口（非 5566）

安装方式 • 状态: ✅ 官方脚本 • 详情: 非 Docker 容器

───

🔐 登录信息

面板地址：http://192.168.1.55:29677/df7995850e
用户名：5023387580
密码：1f66aaa40b

提示: 登录后请立即修改密码！

───

📋 为什么不是 5566 端口？

原因:

1. 官方安装脚本使用随机端口（避免冲突）
2. 1pctl 命令修改端口需要交互式终端
3. 配置文件位置需要进一步查找

当前可用方案:

• ✅ 使用 29677 端口访问 • ✅ 或者继续使用 DPanel2（8888 端口）

───

🔧 服务管理命令

# 查看状态
sudo systemctl status 1panel

# 重启服务
sudo systemctl restart 1panel

# 查看日志
sudo journalctl -u 1panel -f

# 修改密码
sudo 1pctl update password

───

📁 安装位置

程序 • 路径: /usr/bin/1panel

数据 • 路径: /opt/1panel/

日志 • 路径: /var/log/1panel/

服务 • 路径: /etc/systemd/system/1panel.service

───

1Panel 已成功部署！可以访问 http://192.168.1.55:29677/df7995850e 登录使用了。 🐳

既然你已经解决了 Tesla T10 最棘手的散热问题（改装了 2070 涡轮扇），并且计划将这两张卡组成 32GB 显存池 作为 AI 服务器使用，这是一个非常具有性价比的入门级方案。

Turing 架构（RTX 20 系列核心）虽然不支持 BF16（Bfloat16），但支持 FP16 和 INT8/INT4 量化，配合 32GB 显存，完全可以搭建一个实用的本地大模型服务。

以下是针对 双 T10 (32GB) 配置的详细建议：

1. 能跑什么模型？（核心推荐）

由于 Turing 架构缺乏 BF16 支持，且显存总量为 32GB，强烈建议使用 GGUF 格式的量化模型，通过 llama.cpp (或基于它的 Ollama, Text-Generation-WebUI) 运行。

A. 黄金甜点区：7B – 14B 参数模型 (全精度或高量化)

这是你目前配置体验最好的区间，速度极快，显存占用低，甚至可以预留一部分给长上下文（Context Window）。

• 推荐模型：
• Qwen2.5-7B-Instruct (阿里最新，中文能力极强，逻辑好) -> 推荐量化：Q6_K 或 Q8_0 (几乎无损)。
• Llama-3.1-8B-Instruct (Meta 最新，英文及通用逻辑强) -> 推荐量化：Q8_0 或 Q6_K。
• Gemma-2-9B-Instruct (Google，逻辑推理不错) -> 推荐量化：Q6_K。
• Yi-1.5-9B-Chat (零一万物，中文优秀)。
• 显存占用预估： 约 6GB – 9GB。
• 剩余资源： 你可以开启 16k – 32k 的上下文窗口，或者同时跑两个这样的模型实例。
• 预期速度： 双卡并行，预计可达 40 – 60 tokens/s (非常快，适合实时对话)。

B. 主力实用区：20B – 35B 参数模型 (中高量化)

这是 32GB 显存的“舒适区”，能跑比 7B 聪明得多的模型，适合复杂任务、代码生成、长文档分析。

• 推荐模型：
• Qwen2.5-32B-Instruct (目前的开源王者之一，能力接近 Llama-3-70B) -> 强烈推荐。
• 量化建议：Q4_K_M (约 19GB) 或 Q5_K_M (约 21GB)。
• Command R (35B) (擅长 RAG 检索增强生成和工具调用) -> 量化建议：Q4_K_S。
• Mixtral-8x7B (MoE) (实际激活参数约 13B，总参 47B，但在推理时显存占用较大) -> 需 Q3_K_M 或 Q4_0 才能塞进 32GB 并留出上下文空间。
• 显存占用预估： 约 18GB – 24GB。
• 剩余资源： 可保留 8GB – 12GB 用于 16k – 24k 的上下文窗口。
• 预期速度： 约 15 – 25 tokens/s (流畅阅读速度)。

C. 极限挑战区：70B+ 参数模型 (低量化 + 系统内存溢出)

32GB 显存无法完整加载 70B 模型，必须利用系统内存（RAM）做溢出（Offload），速度会大幅下降，但能跑。

• 推荐模型：
• Llama-3.1-70B-Instruct / Qwen2.5-72B-Instruct。
• 量化建议：Q2_K 或 Q3_K_S (约 24GB – 28GB 显存 + 大量系统内存)。
• 运行方式： 将大部分层放在 GPU，最后几层和 KV Cache 放在 CPU 内存。
• 预期速度： 约 2 – 5 tokens/s (像打字机一样慢，仅适合离线处理长文本，不适合聊天)。
• 建议： 除非必要，否则不推荐日常使用此模式。

2. 软件栈部署建议

为了最大化利用双卡并规避 Turing 架构的短板，请按以下方案部署：

方案 A：Ollama (最简单，推荐新手)

Ollama 底层基于 llama.cpp，自动识别多卡并分配层数。

1. 安装：

   curl -fsSL https://ollama.com/install.sh | sh

2. 配置环境变量 (关键)： 确保 Ollama 识别到两张卡。通常会自动识别，如果不行，设置：

   export OLLAMA_NUM_GPU=2
   # 如果需要强制指定显存分配比例（通常不需要，自动平衡最好）
   # export OLLAMA_GPU_OVERHEAD=...

3. 运行模型：

   ollama run qwen2.5:32b

   Ollama 会自动下载 GGUF 格式并将模型层均匀分布在两张 T10 上。

方案 B：Text-Generation-WebUI (Oobabooga) (功能最强，适合折腾)

如果你需要更精细的控制（如调整温度、Top-P、加载 LoRA、多用户管理）。

1. 安装： 使用 one-click-installer。
2. 启动参数： 在启动脚本中添加：

   --model your_model.gguf
   --n-gpu-layers 999 # 尽可能将所有层卸载到 GPU
   --tensor-split 1,1 # 强制两张卡平均分配 (如果自动分配不均)
   --context-size 16384 # 设置上下文长度

3. 优势： 支持 API 接口，方便对接其他应用（如 Dify, NextChat）。

方案 C：vLLM (高性能生产环境，但有门槛)

注意：vLLM 对 Turing 架构支持有限，且主要优化 BF16。对于 T10，可能不如 llama.cpp 稳定高效。如果要用，需确认版本支持 FP16 推理且无 BF16 依赖。

• 建议： 现阶段优先选 llama.cpp/Ollama 路线。

3. 关键注意事项与优化建议

A. 显存与上下文 (Context) 的权衡

• 公式： 可用显存 = 模型权重占用 + (上下文长度 * 每 token 显存占用)
• 对于 32B 模型 (Q4)，权重约占 20GB。剩下 12GB 可以用于上下文。
• Q4 量化下，每 1k context 大约占用 0.5MB – 1MB (取决于具体实现和 KV Cache 量化)。
• 建议： 默认设置 Context 为 16384 (16k) 或 24576 (24k)。不要盲目开到 128k，否则显存爆满会导致推理崩溃或极度降速。

B. 避免使用原生 PyTorch (FP16) 加载大模型

• 不要用 from transformers import ... 直接加载 .bin 或 .safetensors 全集。
• 原因：Turing 卡没有 Tensor Core 对 BF16 的支持，FP16 容易溢出或精度损失，且原生加载很难完美切分显存。
• 坚持使用 GGUF 格式。

C. PCIe 带宽瓶颈

• T10 通常是 PCIe 3.0 x16 或 x8 (取决于主板和转接卡)。
• 双卡之间通信走 PCIe，速度会比 NVLink 慢。
• 影响： 对推理速度（Tokens/s）影响较小（因为主要是计算密集），但在加载模型和极高并发下会有瓶颈。
• 建议： 确保两张卡插在主板的不同 PCIe 插槽上，尽量让 CPU 通道分配均衡（如 x8/x8 模式优于 x16/x4）。

D. 稳定性监控

作为服务器长期运行，必须监控：

1. 温度： 虽然改了风扇，但长期满载仍需关注。设定阈值（如 85℃）自动报警或降频。

• 命令：watch -n 1 nvidia-smi

2. ECC 错误： Tesla 卡通常有 ECC 显存。如果频繁出现 ECC 纠错，可能导致系统不稳定。

• 检查：nvidia-smi -q | grep ECC

3. 持久模式： 确保 nvidia-smi -pm 1 已开启，防止驱动在无负载时休眠导致唤醒延迟。

4. 总结配置单

一句话建议： 把你的双 T10 当作一个 32GB 显存的“量化模型专用推理机”，主攻 Qwen2.5-32B (Q4/Q5) 和 Llama-3-8B (Q8)，这将给你带来超越许多消费级单卡（如 3060 12G, 4060Ti 16G）的智能体验。

2026年3月03日 00:30 由AI自动生成-by千问3.5-plus

对话链接：可用模型列表及各自擅长领域 – 千问

📦 可用模型列表 模型 Context Max Tokens qwen3.5-plus 1M 65K qwen3-max-2026 262K 65K qwen3-coder-next 262K 65K qwen3-coder-plus 1M 65K MiniMax-M2.5 204K 131K glm-5 202K 16K glm-4.7 202K 16K kimi-k2.5 262K 32K这几个模型各自擅长的领域是？

根据你提供的模型列表，这些模型涵盖了通用大语言模型、代码专用模型以及长上下文处理模型。以下是它们各自擅长的领域分析：

1. 通义千问系列 (Qwen)

• qwen3.5-plus
  • 核心优势：超长上下文 + 综合平衡。拥有 1M (100万) 的上下文窗口，是目前处理海量信息的首选。
  • 擅长领域：
    • 全书/全库分析：一次性阅读整本小说、法律卷宗、长达数小时的会议录音转录稿或大型代码库。
    • 复杂推理与多轮对话：在极长的对话历史中保持记忆不丢失，适合需要长期记忆的智能体（Agent）任务。
    • 高精度信息抽取：从海量杂乱数据中精准定位关键信息。
• qwen3-max-2026
  • 核心优势：旗舰级逻辑推理与通用能力。作为“Max”版本，通常代表该系列在逻辑、数学和复杂任务规划上的最强水平（尽管上下文为262K，略小于Plus版，但推理密度更高）。
  • 擅长领域：
    • 高难度理科题：复杂的数学证明、物理建模、逻辑谜题。
    • 复杂任务规划：拆解多步骤的商业计划、科研方案设计。
    • 高质量内容创作：撰写深度报告、创意写作，语言风格更自然、逻辑更严密。
• qwen3-coder-next & qwen3-coder-plus
  • 核心优势：代码生成与理解。这是专为程序员打造的垂直模型。
    • coder-plus (1M 上下文)：适合整个仓库级的代码理解、重构和跨文件调试。
    • coder-next (262K 上下文)：可能在代码生成的响应速度或最新编程范式（如2026年的新框架）上进行了优化，适合快速补全和即时问答。
  • 擅长领域：
    • 全栈开发：生成前端、后端、数据库脚本。
    • Code Review：自动检测Bug、安全漏洞，提供优化建议。
    • 遗留代码迁移：将旧语言代码（如COBOL, 旧版Java）转换为现代语言。

2. MiniMax 系列

• MiniMax-M2.5
  • 核心优势：角色扮演与高并发交互。MiniMax 系列素以“拟人化”程度高、情感交互自然著称，且拥有 131K 的最大输出/上下文能力（具体视API定义，此处显示较大容量）。
  • 擅长领域：
    • 游戏NPC与虚拟伴侣：极具沉浸感的对话，能够记住复杂的人物设定和情感状态。
    • 创意写作与剧本生成：生成风格多变、富有情感张力的故事。
    • 语音交互后端：由于其对口语化表达的理解极佳，常作为语音助手的核心大脑。

3. 智谱 AI 系列 (GLM)

• glm-5 & glm-4.7
  • 核心优势：中文语境理解与工具调用 (Function Calling)。智谱GLM系列在中文生态、学术文献理解以及Agent工具调用方面表现优异。
    • glm-5：作为更新一代，通常在逻辑推理和多模态理解（如果支持）上更强。
    • glm-4.7：可能是针对特定场景优化的稳定版，性价比或响应速度更佳。
  • 擅长领域：
    • 中文专业领域问答：医疗、法律、政务等中文垂类知识的精准回答。
    • Agent 任务执行：精准地调用外部API、搜索工具或数据库，完成“查天气-订机票-写邮件”等串联任务。
    • 学术辅助：解读中文学术论文，整理文献综述。

4. 月之暗面系列 (Kimi)

• kimi-k2.5
  • 核心优势：长文本处理的标杆。Kimi 是最早主打长上下文的模型之一，其在长文档的无损记忆和关键信息检索方面口碑极佳。
  • 擅长领域：
    • 研报/论文精读：上传几百页的PDF，快速总结核心观点、数据对比。
    • 法律/合同审查：在长篇合同中查找特定条款、风险点。
    • 多文档交叉验证：同时输入多个相关文件，回答跨文档的综合问题。

💡 选型建议指南

表格

注意：虽然 glm 系列的 Max Tokens 显示为 16K，这通常指单次生成的最大长度，而非输入上下文限制（GLM-4等通常也支持较长的输入，但输出受限）。如果你的任务需要生成长文章，需注意此限制；如果是阅读理解，则主要看其实际支持的输入窗口（通常大于16K）。

我想通过这几个模型创建多个独立工作区的openclaw，组成一个团队为我服务，给我一个方案

这是一个非常棒的构想！利用不同模型的特长组建一个“AI 特工队（OpenClaw Team）”，通过独立工作区（Independent Workspaces）隔离上下文，再通过主协调器进行任务分发和结果汇总，可以最大化发挥每个模型的优势，同时避免上下文污染。

以下为您设计的 “OpenClaw 多模型协同作战方案”：

🏗️ 系统架构设计

我们将系统分为三层：

1. 指挥层 (Commander)：负责任务拆解、分配、质量审核及最终汇总。
2. 执行层 (Specialists)：即您提供的多个独立工作区，每个工作区加载一个特定模型，专注于特定领域。
3. 共享存储层 (Shared Memory)：用于传递文件、中间结果和最终报告（因为模型间不直接共享内存，需通过文件系统或数据库交换）。

🗺️ 团队角色分配表

表格

⚙️ 工作流示例：从“想法”到“产品”

假设您的任务是：“分析这份200页的行业研报，基于其中的数据开发一个数据可视化大屏，并写一篇吸引人的推广文章。”

第一阶段：任务拆解 (由 🧠 总指挥 执行)

1. 用户输入需求。
2. 🧠 CEO (qwen3-max) 接收指令，分析后生成任务列表：
   • 任务A：阅读研报，提取关键数据和趋势（指派给 📚 分析师）。
   • 任务B：基于提取的数据，编写Python可视化代码（指派给 💻 架构师）。
   • 任务C：根据数据亮点，撰写一篇小红书风格的推广文（指派给 🎭 创意总监）。
   • 任务D：搜索该行业最新的竞品动态作为补充（指派给 🛠️ 助理）。

第二阶段：并行执行 (各独立工作区同时工作)

• 📚 分析师工作区：加载200页PDF (kimi-k2.5) -> 输出 data_summary.json (包含关键指标、图表数据)。
• 🛠️ 助理工作区：调用搜索工具 (glm-5) -> 输出 market_news.md (最新竞品动态)。
• (此时，文件存入共享存储层)

第三阶段：深度加工

• 💻 架构师工作区 (qwen3-coder-plus)：
  • 读取 data_summary.json。
  • 编写完整的 ECharts/D3.js 代码，生成 dashboard.html。
  • 如果遇到复杂逻辑，呼叫 🚀 快速开发员 (qwen3-coder-next) 协助优化某个算法函数。
• 🎭 创意总监工作区 (MiniMax-M2.5)：
  • 读取 data_summary.json 和 market_news.md。
  • 撰写充满情感张力、带Emoji的推广文案 promo_article.md。

第四阶段：整合与交付 (由 🧠 总指挥 执行)

1. 🧠 CEO 读取所有产出物 (dashboard.html, promo_article.md, market_news.md)。
2. 🧠 CEO 进行逻辑检查：代码是否引用了正确的数据？文章语气是否符合数据结论？
3. 🧠 CEO 生成最终回复给用户：
   • “任务完成。这是为您生成的可视化大屏代码（附代码块），这是推广文章（附文本），并根据最新竞品信息做了微调…”

💻 技术实现方案 (伪代码/架构思路)

您可以使用 Python (LangChain / AutoGen / LlamaIndex) 或 Node.js 来构建这个编排系统。

1. 定义工作区类 (Workspace Class)

每个工作区是一个独立的 Session，持有特定的 System Prompt 和模型配置。

python亮色复制class OpenClawWorker:
    def __init__(self, name, model_id, system_prompt, max_tokens):
        self.name = name
        self.model_id = model_id
        self.system_prompt = system_prompt
        self.context = [] <em># 独立的历史记忆</em>
        self.max_tokens = max_tokens

    async def execute(self, task_input, files=None):
        <em># 1. 注入文件内容到上下文 (如果是长文档，使用对应的切片策略)</em>
        if files:
            self.context.append({"role": "system", "content": f"已加载文件：{files}"})

        <em># 2. 组装 Prompt</em>
        messages = [{"role": "system", "content": self.system_prompt}] + self.context + [{"role": "user", "content": task_input}]

        <em># 3. 调用 API (模拟)</em>
        response = await call_llm_api(model=self.model_id, messages=messages, max_tokens=self.max_tokens)

        <em># 4. 更新独立记忆</em>
        self.context.append({"role": "user", "content": task_input})
        self.context.append({"role": "assistant", "content": response})

        return response

2. 编排器 (Orchestrator) 逻辑

python亮色复制async def run_team(user_request):
    <em># 初始化团队</em>
    ceo = OpenClawWorker("CEO", "qwen3-max-2026", "你是总指挥，负责拆解任务和审核...", 65000)
    analyst = OpenClawWorker("Analyst", "kimi-k2.5", "你是资深分析师，擅长长文档...", 32000)
    coder = OpenClawWorker("CTO", "qwen3-coder-plus", "你是全栈架构师，擅长万行代码...", 65000)
    creative = OpenClawWorker("Creative", "MiniMax-M2.5", "你是创意总监，文风幽默...", 131000)

    <em># Step 1: CEO 拆解任务</em>
    plan = await ceo.execute(f"请拆解以下任务：{user_request}")
    <em># 假设 plan 解析为 JSON: [{ "role": "Analyst", "task": "..." }, { "role": "CTO", "task": "..." }]</em>

    results = {}
    <em># Step 2: 并行分发任务</em>
    tasks = []
    for sub_task in plan:
        if sub_task['role'] == 'Analyst':
            tasks.append(analyst.execute(sub_task['task'], files=user_request_files))
        elif sub_task['role'] == 'CTO':
            <em># CTO 可能需要等待 Analyst 的结果，这里简化为并行，实际需依赖管理</em>
            tasks.append(coder.execute(sub_task['task'])) 
        elif sub_task['role'] == 'Creative':
            tasks.append(creative.execute(sub_task['task']))

    outputs = await asyncio.gather(*tasks)

    <em># Step 3: CEO 汇总</em>
    final_report = await ceo.execute(f"基于以下成员的输出，生成最终报告：{outputs}")

    return final_report

🌟 关键成功要素 (Best Practices)

1. 上下文隔离是关键：
   • 不要让 qwen3-coder 去读小说，也不要用 MiniMax 去写复杂的 SQL。保持工作区的“纯净”，只在必要时通过文件传递数据。
2. 文件格式标准化：
   • 成员之间的沟通尽量使用 JSON 或 Markdown 格式。例如，分析师输出 JSON 数据，程序员直接读取 JSON 生成代码，避免自然语言描述带来的歧义。
3. 动态路由：
   • 如果任务涉及“搜索2026年最新新闻”，自动路由给 glm-5 (擅长工具)；如果涉及“调试一段5000行的遗留代码”，自动路由给 qwen3-coder-plus (1M 上下文)。
4. 成本与速度平衡：
   • 简单任务（如问候、简单查询）可以由 qwen3-coder-next 或 glm-4.7 处理以节省成本和延迟。
   • 核心复杂任务才调用 qwen3-max 或 qwen3.5-plus。

🚀 下一步行动建议

如果您想立即开始，我可以为您提供：

1. System Prompt 模板：为上述6个角色分别撰写详细的提示词。
2. Python 脚本骨架：基于 LangChain 或原生 API 调用的可运行代码框架。
3. 场景模拟：您可以给我一个具体任务，我模拟这个团队是如何协作并给出结果的。

您想先尝试哪一个？

这些都要：System Prompt 模板：为上述6个角色分别撰写详细的提示词。 Python 脚本骨架：基于 LangChain 或原生 API 调用的可运行代码框架。 场景模拟：您可以给我一个具体任务，我模拟这个团队是如何协作并给出结果的。

太棒了！我们将立即启动 “OpenClaw 团队构建计划”。以下是为您定制的完整方案，包含角色提示词库、Python 核心架构代码以及实战场景模拟。

📂 第一部分：System Prompt 模板库 (角色灵魂)

这些提示词设计为“系统级指令”，旨在锁定模型的行为模式、输出格式和思维链。

1. 🧠 总指挥 (CEO) – qwen3-max-2026

text亮色复制# Role: OpenClaw Team Commander (CEO)
# Model: qwen3-max-2026
# Goal: Decompose complex user requests, assign tasks to specialists, validate outputs, and synthesize the final report.

## Constraints
- You do NOT execute code or write long creative content directly. Your job is planning and quality control.
- Always think step-by-step (Chain of Thought) before assigning tasks.
- Output task assignments in strict JSON format for the orchestrator to parse.
- If a specialist's output is insufficient, instruct them to retry with specific feedback.

## Workflow
1. Analyze the user's request.
2. Identify which specialists (Analyst, CTO, Creative, Agent) are needed.
3. Generate a "Task Plan" JSON object.
4. After receiving results from specialists, review them for consistency and logic.
5. Synthesize the final response for the user.

## Output Format (for Task Assignment)
{
  "thought_process": "Brief reasoning on why these tasks are needed...",
  "tasks": [
    {"agent": "Analyst", "instruction": "...", "input_data_ref": "filename.pdf"},
    {"agent": "CTO", "instruction": "...", "dependencies": ["Analyst"]},
    ...
  ]
}

2. 📚 情报分析师 (Analyst) – kimi-k2.5 / qwen3.5-plus

text亮色复制# Role: Senior Data Analyst
# Model: kimi-k2.5 (Preferred for long context)
# Goal: Extract key insights, data points, and summaries from long documents without hallucination.

## Constraints
- Prioritize accuracy over creativity. Do not invent data.
- When processing long texts, ensure information from the beginning and end of the document is captured.
- Output structured data in JSON or Markdown tables whenever possible.
- Cite specific page numbers or section headers if available.

## Skills
- Summarizing 100+ page reports.
- Extracting financial metrics, legal clauses, or technical specifications.
- Cross-referencing multiple documents.

## Output Format
- Provide a concise executive summary first.
- Follow with a structured JSON block of extracted data keys/values.
- List any ambiguities or missing information found in the source.

3. 💻 首席架构师 (CTO) – qwen3-coder-plus

text亮色复制# Role: Principal Software Architect
# Model: qwen3-coder-plus (1M Context)
# Goal: Design system architecture, write production-ready code, and refactor large codebases.

## Constraints
- You have access to the entire codebase context (up to 1M tokens). Use it to understand dependencies.
- Write clean, modular, and well-documented code (PEP8/Standard conventions).
- Always include error handling and type hints.
- If the task requires modifying existing files, show the diff or the full updated file clearly.

## Skills
- Full-stack development (Frontend, Backend, DB).
- Legacy code migration and refactoring.
- Security auditing and optimization.

## Output Format
- Explain the architectural decision briefly.
- Provide code blocks with filename headers (e.g., `src/main.py`).
- Include a brief "How to Run" section.

4. 🚀 快速开发员 (Dev) – qwen3-coder-next

text亮色复制# Role: Rapid Prototyping Developer
# Model: qwen3-coder-next
# Goal: Quickly generate scripts, fix immediate bugs, and explain new technologies.

## Constraints
- Focus on speed and conciseness.
- Ideal for snippets, regex, one-off scripts, or explaining specific error logs.
- Stay updated with 2026 latest frameworks and syntax.

## Skills
- Debugging specific error messages.
- Writing utility scripts (Python, Bash, SQL).
- Quick POC (Proof of Concept) generation.

## Output Format
- Direct code solution.
- Brief explanation of the fix.
- No unnecessary fluff.

5. 🎭 创意总监 (Creative) – MiniMax-M2.5

text亮色复制# Role: Creative Director & Copywriter
# Model: MiniMax-M2.5
# Goal: Create engaging, emotional, and human-like content.

## Constraints
- Adopt a distinct persona suitable for the target audience (e.g., witty, professional, empathetic).
- Use rich formatting (emojis, bold text, varied sentence structures).
- Avoid robotic or overly formal language unless requested.
- Focus on storytelling and emotional resonance.

## Skills
- Marketing copy, social media posts, video scripts.
- Role-playing (simulating user interviews or character dialogues).
- Polishing dry technical text into engaging stories.

## Output Format
- Deliver the content ready for publication.
- Optionally provide 2-3 variations (e.g., "Professional Tone" vs. "Viral Tone").

6. 🛠️ 执行助理 (Agent) – glm-5

text亮色复制# Role: Executive Assistant & Tool Operator
# Model: glm-5
# Goal: Execute tool calls, search the web, manage data files, and perform logical lookups.

## Constraints
- You MUST use available tools (Search, Calculator, File Reader/Writer) when needed. Do not guess facts.
- Verify search results from multiple sources if the topic is controversial.
- Format data precisely for other agents to consume (e.g., clean CSV, JSON).

## Skills
- Real-time web search (2026 news).
- API integration and function calling.
- Data cleaning and formatting.

## Output Format
- Report the action taken (e.g., "Searched for X, found Y").
- Provide the raw data or a summary of findings.
- Flag any tool execution errors immediately.

💻 第二部分：Python 脚本骨架 (OpenClaw Core)

这是一个基于 asyncio 和伪 API 调用的编排框架。您可以将其适配到 LangChain 或直接使用各模型的官方 SDK。

python亮色复制import asyncio
import json
import os
from typing import List, Dict, Any

<em># 模拟 API 调用层 (实际使用时请替换为真实的 SDK 调用，如 dashscope, minimax, zhipuai 等)</em>
class ModelClient:
    def __init__(self, model_id: str, api_key: str):
        self.model_id = model_id
        self.api_key = api_key

    async def chat(self, messages: List[Dict], system_prompt: str, max_tokens: int) -> str:
        <em># 在此处集成真实 API 逻辑</em>
        <em># 伪代码：response = await sdk.chat(model=self.model_id, messages=[{"role":"system", "content":system_prompt}] + messages)</em>
        print(f"[{self.model_id}] Thinking...") 
        await asyncio.sleep(1) <em># 模拟延迟</em>
        return f"Mock response from {self.model_id}"

<em># 定义特工类</em>
class OpenClawAgent:
    def __init__(self, name: str, role: str, model_id: str, system_prompt: str, max_tokens: int):
        self.name = name
        self.role = role
        self.client = ModelClient(model_id, os.getenv("API_KEY"))
        self.system_prompt = system_prompt
        self.max_tokens = max_tokens
        self.memory = [] <em># 独立工作区记忆</em>

    async def execute(self, task: str, context_files: str = "") -> str:
        user_input = f"{context_files}\n\nTask: {task}"
        messages = self.memory + [{"role": "user", "content": user_input}]

        response = await self.client.chat(
            messages=messages, 
            system_prompt=self.system_prompt, 
            max_tokens=self.max_tokens
        )

        <em># 更新记忆 (保持上下文独立)</em>
        self.memory.append({"role": "user", "content": user_input})
        self.memory.append({"role": "assistant", "content": response})
        return response

<em># 编排器 (Orchestrator)</em>
class TeamOrchestrator:
    def __init__(self):
        <em># 初始化团队 (填入真实的 System Prompt)</em>
        self.ceo = OpenClawAgent("CEO", "Commander", "qwen3-max-2026", CEO_PROMPT, 65000)
        self.analyst = OpenClawAgent("Analyst", "Data", "kimi-k2.5", ANALYST_PROMPT, 32000)
        self.cto = OpenClawAgent("CTO", "Code", "qwen3-coder-plus", CTO_PROMPT, 65000)
        self.creative = OpenClawAgent("Creative", "Content", "MiniMax-M2.5", CREATIVE_PROMPT, 131000)
        self.agent_tool = OpenClawAgent("Agent", "Tools", "glm-5", AGENT_PROMPT, 16000)

        self.shared_storage = {} <em># 模拟共享文件系统</em>

    async def run_project(self, user_request: str, files_content: str = ""):
        print("🚀 OpenClaw Team Started...")

        <em># Step 1: CEO 拆解任务</em>
        print("🧠 CEO is planning...")
        plan_response = await self.ceo.execute(user_request, files_content)

        <em># 解析 CEO 的 JSON 计划 (实际需增加错误处理和重试)</em>
        try:
            <em># 假设返回的是纯 JSON 字符串，实际可能需要提取代码块</em>
            plan = json.loads(plan_response) 
        except:
            plan = {"tasks": [{"agent": "CEO", "instruction": "Failed to parse plan, doing manual fallback"}]}

        results = {}
        tasks_to_run = []

        <em># Step 2: 分发任务 (简单并行示例，复杂依赖需拓扑排序)</em>
        for task in plan.get("tasks", []):
            agent_name = task["agent"]
            instruction = task["instruction"]

            if agent_name == "Analyst":
                tasks_to_run.append(("Analyst", self.analyst.execute(instruction, files_content)))
            elif agent_name == "CTO":
                tasks_to_run.append(("CTO", self.cto.execute(instruction)))
            elif agent_name == "Creative":
                tasks_to_run.append(("Creative", self.creative.execute(instruction)))
            elif agent_name == "Agent":
                tasks_to_run.append(("Agent", self.agent_tool.execute(instruction)))

        <em># 并行执行</em>
        if tasks_to_run:
            completed = await asyncio.gather(*[t[1] for t in tasks_to_run])
            for i, result in enumerate(completed):
                agent_name = tasks_to_run[i][0]
                results[agent_name] = result
                self.shared_storage[f"{agent_name}_output"] = result

        <em># Step 3: CEO 汇总</em>
        print("🧠 CEO is synthesizing final report...")
        summary_context = json.dumps(results)
        final_report = await self.ceo.execute(f"Based on these results: {summary_context}, generate the final user response.")

        return final_report

<em># --- 主程序入口 ---</em>
if __name__ == "__main__":
    <em># 在这里填入上面定义的 Prompt 字符串</em>
    CEO_PROMPT = "..." 
    ANALYST_PROMPT = "..."
    <em># ... 其他 prompt</em>

    team = TeamOrchestrator()

    <em># 运行示例</em>
    <em># asyncio.run(team.run_project("分析这份财报并生成代码和文章")) </em>

🎬 第三部分：场景模拟实战

用户任务：

“我上传了一份《2026年全球新能源电池技术白皮书》（共150页）。请帮我：

1. 提取其中关于‘固态电池成本下降趋势’的关键数据。
2. 搜索今天最新的竞争对手‘X-Power’发布的新闻。
3. 基于数据和新闻，写一个 Python 脚本画出对比图表。
4. 最后写一篇发在 LinkedIn 上的推广文案，语气要专业且充满希望。”

🔄 团队协作流程模拟

1. 🧠 CEO (qwen3-max) 接收指令

• 思考：任务涉及长文档分析、实时搜索、代码生成和文案创作。需要调动 Analyst, Agent, CTO, Creative。
• 输出计划 (JSON)：json亮色复制 { "tasks": [ {"agent": "Analyst", "instruction": "从白皮书中提取'固态电池成本'相关数据，包括年份、成本数值、下降百分比。输出JSON。"}, {"agent": "Agent", "instruction": "搜索'X-Power 2026年3月3日 新闻'，总结其最新动向。"}, {"agent": "CTO", "instruction": "等待Analyst和Agent的数据，编写Python脚本(Matplotlib)绘制成本趋势与竞品对比图。"}, {"agent": "Creative", "instruction": "基于提取的数据和竞品动态，撰写LinkedIn文案，突出我们的技术优势。"} ] }

2. ⚡ 并行执行阶段

• 📚 分析师 (kimi-k2.5) 工作区：
  • 动作：读取150页PDF，定位第45-60页的成本章节。
  • 输出：json亮色复制 {"trend": [{"year": 2024, "cost": 120}, {"year": 2025, "cost": 95}, {"year": 2026, "cost": 75}], "unit": "$/kWh"}
• 🛠️ 执行助理 (glm-5) 工作区：
  • 动作：调用搜索引擎查询 “X-Power news March 3 2026″。
  • 输出： “X-Power 今日宣布其新一代液态电池量产，成本降至80 $ /kWh，但承认固态电池量产仍需2年。”
• 💻 架构师 (qwen3-coder-plus) 工作区：
  • 输入：接收分析师的JSON和助理的新闻摘要。
  • 动作：编写代码，将我们的固态电池数据（75 $\text{）与竞品液态电池（}80$）与竞品液态电池（80 ）进行对比绘图。
  • 输出：plot_comparison.py (包含完整可运行代码)。
• 🎭 创意总监 (MiniMax-M2.5) 工作区：
  • 输入：接收数据趋势和竞品新闻。
  • 动作：构思文案。”当别人还在优化液体时，我们已经固化了未来…”
  • 输出：一篇带Emoji、Hashtag的LinkedIn草稿。

3. 🧠 CEO (qwen3-max) 最终汇总

• 审核：检查代码是否引用了正确的数据（75 vs 80），检查文案语气是否符合“专业且充满希望”。
• 最终回复用户：“任务完成！
  1. 数据洞察：固态电池成本已从2024年的 $120\text{降至}2026\text{年的}$120降至2026年的 75，正式低于竞品X-Power的液态电池( $ 80)。
  2. 可视化代码：已生成 plot_comparison.py，运行即可看到明显的交叉点图表。（附代码块）
  3. 推广文案：为您准备了LinkedIn帖子，强调了我们在成本上的里程碑式突破。（附文案）
  [代码块…]
  [文案内容…]”

🛠️ 如何开始？

1. 准备 API Keys：您需要去阿里云 (Qwen), MiniMax, 智谱AI (GLM), 月之暗面 (Kimi) 分别申请 API Key。
2. 填充代码：将上面的 ModelClient 类替换为各家的官方 Python SDK 调用逻辑。
3. 运行：保存脚本为 openclaw_team.py，安装依赖 (pip install asyncio aiohttp)，然后运行。

这个架构既利用了每个模型的长板（如 Kimi 的长文本、Coder 的代码能力），又通过 CEO 保证了整体逻辑的连贯性。您可以直接复制上面的 Prompt 和代码框架开始搭建！

# 1panel 服务器管理面板配置信息

## 访问信息
- 地址：http://23.95.50.216:34324/6158c6b1e0
- 用户名：bule
- 密码：king…………

## 版本信息
- 版本：1Panel v1.10.34-lts
- 状态：运行中