@clawhub-yang1002378395-cmyk-035b3c7544
Configure a Telegram Bot with OpenClaw in 10 minutes to enable free, worldwide AI messaging with command, group, and webhook support.
# OpenClaw Telegram Setup
10 分钟配置 Telegram Bot 作为 OpenClaw 消息渠道。
## 为什么选 Telegram？
- **免费无限制**：消息、文件、多媒体全免费
- **API 开放**：Bot API 简单易用
- **全球可用**：无地域限制
- **功能强大**：支持命令、按钮、Inline 查询
## 快速配置
### Step 1: 创建 Bot
1. 在 Telegram 搜索 `@BotFather`
2. 发送 `/newbot`
3. 按提示设置 Bot 名称
4. 保存返回的 **Token**（格式：`123456789:ABCdefGHI...`）
### Step 2: 获取 Chat ID
```bash
# 方法 1：用你的 Bot 发条消息，然后访问
https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates
# 方法 2：用 @userinfobot 获取你的 ID
```
### Step 3: 配置 OpenClaw
编辑 `~/.openclaw/config.yaml`:
```yaml
plugins:
entries:
- plugin: openclaw-telegram
config:
botToken: "123456789:ABCdefGHI..."
allowedChatIds:
- 123456789 # 你的 Chat ID
```
### Step 4: 启动 Gateway
```bash
openclaw gateway start
```
### Step 5: 测试
在 Telegram 向你的 Bot 发送消息，应该收到 AI 回复。
## 高级功能
### 群组支持
```yaml
plugins:
entries:
- plugin: openclaw-telegram
config:
botToken: "xxx"
allowedChatIds:
- 123456789 # 个人
- -100123456789 # 群组（负数）
```
### 命令支持
在 BotFather 设置命令：
```
/setcommands
help - 获取帮助
status - 检查状态
clear - 清除对话
```
### Webhook 模式（需要公网服务器）
```yaml
plugins:
entries:
- plugin: openclaw-telegram
config:
botToken: "xxx"
webhook:
url: "https://your-domain.com/telegram/webhook"
port: 8443
```
## 常见问题
### Q: Bot 不回复
A: 检查 Chat ID 是否正确（正数是个人，负数是群组）
### Q: 提示 "Forbidden: bot was blocked by the user"
A: 你可能之前屏蔽了 Bot，需要先解除屏蔽
### Q: 群组消息无响应
A: 确保 Bot 在群组中，且有读取消息权限
## 成本
- Telegram Bot API：**完全免费**
- OpenClaw Gateway：本地运行，无费用
- AI 模型：按使用量计费（DeepSeek 最便宜）
## 需要帮助？
- 微信：yanghu_ai
- Telegram: @yanghu_openclaw
- 免费远程配置（首次）
---
Version: 1.0.0
Created: 2026-03-21
FILE:package.json
{
"name": "openclaw-telegram-setup",
"version": "1.0.0",
"description": "10-minute Telegram Bot setup for OpenClaw",
"keywords": ["telegram", "openclaw", "bot", "messaging", "setup"],
"author": "OpenClaw CN Team"
}
Quickly configure DeepSeek V3 as the AI model for OpenClaw with API key setup, cost-effective Chinese optimization, and optional streaming or temperature tun...
# DeepSeek Quick Config for OpenClaw
5 分钟配置 DeepSeek V3 作为 OpenClaw 的 AI 模型。
## 为什么选 DeepSeek？
- **性价比最高**：¥0.27/百万 input tokens vs GPT-4o ¥35/百万
- **性能强劲**：接近 GPT-4 水平
- **中文优化**：国产模型，中文理解更好
- **无需 VPN**：国内直连，速度快
## 快速配置
### Step 1: 获取 API Key
1. 访问 https://platform.deepseek.com/
2. 注册/登录
3. 进入 API Keys 页面
4. 创建新 Key
### Step 2: 配置 OpenClaw
```bash
# 方法 1：命令行配置
openclaw configure --section models
# 选择 DeepSeek，粘贴 API Key
```
或编辑 `~/.openclaw/config.yaml`:
```yaml
models:
default: deepseek-chat
providers:
deepseek:
apiKey: sk-xxxxxxxx
baseURL: https://api.deepseek.com/v1
```
### Step 3: 测试连接
```bash
openclaw chat "你好，介绍一下你自己"
```
## 成本对比
| 模型 | Input (¥/百万) | Output (¥/百万) | 相对成本 |
|------|---------------|-----------------|---------|
| DeepSeek V3 | ¥0.27 | ¥1.08 | 1x |
| GPT-4o mini | ¥1.05 | ¥4.20 | 4x |
| Claude Haiku | ¥0.63 | ¥3.15 | 3x |
| GPT-4o | ¥35.00 | ¥105.00 | 130x |
| Claude Sonnet | ¥21.00 | ¥105.00 | 97x |
## 常见问题
### Q: 提示 "API key invalid"
A: 检查 Key 是否正确复制，没有多余空格
### Q: 响应很慢
A: 深度思考模式 (deepseek-reasoner) 会慢一些，日常用 deepseek-chat
### Q: 想用 R1 深度思考？
A: 把模型名改成 `deepseek-reasoner`
## 高级配置
### 启用流式输出
```yaml
models:
providers:
deepseek:
stream: true
```
### 自定义温度
```yaml
models:
providers:
deepseek:
temperature: 0.7 # 0-2，默认 1
```
## 需要帮助？
- 微信：yanghu_ai
- Telegram: @yanghu_openclaw
---
Version: 1.0.0
Created: 2026-03-21
FILE:package.json
{
"name": "deepseek-quick-config",
"version": "1.0.0",
"description": "5-minute DeepSeek V3 configuration for OpenClaw",
"keywords": ["deepseek", "openclaw", "chinese", "ai", "config"],
"author": "OpenClaw CN Team"
}
快速收集客户需求，生成OpenClaw配置方案，创建客户档案并发送报价单，实现付费客户自动化 onboarding。
# OpenClaw Client Onboarding
快速为付费客户配置 OpenClaw 的自动化流程。
## 用途
当你接到 OpenClaw 安装/配置订单时，使用此 Skill 快速：
1. 收集客户需求（AI 模型、消息渠道、预算）
2. 生成配置模板
3. 创建客户档案
4. 发送报价单
## 使用方法
```
客户下单 OpenClaw 配置服务
→ 运行此 Skill
→ 自动收集信息并生成配置方案
```
## 工作流程
### Step 1: 收集客户信息
向客户询问：
- **AI 模型偏好**: DeepSeek / GLM-5 / Qwen / GPT / Claude
- **消息渠道**: Telegram / Discord / WeChat / Feishu / DingTalk
- **预算范围**: ¥99-299 / ¥299-999 / ¥999+
- **主要用途**: 个人助手 / 客服 / 自动化 / 其他
### Step 2: 生成配置方案
根据客户回答，生成：
- 推荐的 AI 模型配置
- 消息渠道配置
- 自定义 Skills 推荐
- 报价单
### Step 3: 创建客户档案
在 `clients/{客户名}/` 创建：
- `config.json` - 配置文件
- `notes.md` - 客户备注
- `invoice.md` - 报价单
## 定价参考
| 套餐 | 价格 | 包含服务 |
|------|------|----------|
| 基础 | ¥99 | 单渠道 + 基础配置 |
| 高级 | ¥299 | 多渠道 + 3 个 Skills |
| 企业 | ¥999 | 全渠道 + 10 个 Skills + 远程培训 |
## 文件结构
```
workspace/
├── skills/
│ └── openclaw-client-onboarding/
│ └── SKILL.md
└── clients/
└── {客户名}/
├── config.json
├── notes.md
└── invoice.md
```
## 联系方式
- WeChat: yanghu_ai
- Telegram: @yanghu_openclaw
- Email: [email protected]
---
Version: 1.0.0
Created: 2026-03-21
Author: OpenClaw CN Team
FILE:package.json
{
"name": "openclaw-client-onboarding",
"version": "1.0.0",
"description": "OpenClaw client onboarding automation for Chinese market",
"keywords": ["openclaw", "business", "chinese", "onboarding"],
"author": "OpenClaw CN Team"
}
OpenClaw 成本计算器 - 精确计算 OpenClaw + AI 模型的完整使用成本，对比不同模型组合，优化支出。适合：个人用户、企业用户、成本优化。
---
name: openclaw-cost-calculator
version: 1.0.0
description: |
OpenClaw 成本计算器 - 精确计算 OpenClaw + AI 模型的完整使用成本，对比不同模型组合，优化支出。适合：个人用户、企业用户、成本优化。
metadata:
openclaw:
emoji: "💰"
version: 1.0.0
requires:
bins: ["curl"]
---
# OpenClaw 成本计算器
**目标**：精确计算 OpenClaw 使用的完整成本，帮你选择最优模型组合，省钱 50-90%。
---
## 🎯 快速计算
### 场景 1：个人日常使用
**需求**：每天 50 轮对话，每轮 1000 tokens 输入 + 500 tokens 输出
**计算**：
```
每日输入：50 × 1000 = 50,000 tokens
每日输出：50 × 500 = 25,000 tokens
每月使用：1,500,000 输入 + 750,000 输出
GPT-4o 成本：
输入：1.5M × $2.5/1M = $3.75
输出：0.75M × $10/1M = $7.50
月费用：$11.25 ≈ ¥80
DeepSeek V3 成本：
输入：1.5M × ¥1/1M = ¥1.5
输出：0.75M × ¥2/1M = ¥1.5
月费用：¥3 ≈ $0.42
节省：$10.83/月（96%）
```
### 场景 2：企业客服机器人
**需求**：每天 1000 次咨询，每次 800 tokens 输入 + 400 tokens 输出
**计算**：
```
每日输入：1000 × 800 = 800,000 tokens
每日输出：1000 × 400 = 400,000 tokens
每月使用：24M 输入 + 12M 输出
Claude 3.5 Sonnet 成本：
输入：24M × $3/1M = $72
输出：12M × $15/1M = $180
月费用：$252 ≈ ¥1,800
GLM-4 成本：
输入：24M × ¥10/1M = ¥240
输出：12M × ¥10/1M = ¥120
月费用：¥360 ≈ $50
节省：$202/月（80%）
```
### 场景 3：内容创作
**需求**：每天写 10 篇文章，每篇 3000 tokens 输入 + 2000 tokens 输出
**计算**：
```
每日输入：10 × 3000 = 30,000 tokens
每日输出：10 × 2000 = 20,000 tokens
每月使用：900K 输入 + 600K 输出
GPT-4o 成本：
输入：0.9M × $2.5/1M = $2.25
输出：0.6M × $10/1M = $6.00
月费用：$8.25 ≈ ¥60
DeepSeek V3 成本：
输入：0.9M × ¥1/1M = ¥0.9
输出：0.6M × ¥2/1M = ¥1.2
月费用：¥2.1 ≈ $0.30
节省：$7.95/月（96%）
```
---
## 📊 模型价格对比（2026-03）
| 模型 | 输入价格 | 输出价格 | 优势 | 劣势 |
|------|----------|----------|------|------|
| **DeepSeek V3** | ¥1/1M | ¥2/1M | 最便宜，中文强 | 需要国内网络 |
| **GLM-4** | ¥10/1M | ¥10/1M | 国产，稳定 | 价格中等 |
| **Qwen-Max** | ¥20/1M | ¥20/1M | 阿里云生态 | 价格偏高 |
| **GPT-4o-mini** | $0.15/1M | $0.6/1M | 性价比高 | 需要 VPN |
| **Claude 3 Haiku** | $0.25/1M | $1.25/1M | 快速便宜 | 需要 VPN |
| **GPT-4o** | $2.5/1M | $10/1M | 多模态强 | 价格贵 |
| **Claude 3.5 Sonnet** | $3/1M | $15/1M | 编程最强 | 价格贵 |
**省钱建议**：
- **日常使用**：DeepSeek V3（96% 节省）
- **企业应用**：GLM-4（稳定 + 合规）
- **编程任务**：Claude 3 Haiku（便宜 + 强）
- **复杂推理**：Claude 3.5 Sonnet（贵但强）
---
## 🔧 OpenClaw 配置优化
### 配置 1：成本优先（DeepSeek）
```yaml
models:
default: deepseek-chat
fallback: glm-4
providers:
deepseek:
apiKey: "sk-xxx"
baseUrl: "https://api.deepseek.com/v1"
zhipu:
apiKey: "xxx"
model: "glm-4"
```
**预期成本**：¥2-5/月（个人使用）
### 配置 2：性能优先（Claude + DeepSeek）
```yaml
models:
default: claude-3-5-sonnet-20241022
reasoning: deepseek-reasoner
fallback: glm-4
providers:
anthropic:
apiKey: "sk-ant-xxx"
deepseek:
apiKey: "sk-xxx"
zhipu:
apiKey: "xxx"
```
**预期成本**：$5-15/月（混合使用）
### 配置 3：企业稳定（GLM-4）
```yaml
models:
default: glm-4
reasoning: glm-4-plus
providers:
zhipu:
apiKey: "xxx"
model: "glm-4"
```
**预期成本**：¥50-200/月（企业使用）
---
## 💰 ROI 计算器
### 个人用户
**投入**：
- OpenClaw 安装：免费（DIY）或 ¥99（服务）
- 模型成本：¥2-10/月
**回报**：
- 时间节省：2-4 小时/天 × ¥100/小时 = ¥200-400/天
- 月回报：¥6000-12000
- **ROI：600-6000 倍**
### 企业用户
**投入**：
- OpenClaw 企业版：¥299（配置服务）
- 模型成本：¥50-500/月
**回报**：
- 客服自动化：节省 1 个客服 × ¥5000/月
- 文档自动化：节省 10 小时/周 × ¥100/小时 = ¥4000/月
- 月回报：¥9000+
- **ROI：18-180 倍**
---
## 🎯 优化建议
### 建议 1：混合使用
**策略**：
- 80% 简单任务 → DeepSeek V3（最便宜）
- 15% 中等任务 → GLM-4（稳定）
- 5% 复杂任务 → Claude 3.5 Sonnet（最强）
**预期节省**：70-90%
### 建议 2：缓存优化
**策略**：
- 启用 OpenClaw 上下文缓存
- 减少重复 prompt 成本
- 缓存命中可节省 90% 输入成本
### 建议 3：批量处理
**策略**：
- 合并多个小请求为一个大请求
- 减少 API 调用次数
- 批量处理可节省 20-30%
---
## 📋 成本监控
### 配置成本追踪
在 OpenClaw 配置中启用成本追踪：
```yaml
tracking:
enabled: true
alerts:
daily: 10 # 日成本超过 ¥10 提醒
monthly: 200 # 月成本超过 ¥200 提醒
```
### 查看成本报告
```
显示本月 OpenClaw 成本报告
```
OpenClaw 会返回：
- 总成本
- 按模型分类成本
- 按日期成本趋势
- 优化建议
---
## 💰 定价参考
- **基础计算器**：免费（本 Skill）
- **成本优化咨询**：¥299（一对一分析 + 配置优化）
- **企业成本审计**：¥999（完整审计 + 优化方案 + 实施指导）
---
## 🆘 获取帮助
- **OpenClaw 文档**：https://docs.openclaw.ai
- **OpenClaw 社区**：https://discord.com/invite/clawd
- **DeepSeek 文档**：https://platform.deepseek.com/docs
- **智谱 GLM 文档**：https://open.bigmodel.cn/dev/api
---
**创建时间**：2026-03-21
**作者**：OpenClaw 中文生态
**版本**：1.0.0
FILE:skill.json
{
"name": "openclaw-cost-calculator",
"version": "1.0.0",
"description": "OpenClaw 成本计算器 - 精确计算 OpenClaw + AI 模型的完整使用成本，对比不同模型组合，优化支出",
"author": "yang1002378395-cmyk",
"license": "MIT",
"keywords": ["openclaw", "cost", "calculator", "ai", "pricing", "chinese"]
}企业微信快速集成配置 - 5分钟连接 OpenClaw 与企业微信，解锁群机器人、应用消息、客户管理。适合：企业用户、微信生态、客户服务。
---
name: wecom-quickstart-cn
version: 1.0.0
description: |
企业微信快速集成配置 - 5分钟连接 OpenClaw 与企业微信，解锁群机器人、应用消息、客户管理。适合：企业用户、微信生态、客户服务。
metadata:
openclaw:
emoji: "企"
version: 1.0.0
requires:
bins: ["curl"]
---
# 企业微信快速集成配置
**目标**：5 分钟内完成 OpenClaw + 企业微信集成，开始自动化办公。
---
## 🚀 快速开始（3 步）
### 第一步：创建企业微信应用
1. 登录 [企业微信管理后台](https://work.weixin.qq.com/wework_admin/frame)
2. 应用管理 → 自建应用 → 创建应用
3. 填写信息：
- **应用名称**：OpenClaw Assistant
- **应用logo**：自定义或默认
- **可见范围**：选择部门/人员
4. 创建后记录：
- `AgentId`
- `Secret`
### 第二步：获取企业凭证
在「我的企业」页面获取：
- `CorpId` - 企业 ID
- 在「客户联系」→「API」获取 `Customer Secret`（可选，用于客户管理）
### 第三步：配置 OpenClaw
在 OpenClaw 配置文件 `~/.openclaw/config.yml` 添加：
```yaml
channels:
wecom:
enabled: true
corpId: "wx1234567890abcdef" # 企业 ID
agentId: 1000001 # 应用 AgentId
secret: "xxxxxxxxxxxxxxxxxxxxxxxx" # 应用 Secret
```
然后重启 OpenClaw：
```bash
openclaw gateway restart
```
---
## ✅ 验证集成
在 OpenClaw 对话中测试：
```
发送企业微信消息到用户 @user_id：测试成功，OpenClaw 已连接！
```
如果企业微信收到消息，集成完成！
---
## 📋 常见使用场景
### 场景 1：群机器人消息推送
**指令**：
```
发送企业微信群消息：项目进度更新：完成 80%
```
**OpenClaw 会自动**：
1. 调用群机器人 Webhook
2. 发送 Markdown 格式消息
3. 支持 @指定成员
### 场景 2：客户服务自动化
**指令**：
```
监控企业微信客户消息，自动回复常见问题
```
**OpenClaw 会自动**：
1. 接收客户消息
2. 匹配知识库
3. 发送智能回复
### 场景 3：审批流程集成
**指令**：
```
当有新审批时，发送企业微信通知给审批人
```
**OpenClaw 会自动**：
1. 监控审批状态
2. 推送通知给相关人员
3. 记录审批日志
---
## 🔧 高级配置
### 群机器人配置
在企业微信群中添加群机器人：
```yaml
channels:
wecom:
enabled: true
corpId: "wx1234567890abcdef"
agentId: 1000001
secret: "xxx"
groupBots:
- name: "开发群"
webhook: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx"
- name: "运维群"
webhook: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=yyy"
```
### 多应用支持
如果需要管理多个应用：
```yaml
channels:
wecom:
enabled: true
corpId: "wx1234567890abcdef"
apps:
- name: "OpenClaw Assistant"
agentId: 1000001
secret: "xxx"
- name: "HR Bot"
agentId: 1000002
secret: "yyy"
```
---
## 🐛 故障排查
### 问题 1：消息发送失败
**错误**：`invalid corpId or secret`
**解决**：
1. 检查 CorpId 是否正确（「我的企业」页面）
2. 检查 Secret 是否正确（应用详情页）
3. 确认应用已发布且可见范围正确
### 问题 2：群机器人无法推送
**错误**：`webhook url invalid`
**解决**：
1. 检查 Webhook URL 格式
2. 确认机器人未被删除
3. 测试 URL 可达性：
```bash
curl -X POST "YOUR_WEBHOOK_URL" \
-H "Content-Type: application/json" \
-d '{"msgtype":"text","text":{"content":"测试"}}'
```
### 问题 3：客户消息接收失败
**错误**：`no callback url`
**解决**：
1. 在企业微信后台配置回调 URL
2. 设置可信域名
3. 启用客户联系 API
---
## 📚 企业微信 API 参考
### 应用消息发送
```bash
POST https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=ACCESS_TOKEN
{
"touser": "UserID",
"msgtype": "text",
"agentid": 1000001,
"text": {
"content": "这是一条应用消息"
}
}
```
### 群机器人消息
```bash
POST https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=KEY
{
"msgtype": "markdown",
"markdown": {
"content": "### 标题\n**粗体**\n- 列表项"
}
}
```
---
## 💰 定价参考
- **基础集成**：¥99（应用创建 + 消息发送）
- **企业定制**：¥299（群机器人 + 客户管理 + 自动化）
- **全托管服务**：¥999/月（OpenClaw 托管 + 企业微信集成 + 技术支持）
---
## 🆘 获取帮助
- **企业微信开发文档**：https://developer.work.weixin.qq.com/document
- **OpenClaw 文档**：https://docs.openclaw.ai
- **OpenClaw 社区**：https://discord.com/invite/clawd
---
**创建时间**：2026-03-21
**作者**：OpenClaw 中文生态
**版本**：1.0.0
FILE:skill.json
{
"name": "wecom-quickstart-cn",
"version": "1.0.0",
"description": "企业微信快速集成配置 - 5分钟连接 OpenClaw 与企业微信，解锁群机器人、应用消息、客户管理",
"author": "yang1002378395-cmyk",
"license": "MIT",
"keywords": ["wecom", "weixin", "enterprise", "robot", "chinese", "openclaw"]
}钉钉快速集成配置 - 5分钟连接 OpenClaw 与钉钉，解锁机器人消息、审批流程、智能办公。适合：企业用户、钉钉生态、国内企业。
---
name: dingtalk-quickstart-cn
version: 1.0.0
description: |
钉钉快速集成配置 - 5分钟连接 OpenClaw 与钉钉，解锁机器人消息、审批流程、智能办公。适合：企业用户、钉钉生态、国内企业。
metadata:
openclaw:
emoji: "钉"
version: 1.0.0
requires:
bins: ["curl"]
---
# 钉钉快速集成配置
**目标**：5 分钟内完成 OpenClaw + 钉钉集成，开始自动化办公。
---
## 🚀 快速开始（3 步）
### 第一步：创建钉钉机器人
1. 打开钉钉群 → 群设置 → 智能群助手 → 添加机器人
2. 选择「自定义」机器人
3. 填写信息：
- **机器人名称**：OpenClaw Assistant
- **机器人头像**：自定义或默认
4. 安全设置（三选一）：
- **推荐**：加签（Secret）— 最安全
- IP 地址（白名单）
- 自定义关键词
5. 创建后记录：
- `Webhook URL`
- `Secret`（如果选择了加签）
### 第二步：配置 OpenClaw
在 OpenClaw 配置文件 `~/.openclaw/config.yml` 添加：
```yaml
channels:
dingtalk:
enabled: true
webhook: "https://oapi.dingtalk.com/robot/send?access_token=xxx"
secret: "SECxxx" # 可选，加签时需要
```
然后重启 OpenClaw：
```bash
openclaw gateway restart
```
### 第三步：测试发送
在 OpenClaw 对话中测试：
```
发送钉钉消息：测试成功，OpenClaw 已连接！
```
如果钉钉群收到消息，集成完成！
---
## 📋 常见使用场景
### 场景 1：自动发送每日简报
**指令**：
```
每天 8:00 发送钉钉消息：今日待办事项：[事项列表]
```
**OpenClaw 会自动**：
1. 读取待办事项
2. 生成简报
3. 定时发送到钉钉群
### 场景 2：监控告警通知
**指令**：
```
当服务器 CPU > 80% 时，发送钉钉告警消息
```
**OpenClaw 会自动**：
1. 监控服务器指标
2. 触发阈值时发送钉钉消息
3. 包含详细告警信息
### 场景 3：审批流程自动化
**指令**：
```
读取钉钉审批单 [单号]，自动处理并回复结果
```
**OpenClaw 会自动**：
1. 调用钉钉审批 API
2. 分析审批内容
3. 执行相应操作
---
## 🔧 高级配置
### 多机器人支持
如果需要管理多个钉钉群：
```yaml
channels:
dingtalk:
enabled: true
bots:
- name: "开发群"
webhook: "https://oapi.dingtalk.com/robot/send?access_token=xxx1"
secret: "SECxxx1"
- name: "运维群"
webhook: "https://oapi.dingtalk.com/robot/send?access_token=xxx2"
secret: "SECxxx2"
```
### 消息模板配置
创建自定义消息模板：
```yaml
channels:
dingtalk:
templates:
alert: |
### 🚨 告警通知
**类型**：{type}
**级别**：{level}
**详情**：{detail}
**时间**：{timestamp}
daily: |
### 📅 每日简报
**日期**：{date}
**待办**：{todos}
**提醒**：{reminders}
```
---
## 🐛 故障排查
### 问题 1：消息发送失败
**错误**：`invalid webhook url`
**解决**：
1. 检查 Webhook URL 格式
2. 确认机器人未被删除
3. 测试 URL 可达性：
```bash
curl -X POST "YOUR_WEBHOOK_URL" \
-H "Content-Type: application/json" \
-d '{"msgtype":"text","text":{"content":"测试"}}'
```
### 问题 2：签名验证失败
**错误**：`sign not match`
**解决**：
1. 确认使用加签方式
2. 检查 Secret 是否正确
3. 确认时间戳在 1 小时内
### 问题 3：IP 白名单限制
**错误**：`ip not in whitelist`
**解决**：
1. 检查机器人 IP 白名单设置
2. 添加 OpenClaw 服务器 IP
3. 或改用加签方式（无需 IP 白名单）
---
## 📚 钉钉 API 参考
### 消息类型
**文本消息**：
```json
{
"msgtype": "text",
"text": {
"content": "这是一条文本消息"
}
}
```
**Markdown 消息**：
```json
{
"msgtype": "markdown",
"markdown": {
"title": "Markdown 标题",
"text": "### 标题\n**粗体**\n- 列表项"
}
}
```
**链接消息**：
```json
{
"msgtype": "link",
"link": {
"title": "链接标题",
"text": "链接描述",
"messageUrl": "https://example.com",
"picUrl": "https://example.com/icon.png"
}
}
```
---
## 💰 定价参考
- **基础集成**：¥99（机器人创建 + 消息发送）
- **企业定制**：¥299（多机器人 + 模板 + 定时任务）
- **全托管服务**：¥999/月（OpenClaw 托管 + 钉钉集成 + 技术支持）
---
## 🆘 获取帮助
- **钉钉开发文档**：https://open.dingtalk.com/document
- **OpenClaw 文档**：https://docs.openclaw.ai
- **OpenClaw 社区**：https://discord.com/invite/clawd
---
**创建时间**：2026-03-21
**作者**：OpenClaw 中文生态
**版本**：1.0.0
FILE:skill.json
{
"name": "dingtalk-quickstart-cn",
"version": "1.0.0",
"description": "钉钉快速集成配置 - 5分钟连接 OpenClaw 与钉钉，解锁机器人消息、审批流程、智能办公",
"author": "yang1002378395-cmyk",
"license": "MIT",
"keywords": ["dingtalk", "dingding", "enterprise", "robot", "chinese", "openclaw"]
}飞书快速集成配置 - 5分钟连接 OpenClaw 与飞书，解锁文档管理、知识库、自动化工作流。适合：企业用户、团队协作、飞书生态。
---
name: feishu-quickstart-cn
version: 1.0.0
description: |
飞书快速集成配置 - 5分钟连接 OpenClaw 与飞书，解锁文档管理、知识库、自动化工作流。适合：企业用户、团队协作、飞书生态。
metadata:
openclaw:
emoji: "🚀"
version: 1.0.0
requires:
bins: ["curl"]
---
# 飞书快速集成配置
**目标**：5 分钟内完成 OpenClaw + 飞书集成，开始自动化办公。
---
## 🚀 快速开始（3 步）
### 第一步：创建飞书应用
1. 访问 [飞书开放平台](https://open.feishu.cn/app)
2. 点击「创建企业自建应用」
3. 填写信息：
- **应用名称**：OpenClaw Assistant
- **应用描述**：AI 助手，自动化办公
4. 创建后记录：
- `App ID`
- `App Secret`
### 第二步：配置权限
在应用后台 → 「权限管理」→ 添加以下权限：
**文档权限（必选）**：
- `docx:document` - 读写文档
- `docx:document:readonly` - 读取文档
- `docx:document.block:convert` - 转换文档块
- `drive:drive` - 云空间访问
**知识库权限（可选）**：
- `wiki:wiki:readonly` - 读取知识库
- `wiki:wiki` - 读写知识库
**多维表格权限（可选）**：
- `bitable:bitable` - 读写多维表格
- `bitable:bitable:readonly` - 读取多维表格
### 第三步：配置 OpenClaw
在 OpenClaw 配置文件 `~/.openclaw/config.yml` 添加：
```yaml
channels:
feishu:
enabled: true
appId: "cli_xxxxxxxxxxxx" # 你的 App ID
appSecret: "xxxxxxxxxxxxxxxx" # 你的 App Secret
```
然后重启 OpenClaw：
```bash
openclaw gateway restart
```
---
## ✅ 验证集成
在 OpenClaw 对话中测试：
```
读取飞书文档 https://xxx.feishu.cn/docx/ABC123
```
如果成功返回文档内容，集成完成！
---
## 📋 常见使用场景
### 场景 1：自动生成周报
**指令**：
```
读取飞书文档 [项目文档链接]，提取本周进展，生成周报并保存到 [周报文档]
```
**OpenClaw 会自动**：
1. 读取项目文档
2. 提取关键信息
3. 生成周报 Markdown
4. 写入周报文档
### 场景 2：知识库管理
**指令**：
```
在飞书知识库 [空间名] 创建新页面「产品 FAQ」，内容如下：
[FAQ 内容]
```
**OpenClaw 会自动**：
1. 调用 `feishu_wiki` 创建页面
2. 调用 `feishu_doc` 写入内容
3. 返回页面链接
### 场景 3：多维表格自动化
**指令**：
```
读取飞书多维表格 [表格链接]，统计销售额，更新到汇总表
```
**OpenClaw 会自动**：
1. 调用 `feishu_bitable_list_records` 读取数据
2. 计算统计结果
3. 调用 `feishu_bitable_update_record` 更新汇总
---
## 🔧 高级配置
### 多租户支持（企业版）
如果需要管理多个飞书租户：
```yaml
channels:
feishu:
enabled: true
tenants:
- name: "公司A"
appId: "cli_xxx"
appSecret: "xxx"
- name: "公司B"
appId: "cli_yyy"
appSecret: "yyy"
```
### Webhook 事件订阅（可选）
配置飞书事件推送，实现实时响应：
1. 在飞书应用后台 → 「事件订阅」
2. 配置 Request URL：`https://your-openclaw-domain/webhook/feishu`
3. 订阅事件：
- `contact.user.created_v3` - 用户创建
- `docx.document.created_v1` - 文档创建
- `im.message.receive_v1` - 消息接收
---
## 🐛 故障排查
### 问题 1：权限不足
**错误**：`permission denied: docx:document`
**解决**：
1. 检查飞书应用权限配置
2. 确保已发布应用版本
3. 等待 5 分钟权限生效
### 问题 2：文档链接无法识别
**错误**：`invalid doc_token`
**解决**：
1. 确认链接格式：`https://xxx.feishu.cn/docx/ABC123`
2. 提取 `doc_token`：`ABC123`（/docx/ 后的部分）
3. 确保文档对应用可见
### 问题 3：表格写入失败
**错误**：`field type mismatch`
**解决**：
1. 使用 `feishu_bitable_list_fields` 查看字段类型
2. 确保数据格式匹配：
- Text → `"string"`
- Number → `123`
- SingleSelect → `"Option"`
- MultiSelect → `["A", "B"]`
- DateTime → `timestamp_ms`
---
## 📚 相关 Skills
- `feishu-doc` - 文档读写操作
- `feishu-wiki` - 知识库管理
- `feishu-drive` - 云存储管理
- `feishu-perm` - 权限管理
---
## 💰 定价参考
- **基础集成**：¥99（环境检查 + 配置指导）
- **企业定制**：¥299（多租户 + Webhook + 培训）
- **全托管服务**：¥999/月（OpenClaw 托管 + 飞书集成 + 技术支持）
---
## 🆘 获取帮助
- **文档**：https://docs.openclaw.ai
- **社区**：https://discord.com/invite/clawd
- **飞书开放平台**：https://open.feishu.cn/document
---
**创建时间**：2026-03-21
**作者**：OpenClaw 中文生态
**版本**：1.0.0
FILE:skill.json
{
"name": "feishu-quickstart-cn",
"version": "1.0.0",
"description": "飞书快速集成配置 - 5分钟连接 OpenClaw 与飞书，解锁文档管理、知识库、自动化工作流",
"author": "yang1002378395-cmyk",
"license": "MIT",
"keywords": ["feishu", "lark", "enterprise", "integration", "chinese", "openclaw"]
}
中文用户快速安装配置国产AI模型并测试OpenClaw全流程指导，包括环境检查、模型配置、连接测试及扩展技能安装。
# OpenClaw 快速入门（中文版）
> 5分钟上手 OpenClaw，国产 AI 模型配置指南
## 适用场景
- 刚接触 OpenClaw 的中国用户
- 想用国产 AI（DeepSeek/智谱/通义）替代 OpenAI
- 不想折腾配置，想要开箱即用
## 快速开始
### 1. 环境检测
```bash
# 检查 Node.js 版本（需要 18+）
node --version
# 检查系统信息
uname -a
```
### 2. 安装 OpenClaw
```bash
# macOS/Linux
curl -fsSL https://get.openclaw.ai | bash
# 或使用 npm
npm install -g openclaw
```
### 3. 配置国产 AI 模型
#### DeepSeek（推荐，最便宜）
```bash
# 获取 API Key：https://platform.deepseek.com/
openclaw configure --section ai --set deepseek.apiKey=YOUR_KEY
```
#### 智谱 GLM（稳定，中文友好）
```bash
# 获取 API Key：https://open.bigmodel.cn/
openclaw configure --section ai --set zhipu.apiKey=YOUR_KEY
```
#### 通义千问（阿里云）
```bash
# 获取 API Key：https://dashscope.console.aliyun.com/
openclaw configure --section ai --set qwen.apiKey=YOUR_KEY
```
### 4. 测试连接
```bash
openclaw status
```
看到 `✓ AI: connected` 就成功了！
## 价格对比（2026-03）
| 模型 | 输入（每万tokens） | 输出（每万tokens） | 备注 |
|------|-------------------|-------------------|------|
| DeepSeek V3 | ¥0.27 | ¥1.08 | 最便宜，推荐 |
| 智谱 GLM-4 | ¥0.10 | ¥0.10 | 限时免费 |
| 通义千问 | ¥0.008 | ¥0.008 | 最便宜但限流 |
| GPT-4o | ¥17.5 | ¥52.5 | 贵150倍 |
## 常见问题
### Q: 如何切换模型？
```bash
openclaw configure --section ai --set defaultModel=deepseek/deepseek-chat
```
### Q: 如何查看当前配置？
```bash
openclaw config list
```
### Q: 连接失败怎么办？
1. 检查 API Key 是否正确
2. 检查网络（部分平台需要 VPN）
3. 查看日志：`openclaw logs`
## 付费支持
需要人工安装配置？微信：[待补充]
- 基础安装：¥99
- 高级配置（含多模型）：¥299
- 企业部署：¥999
---
**作者**：OpenClaw 中文社区
**版本**：1.0.0
**更新**：2026-03-26
FILE:skill.json
{
"name": "openclaw-quickstart-cn",
"version": "1.0.0",
"version": "1.0.0",
"description": "OpenClaw 快速入门指南（中文版）- 5分钟上手，国产AI模型配置",
"author": "OpenClaw 中文社区",
"tags": ["openclaw", "chinese", "tutorial", "deepseek", "zhipu", "qwen"],
"license": "MIT",
"homepage": "https://github.com/openclaw-cn/skills",
"keywords": ["openclaw", "快速入门", "中文", "国产AI", "deepseek", "智谱", "通义"],
"category": "tutorial"
}
One-click publishing to Juejin, Zhihu, Weibo, and Xiaohongshu with scheduling, format adaptation, and publishing logs using platform cookies.
# SKILL.md - 社交媒体一键发布助手
## 描述
一键发布内容到多个社交媒体平台（掘金/知乎/微博/小红书），支持定时发布和格式适配。
## 功能
- **多平台发布**：掘金、知乎、微博、小红书
- **格式适配**：自动适配各平台字数限制和格式要求
- **定时发布**：设置发布时间，自动执行
- **发布日志**：记录发布链接和状态
## 使用方法
```bash
# 安装
claw install social-publisher
# 发布到所有平台
claw run social-publisher --content "文章内容" --title "标题"
# 发布到指定平台
claw run social-publisher --platform juejin --content "文章内容"
# 定时发布
claw run social-publisher --content "文章内容" --schedule "2026-03-21 10:00"
```
## 配置
需要在 `~/.openclaw/workspace/config/social-publisher.json` 配置各平台 Cookie：
```json
{
"juejin": {
"cookie": "your-juejin-cookie"
},
"zhihu": {
"cookie": "your-zhihu-cookie"
},
"weibo": {
"cookie": "your-weibo-cookie"
}
}
```
## 注意事项
- Cookie 有效期约 1 年，过期需重新登录获取
- 小红书需要人工验证码，无法完全自动化
- 建议先用测试账号验证发布功能
## 价格
免费（引流到安装服务 ¥99）
## 作者
yang1002378395
FILE:package.json
{
"name": "social-publisher",
"version": "1.0.0",
"description": "一键发布内容到多个社交媒体平台（掘金/知乎/微博）",
"author": "yang1002378395",
"tags": ["social", "publish", "automation", "chinese"],
"repository": "https://clawhub.com/yang1002378395-cmyk/social-publisher",
"license": "MIT",
"price": 0,
"currency": "USD"
}
FILE:scripts/social_publisher.py
#!/usr/bin/env python3
"""
社交媒体一键发布脚本
支持：掘金、知乎、微博
用法：
python3 social_publisher.py --platform juejin --file article.md
python3 social_publisher.py --all --file article.md
python3 social_publisher.py --schedule "2026-03-21 10:00" --file article.md
"""
import json
import time
import argparse
import urllib.request
from datetime import datetime
from pathlib import Path
from typing import Optional
W = Path(__file__).parent.parent
CONFIG_FILE = W / "config/social-publisher.json"
LOG_FILE = W / "memory/social-publish-log.jsonl"
# 平台配置
PLATFORMS = {
"juejin": {
"name": "掘金",
"api": "https://api.juejin.cn",
"max_length": 20000,
"cookie_key": "juejin"
},
"zhihu": {
"name": "知乎",
"api": "https://www.zhihu.com/api",
"max_length": 100000,
"cookie_key": "zhihu"
},
"weibo": {
"name": "微博",
"api": "https://api.weibo.cn",
"max_length": 2000,
"cookie_key": "weibo"
}
}
def load_config() -> dict:
"""加载配置"""
if not CONFIG_FILE.exists():
return {}
return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
def get_cookie(platform: str) -> Optional[str]:
"""获取平台 Cookie"""
config = load_config()
return config.get(platform, {}).get("cookie")
def read_article(file_path: Path) -> tuple[str, str]:
"""读取文章内容"""
if file_path.suffix == ".json":
data = json.loads(file_path.read_text(encoding="utf-8"))
title = data.get("title", file_path.stem)
content = data.get("content_markdown", "") or data.get("markdown_content", "")
else:
text = file_path.read_text(encoding="utf-8").strip()
lines = text.splitlines()
title = lines[0].lstrip("#").strip() if lines else file_path.stem
content = text
return title, content
def adapt_content(content: str, platform: str) -> str:
"""适配内容到平台"""
max_len = PLATFORMS[platform]["max_length"]
if len(content) > max_len:
return content[:max_len-50] + "\n\n...（内容过长，已截断）"
return content
def publish_to_juejin(title: str, content: str, cookie: str) -> dict:
"""发布到掘金"""
url = f"{PLATFORMS['juejin']['api']}/content_api/v1/article_draft/create"
payload = {
"title": title,
"content": content,
"category_id": "6809637773935378440", # AI
"tag_ids": ["6809640408797167623"],
"brief_content": content[:200]
}
req = urllib.request.Request(
url,
data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
headers={
"Content-Type": "application/json",
"Cookie": cookie,
"User-Agent": "Mozilla/5.0"
}
)
try:
with urllib.request.urlopen(req, timeout=30) as r:
return json.loads(r.read().decode("utf-8"))
except Exception as e:
return {"err_no": -1, "err_msg": str(e)}
def publish_to_zhihu(title: str, content: str, cookie: str) -> dict:
"""发布到知乎（创建草稿）"""
url = "https://www.zhihu.com/api/v4/articles"
payload = {
"title": title,
"content": content,
"draft": True,
"can_reward": False
}
req = urllib.request.Request(
url,
data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
headers={
"Content-Type": "application/json",
"Cookie": cookie,
"User-Agent": "Mozilla/5.0",
"x-requested-with": "fetch"
}
)
try:
with urllib.request.urlopen(req, timeout=30) as r:
resp = json.loads(r.read().decode("utf-8"))
return {"err_no": 0, "data": resp} if "id" in resp else {"err_no": -1, "err_msg": resp.get("error", {}).get("message", "未知错误")}
except Exception as e:
return {"err_no": -1, "err_msg": str(e)}
def publish_to_weibo(content: str, cookie: str) -> dict:
"""发布到微博"""
url = "https://api.weibo.cn/2/statuses/share.json"
# 微博只支持短文本 + 图片
text = content[:2000] if len(content) > 2000 else content
req = urllib.request.Request(
url,
data=f"content={text}".encode("utf-8"),
headers={
"Content-Type": "application/x-www-form-urlencoded",
"Cookie": cookie,
"User-Agent": "Mozilla/5.0"
},
method="POST"
)
try:
with urllib.request.urlopen(req, timeout=30) as r:
resp = json.loads(r.read().decode("utf-8"))
return {"err_no": 0, "data": resp} if "id" in resp else {"err_no": -1, "err_msg": resp.get("error", "未知错误")}
except Exception as e:
return {"err_no": -1, "err_msg": str(e)}
def log_publish(platform: str, title: str, result: dict):
"""记录发布日志"""
log_entry = {
"time": datetime.now().isoformat(),
"platform": platform,
"title": title,
"result": result
}
with open(LOG_FILE, "a", encoding="utf-8") as f:
f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
def main():
parser = argparse.ArgumentParser(description="社交媒体一键发布")
parser.add_argument("--platform", choices=["juejin", "zhihu", "weibo"])
parser.add_argument("--all", action="store_true", help="发布到所有平台")
parser.add_argument("--file", required=True, help="文章文件路径")
parser.add_argument("--schedule", help="定时发布时间")
args = parser.parse_args()
# 读取文章
file_path = Path(args.file)
if not file_path.exists():
print(f"❌ 文件不存在: {file_path}")
return
title, content = read_article(file_path)
# 定时发布
if args.schedule:
schedule_time = datetime.fromisoformat(args.schedule)
wait_seconds = (schedule_time - datetime.now()).total_seconds()
if wait_seconds > 0:
print(f"⏰ 定时发布：{args.schedule}，等待 {wait_seconds:.0f} 秒")
time.sleep(wait_seconds)
# 确定发布平台
platforms = ["juejin", "zhihu", "weibo"] if args.all else [args.platform]
for platform in platforms:
cookie = get_cookie(platform)
if not cookie:
print(f"⚠️ {PLATFORMS[platform]['name']} Cookie 未配置，跳过")
continue
adapted_content = adapt_content(content, platform)
print(f"📤 发布到 {PLATFORMS[platform]['name']}...")
if platform == "juejin":
result = publish_to_juejin(title, adapted_content, cookie)
elif platform == "zhihu":
result = publish_to_zhihu(title, adapted_content, cookie)
elif platform == "weibo":
result = publish_to_weibo(adapted_content, cookie)
if result.get("err_no") == 0:
print(f"✅ {PLATFORMS[platform]['name']} 发布成功")
else:
print(f"❌ {PLATFORMS[platform]['name']} 发布失败: {result.get('err_msg')}")
log_publish(platform, title, result)
time.sleep(1) # 避免频率限制
if __name__ == "__main__":
main()AI 模型成本优化器 - 自动计算 API 费用，推荐最优模型，对比 DeepSeek/智谱/通义/GPT 成本。省钱必备工具。
---
name: ai-cost-optimizer
description: AI 模型成本优化器 - 自动计算 API 费用，推荐最优模型，对比 DeepSeek/智谱/通义/GPT 成本。省钱必备工具。
version: 1.0.0
author: OpenClaw CN
tags:
- ai
- cost
- optimization
- deepseek
- pricing
- calculator
---
# AI 成本优化器
智能对比 AI 模型 API 成本，推荐最优模型，帮你省 90%+ API 费用。
## 功能
- 💰 **成本计算** - 实时计算不同模型的 API 费用
- 📊 **价格对比** - 一键对比 10+ 主流模型
- 🎯 **智能推荐** - 根据场景推荐最优模型
- 📈 **费用预估** - 预估使用 10 万 tokens 花多少钱
- 💡 **省钱建议** - 告诉你如何优化成本
## 安装
```bash
npx clawhub@latest install ai-cost-optimizer
```
## 使用方法
### 1. 对比模型价格
```bash
node ~/.openclaw/skills/ai-cost-optimizer/compare.js
```
输出示例：
```
📊 AI 模型价格对比
┌─────────────┬──────────┬──────────┬─────────────┐
│ 模型 │ 输入 │ 输出 │ 每10万tokens │
├─────────────┼──────────┼──────────┼─────────────┤
│ DeepSeek V3 │ ¥0.27/M │ ¥1.08/M │ ¥1.35 │
│ 智谱 GLM-4 │ ¥0.10/M │ ¥0.10/M │ ¥0.50 │
│ 通义千问 │ ¥0.30/M │ ¥0.60/M │ ¥1.80 │
│ GPT-4o │ ¥35/M │ ¥105/M │ ¥140 │
│ Claude 3.5 │ ¥17.50/M │ ¥52.50/M │ ¥70 │
└─────────────┴──────────┴──────────┴─────────────┘
💡 推荐选择：
日常使用 → DeepSeek V3（省 99% 费用）
中文内容 → 智谱 GLM-4（省 99.5% 费用）
复杂推理 → Claude 3.5（省 50% 费用）
```
### 2. 计算使用费用
```bash
# 计算特定模型的费用
node ~/.openclaw/skills/ai-cost-optimizer/calculate.js deepseek 500000
# 输出：使用 50 万 tokens 花费 ¥6.75
# 交互式计算
node ~/.openclaw/skills/ai-cost-optimizer/calculate.js
```
### 3. 智能推荐
```bash
node ~/.openclaw/skills/ai-cost-optimizer/recommend.js
```
会询问你的使用场景，然后推荐最优模型：
```
❓ 主要用途？
1. 日常对话/写作
2. 编程/代码生成
3. 中文内容创作
4. 复杂推理/分析
5. 多模态（图文）
❓ 每天大约调用次数？
1. < 100 次
2. 100-1000 次
3. 1000-10000 次
4. > 10000 次
💡 推荐：DeepSeek V3
- 性价比最高
- 预估每月费用：¥27（1000次/天）
- 同等使用 GPT-4o：¥2800（省 99%）
```
### 4. 生成成本报告
```bash
node ~/.openclaw/skills/ai-cost-optimizer/report.js --model deepseek --tokens 1000000
```
生成详细成本分析报告：
- 各模型费用对比
- 省钱潜力分析
- 使用建议
## 支持的模型
| 模型 | 输入价格 | 输出价格 | 推荐场景 |
|------|----------|----------|----------|
| DeepSeek V3 | ¥0.27/M | ¥1.08/M | 日常对话、编程、写作 |
| DeepSeek Coder | ¥0.27/M | ¥1.08/M | 代码生成、代码审查 |
| 智谱 GLM-4 | ¥0.10/M | ¥0.10/M | 中文内容创作 |
| 智谱 GLM-3-Turbo | ¥0.05/M | ¥0.05/M | 高频调用 |
| 通义千问 Plus | ¥0.30/M | ¥0.60/M | 多模态任务 |
| 通义千问 Turbo | ¥0.10/M | ¥0.10/M | 快速响应 |
| GPT-4o | ¥35/M | ¥105/M | 复杂推理（企业级） |
| GPT-4o-mini | ¥3.50/M | ¥10.50/M | 中等任务 |
| Claude 3.5 Sonnet | ¥17.50/M | ¥52.50/M | 长文本、代码 |
| Claude 3.5 Haiku | ¥0.18/M | ¥0.54/M | 快速对话 |
## 省钱案例
### 案例 1：个人开发者
- **使用场景**：每天 AI 写代码 + 写博客
- **原方案**：GPT-4o，每月 100 万 tokens → ¥1400
- **优化后**：DeepSeek V3，每月 100 万 tokens → ¥13.5
- **节省**：**¥1386.5/月（99%）**
### 案例 2：初创公司
- **使用场景**：客服 Bot，每月 5000 万 tokens
- **原方案**：GPT-4o-mini → ¥17500/月
- **优化后**：DeepSeek V3 → ¥675/月
- **节省**：**¥16825/月（96%）**
### 案例 3：中文内容团队
- **使用场景**：写文章、营销文案，每月 3000 万 tokens
- **原方案**：GPT-4o → ¥42000/月
- **优化后**：智谱 GLM-4 + DeepSeek 组合 → ¥450/月
- **节省**：**¥41550/月（99%）**
## 混合策略（最优解）
根据不同任务使用不同模型：
| 任务类型 | 推荐模型 | 原因 |
|----------|----------|------|
| 简单对话 | DeepSeek V3 | 便宜 |
| 代码生成 | DeepSeek Coder | 代码能力强 |
| 中文写作 | 智谱 GLM-4 | 中文能力强 |
| 复杂推理 | Claude 3.5 | 推理强 |
| 多模态 | 通义千问 Plus | 图文处理 |
**预期节省**：50-99%（根据任务分布）
## 价格数据来源
- DeepSeek: https://platform.deepseek.com
- 智谱 AI: https://open.bigmodel.cn
- 通义千问: https://dashscope.aliyun.com
- OpenAI: https://openai.com/pricing
- Anthropic: https://www.anthropic.com/pricing
**注意**：价格可能变动，以官方为准。
## 常见问题
### Q: DeepSeek 和 GPT-4 差多少？
A: 日常任务（写作、编程、问答）几乎没差。复杂推理（数学证明、多步逻辑）GPT-4 略好，但贵 100 倍。
### Q: 可以混用多个模型吗？
A: 可以！推荐策略：
- 80% 用 DeepSeek/智谱（便宜）
- 20% 用 GPT/Claude（复杂任务）
- 预期节省 70-80%
### Q: 如何切换模型？
A: 编辑 `~/.openclaw/config.json`：
```json
{
"model": {
"provider": "deepseek",
"model": "deepseek-chat"
}
}
```
### Q: 这些价格准确吗？
A: 官方价格，2026-03 更新。价格可能变动，请以官方为准。
## 配置 OpenClaw 使用不同模型
### 方式 1：配置文件
编辑 `~/.openclaw/config.json`：
```json
{
"model": {
"provider": "deepseek",
"model": "deepseek-chat"
}
}
```
### 方式 2：环境变量
```bash
export DEFAULT_MODEL_PROVIDER=deepseek
export DEFAULT_MODEL_ID=deepseek-chat
```
### 方式 3：使用 openclaw-cn-installer
```bash
npx clawhub@latest install openclaw-cn-installer
node ~/.openclaw/skills/openclaw-cn-installer/setup-ai.js deepseek
```
## 相关资源
- [OpenClaw 中文安装助手](https://clawhub.ai/skill/openclaw-cn-installer)
- [DeepSeek 官网](https://deepseek.com)
- [智谱 AI 官网](https://bigmodel.cn)
- [OpenClaw 文档](https://docs.openclaw.ai)
## License
MIT
FILE:calculate.js
#!/usr/bin/env node
/**
* AI Cost Optimizer - Calculate Cost
* 计算特定模型的 API 费用
*/
const MODELS = {
'deepseek': { name: 'DeepSeek V3', input: 0.27, output: 1.08 },
'deepseek-coder': { name: 'DeepSeek Coder', input: 0.27, output: 1.08 },
'glm-4': { name: '智谱 GLM-4', input: 0.10, output: 0.10 },
'glm-3-turbo': { name: '智谱 GLM-3-Turbo', input: 0.05, output: 0.05 },
'qwen-plus': { name: '通义千问 Plus', input: 0.30, output: 0.60 },
'qwen-turbo': { name: '通义千问 Turbo', input: 0.10, output: 0.10 },
'gpt-4o': { name: 'GPT-4o', input: 35, output: 105 },
'gpt-4o-mini': { name: 'GPT-4o-mini', input: 3.50, output: 10.50 },
'claude-3.5-sonnet': { name: 'Claude 3.5 Sonnet', input: 17.50, output: 52.50 },
'claude-3.5-haiku': { name: 'Claude 3.5 Haiku', input: 0.18, output: 0.54 },
};
const GREEN = '\x1b[32m';
const YELLOW = '\x1b[33m';
const RESET = '\x1b[0m';
function calculateCost(modelKey, inputTokens, outputTokens) {
const model = MODELS[modelKey.toLowerCase()];
if (!model) {
console.error(`❌ 未知模型: modelKey`);
console.log('支持的模型:', Object.keys(MODELS).join(', '));
return null;
}
const inputCost = (model.input / 1000000) * inputTokens;
const outputCost = (model.output / 1000000) * outputTokens;
const totalCost = inputCost + outputCost;
return {
model: model.name,
inputTokens,
outputTokens,
totalTokens: inputTokens + outputTokens,
inputCost,
outputCost,
totalCost,
};
}
function formatCost(cost) {
if (cost < 1) return `(cost * 100).toFixed(2) 分`;
return `¥cost.toFixed(2)`;
}
// 命令行参数
const args = process.argv.slice(2);
if (args.length >= 2) {
// node calculate.js <model> <tokens>
const modelKey = args[0];
const totalTokens = parseInt(args[1]);
// 假设输入输出各占一半
const inputTokens = Math.floor(totalTokens / 2);
const outputTokens = totalTokens - inputTokens;
const result = calculateCost(modelKey, inputTokens, outputTokens);
if (result) {
console.log(`\n💰 费用计算：result.model\n`);
console.log('─'.repeat(50));
console.log(` 输入 tokens: result.inputTokens.toLocaleString() → formatCost(result.inputCost)`);
console.log(` 输出 tokens: result.outputTokens.toLocaleString() → formatCost(result.outputCost)`);
console.log('─'.repeat(50));
console.log(` GREEN总计：result.totalTokens.toLocaleString() tokens = formatCost(result.totalCost)RESET\n`);
// 对比 GPT-4o
if (modelKey !== 'gpt-4o') {
const gpt4oCost = calculateCost('gpt-4o', inputTokens, outputTokens);
const savings = gpt4oCost.totalCost - result.totalCost;
const savingsPercent = ((savings / gpt4oCost.totalCost) * 100).toFixed(1);
console.log(` YELLOW💡 相比 GPT-4o：节省 ¥savings.toFixed(2) (savingsPercent%)RESET\n`);
}
}
} else {
// 交互式
console.log('\n💰 AI 费用计算器\n');
console.log('支持的模型:', Object.values(MODELS).map(m => m.name).join(', '));
console.log('使用方法:');
console.log(' node calculate.js <模型> <总tokens数量>\n');
console.log('示例:');
console.log(' node calculate.js deepseek 100000');
console.log(' node calculate.js gpt-4o 500000\n');
}
FILE:compare.js
#!/usr/bin/env node
/**
* AI Cost Optimizer - Compare Prices
* 对比不同 AI 模型的 API 价格
*/
const MODELS = [
{ name: 'DeepSeek V3', input: 0.27, output: 1.08, tags: ['日常', '编程', '写作'], best: '性价比最高' },
{ name: 'DeepSeek Coder', input: 0.27, output: 1.08, tags: ['代码生成'], best: '代码能力强' },
{ name: '智谱 GLM-4', input: 0.10, output: 0.10, tags: ['中文'], best: '中文能力强' },
{ name: '智谱 GLM-3-Turbo', input: 0.05, output: 0.05, tags: ['高频'], best: '超便宜' },
{ name: '通义千问 Plus', input: 0.30, output: 0.60, tags: ['多模态'], best: '图文处理' },
{ name: '通义千问 Turbo', input: 0.10, output: 0.10, tags: ['快速'], best: '快速响应' },
{ name: 'GPT-4o', input: 35, output: 105, tags: ['复杂推理'], best: '企业级' },
{ name: 'GPT-4o-mini', input: 3.50, output: 10.50, tags: ['中等任务'], best: '均衡' },
{ name: 'Claude 3.5 Sonnet', input: 17.50, output: 52.50, tags: ['长文本', '代码'], best: '推理强' },
{ name: 'Claude 3.5 Haiku', input: 0.18, output: 0.54, tags: ['快速'], best: '便宜又快' },
];
const GREEN = '\x1b[32m';
const YELLOW = '\x1b[33m';
const CYAN = '\x1b[36m';
const RESET = '\x1b[0m';
function calculateCost100k(model) {
// 假设输入输出各占一半，即 50k 输入 + 50k 输出
const inputCost = (model.input / 1000000) * 50000;
const outputCost = (model.output / 1000000) * 50000;
return inputCost + outputCost;
}
console.log('\n📊 AI 模型价格对比\n');
console.log('─'.repeat(70));
// 表头
console.log(`│ '模型'.padEnd(12) │ '输入'.padEnd(10) │ '输出'.padEnd(10) │ '10万tokens'.padEnd(12) │`);
console.log('─'.repeat(70));
// 排序：按价格从低到高
const sortedModels = [...MODELS].sort((a, b) => calculateCost100k(a) - calculateCost100k(b));
sortedModels.forEach((model, index) => {
const cost100k = calculateCost100k(model);
const costStr = `¥cost100k.toFixed(2)`;
const icon = index === 0 ? GREEN + '🏆' + RESET : ' ';
console.log(`icon │ model.name.padEnd(12) │ ¥model.input.toFixed(2)/M │ ¥model.output.toFixed(2)/M │ costStr.padEnd(12) │`);
});
console.log('─'.repeat(70));
// 推荐建议
console.log('\n💡 推荐选择：\n');
const recommendations = [
{
title: '日常使用',
model: 'DeepSeek V3',
desc: '性价比最高',
savings: '省 99% 费用',
price: calculateCost100k(MODELS.find(m => m.name === 'DeepSeek V3')),
},
{
title: '中文内容',
model: '智谱 GLM-4',
desc: '中文能力强',
savings: '省 99.5% 费用',
price: calculateCost100k(MODELS.find(m => m.name === '智谱 GLM-4')),
},
{
title: '复杂推理',
model: 'Claude 3.5 Sonnet',
desc: '推理能力强',
savings: '省 50% 费用（对比 GPT-4o）',
price: calculateCost100k(MODELS.find(m => m.name === 'Claude 3.5 Sonnet')),
},
{
title: '代码生成',
model: 'DeepSeek Coder',
desc: '代码专项优化',
savings: '省 99% 费用',
price: calculateCost100k(MODELS.find(m => m.name === 'DeepSeek Coder')),
},
];
recommendations.forEach(rec => {
console.log(` YELLOW→RESET rec.title.padEnd(8) → CYANrec.modelRESET`);
console.log(` rec.desc, rec.savings`);
console.log(` 每10万 tokens：¥rec.price.toFixed(2)\n`);
});
// 对比 GPT-4o
const gpt4o = MODELS.find(m => m.name === 'GPT-4o');
const deepseek = MODELS.find(m => m.name === 'DeepSeek V3');
const ratio = calculateCost100k(gpt4o) / calculateCost100k(deepseek);
console.log('─'.repeat(70));
console.log(`\nGREEN📈 省钱潜力：RESET`);
console.log(` DeepSeek V3 vs GPT-4o：便宜 ratio.toFixed(0) 倍`);
console.log(` 同样使用 100 万 tokens：`);
console.log(` - GPT-4o: ¥(calculateCost100k(gpt4o) * 10).toFixed(2)`);
console.log(` - DeepSeek: ¥(calculateCost100k(deepseek) * 10).toFixed(2)`);
console.log(` GREEN节省：¥(calculateCost100k(gpt4o) * 10 - calculateCost100k(deepseek) * 10).toFixed(2) (((1 - 1/ratio) * 100).toFixed(0)%)RESET\n`);
console.log('📖 更多功能：');
console.log(' node calculate.js - 计算使用费用');
console.log(' node recommend.js - 智能推荐模型\n');
FILE:package.json
{
"name": "ai-cost-optimizer",
"version": "1.0.0",
"description": "AI 模型成本优化器 - 对比 DeepSeek/智谱/通义/GPT 价格，推荐最优模型",
"main": "compare.js",
"bin": {
"ai-cost-compare": "./compare.js",
"ai-cost-calc": "./calculate.js",
"ai-cost-rec": "./recommend.js"
},
"scripts": {
"compare": "node compare.js",
"calculate": "node calculate.js",
"recommend": "node recommend.js"
},
"keywords": [
"ai",
"cost",
"optimization",
"deepseek",
"zhipu",
"qwen",
"gpt",
"claude",
"pricing",
"calculator"
],
"author": "OpenClaw CN",
"license": "MIT",
"repository": {
"type": "git",
"url": "https://github.com/openclaw-cn/ai-cost-optimizer"
},
"engines": {
"node": ">=18.0.0"
}
}
FILE:recommend.js
#!/usr/bin/env node
/**
* AI Cost Optimizer - Recommend Model
* 根据使用场景智能推荐最优 AI 模型
*/
const readline = require('readline');
const MODELS = {
daily: {
name: 'DeepSeek V3',
provider: 'deepseek',
model: 'deepseek-chat',
input: 0.27,
output: 1.08,
desc: '性价比最高，适合日常对话、写作、编程',
monthlyCost: 27,
tokensPerCall: 1000,
},
coding: {
name: 'DeepSeek Coder',
provider: 'deepseek',
model: 'deepseek-coder',
input: 0.27,
output: 1.08,
desc: '代码专项优化，适合代码生成、审查',
monthlyCost: 27,
tokensPerCall: 1500,
},
chinese: {
name: '智谱 GLM-4',
provider: 'zhipu',
model: 'glm-4',
input: 0.10,
output: 0.10,
desc: '中文能力强，适合中文内容创作',
monthlyCost: 10,
tokensPerCall: 800,
},
complex: {
name: 'Claude 3.5 Sonnet',
provider: 'anthropic',
model: 'claude-3-5-sonnet-20241022',
input: 17.50,
output: 52.50,
desc: '推理能力强，适合复杂任务',
monthlyCost: 350,
tokensPerCall: 2000,
},
multimodal: {
name: '通义千问 Plus',
provider: 'qwen',
model: 'qwen-plus',
input: 0.30,
output: 0.60,
desc: '多模态支持，图文处理',
monthlyCost: 36,
tokensPerCall: 1200,
},
};
const SCENARIOS = {
'1': {
name: '日常对话/写作',
recommend: 'daily',
alternatives: ['chinese'],
},
'2': {
name: '编程/代码生成',
recommend: 'coding',
alternatives: ['daily'],
},
'3': {
name: '中文内容创作',
recommend: 'chinese',
alternatives: ['daily'],
},
'4': {
name: '复杂推理/分析',
recommend: 'complex',
alternatives: ['daily'],
},
'5': {
name: '多模态（图文）',
recommend: 'multimodal',
alternatives: ['daily'],
},
};
const FREQUENCY = {
'1': { label: '< 100 次/天', factor: 0.1 },
'2': { label: '100-1000 次/天', factor: 1 },
'3': { label: '1000-10000 次/天', factor: 10 },
'4': { label: '> 10000 次/天', factor: 50 },
};
const GREEN = '\x1b[32m';
const YELLOW = '\x1b[33m';
const CYAN = '\x1b[36m';
const RESET = '\x1b[0m';
async function prompt(rl, question) {
return new Promise(resolve => {
rl.question(question, answer => {
resolve(answer.trim());
});
});
}
function estimateMonthlyCost(modelKey, frequencyFactor) {
const model = MODELS[modelKey];
const tokensPerMonth = model.tokensPerCall * 30 * frequencyFactor;
const costPerMonth = (model.input / 1000000 * tokensPerMonth * 0.5 +
model.output / 1000000 * tokensPerMonth * 0.5);
return {
tokens: tokensPerMonth,
cost: costPerMonth,
};
}
async function main() {
console.log('\n🎯 AI 模型智能推荐\n');
console.log('─'.repeat(60));
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
try {
// 问题 1：主要用途
console.log('\n❓ 主要用途？\n');
Object.entries(SCENARIOS).forEach(([key, scenario]) => {
console.log(` key. scenario.name`);
});
const scenarioChoice = await prompt(rl, '\n请选择 (1-5): ');
const scenario = SCENARIOS[scenarioChoice];
if (!scenario) {
console.log('❌ 无效选择');
rl.close();
return;
}
// 问题 2：使用频率
console.log('\n❓ 每天大约调用次数？\n');
Object.entries(FREQUENCY).forEach(([key, freq]) => {
console.log(` key. freq.label`);
});
const freqChoice = await prompt(rl, '\n请选择 (1-4): ');
const frequency = FREQUENCY[freqChoice];
if (!frequency) {
console.log('❌ 无效选择');
rl.close();
return;
}
rl.close();
// 推荐模型
console.log('\n' + '─'.repeat(60));
console.log(`GREEN💡 推荐模型：MODELS[scenario.recommend].nameRESET\n`);
console.log(` MODELS[scenario.recommend].desc`);
const estimate = estimateMonthlyCost(scenario.recommend, frequency.factor);
console.log(`\n 预估每月费用：¥estimate.cost.toFixed(2)`);
console.log(` 预估每月 tokens：estimate.tokens.toLocaleString()`);
// 对比 GPT-4o
const gpt4oEstimate = estimateMonthlyCost('daily', frequency.factor);
const gpt4oCost = gpt4oEstimate.cost * (35 / 0.27); // GPT-4o vs DeepSeek ratio
const savings = gpt4oCost - estimate.cost;
const savingsPercent = ((savings / gpt4oCost) * 100).toFixed(1);
console.log(`\n YELLOW💰 相比 GPT-4o：节省 ¥savings.toFixed(2) (savingsPercent%)RESET`);
// 备选方案
console.log('\n' + '─'.repeat(60));
console.log('🔄 备选方案：\n');
scenario.alternatives.forEach((altKey, index) => {
const altModel = MODELS[altKey];
const altEstimate = estimateMonthlyCost(altKey, frequency.factor);
console.log(` index + 1. altModel.name`);
console.log(` altModel.desc`);
console.log(` 预估每月费用：¥altEstimate.cost.toFixed(2)\n`);
});
console.log('─'.repeat(60));
console.log('\n📖 如何配置模型？\n');
console.log(' 方式 1: 使用 openclaw-cn-installer');
console.log(' npx clawhub@latest install openclaw-cn-installer');
console.log(` node ~/.openclaw/skills/openclaw-cn-installer/setup-ai.js MODELS[scenario.recommend].provider`);
console.log('\n 方式 2: 手动编辑配置文件');
console.log(' 编辑 ~/.openclaw/config.json：');
console.log(' {');
console.log(` "model": {`);
console.log(` "provider": "MODELS[scenario.recommend].provider",`);
console.log(` "model": "MODELS[scenario.recommend].model"`);
console.log(` }`);
console.log(' }\n');
} catch (e) {
console.error('Error:', e.message);
rl.close();
}
}
main();
FILE:skill.json
{
"name": "ai-cost-optimizer",
"version": "1.0.0",
"description": "AI-powered skill for productivity",
"author": "yang1002378395-cmyk",
"license": "MIT",
"keywords": ["ai", "automation", "productivity"]
}
OpenClaw 中文安装配置助手。一键检测环境、配置国产 AI 模型（DeepSeek/智谱/阿里通义）。适合中国用户快速上手 OpenClaw。
---
name: openclaw-cn-installer
description: OpenClaw 中文安装配置助手。一键检测环境、配置国产 AI 模型（DeepSeek/智谱/阿里通义）。适合中国用户快速上手 OpenClaw。
version: 1.0.1
author: OpenClaw CN
tags:
- openclaw
- chinese
- installer
- setup
- deepseek
- zhipu
- qwen
---
# OpenClaw 中文安装配置助手
专为中文用户设计的 OpenClaw 安装配置 Skill。配置国产 AI 模型，节省 99% API 费用。
## 功能
- 🔍 **环境检测** - 自动检测 Node.js、系统、网络环境
- 🤖 **国产模型配置** - 一键配置 DeepSeek、智谱 GLM、阿里通义千问
- ✅ **连接测试** - 测试 API 连接，验证配置正确
## 安装
```bash
npx clawhub@latest install openclaw-cn-installer
```
## 使用方法
### 1. 环境检测
```bash
node ~/.openclaw/skills/openclaw-cn-installer/check-env.js
```
检测内容：
- Node.js 版本（需要 18+）
- 操作系统兼容性
- 网络连接状态
### 2. 配置国产 AI 模型
```bash
# DeepSeek
node ~/.openclaw/skills/openclaw-cn-installer/setup-ai.js deepseek
# 智谱 GLM
node ~/.openclaw/skills/openclaw-cn-installer/setup-ai.js zhipu
# 阿里通义千问
node ~/.openclaw/skills/openclaw-cn-installer/setup-ai.js qwen
```
### 3. 测试连接
```bash
node ~/.openclaw/skills/openclaw-cn-installer/test-connection.js
```
输出示例：
```
✅ DeepSeek API: 连接成功
✅ 响应时间: 234ms
✅ 余额: ¥45.00
```
## 支持的 AI 模型
| 模型 | 提供商 | 特点 | 推荐场景 |
|------|--------|------|----------|
| DeepSeek V3 | DeepSeek | 超高性价比 ¥0.27/M tokens | 日常对话、代码生成 |
| GLM-4 | 智谱 AI | 中文能力强 | 中文内容创作 |
| Qwen 2.5 | 阿里云 | 多模态支持 | 图文混合任务 |
## 价格对比
| 模型 | 输入价格 | 输出价格 | 相比 GPT-4 |
|------|----------|----------|------------|
| DeepSeek V3 | ¥0.27/M | ¥1.08/M | **便宜 100x** |
| GLM-4 | ¥0.1/M | ¥0.1/M | 便宜 50x |
| Qwen 2.5 | ¥0.3/M | ¥0.6/M | 便宜 30x |
| GPT-4o | ¥35/M | ¥105/M | 基准 |
**省钱技巧**：用 DeepSeek 做日常任务，省 99% API 费用。
## 常见问题
### Q: 如何获取 DeepSeek API Key？
1. 访问 https://platform.deepseek.com
2. 注册账号（支持手机号）
3. 充值（最低 ¥10）
4. 创建 API Key
### Q: OpenClaw 配置文件在哪？
```
~/.openclaw/config.json # 主配置
~/.openclaw/.env # 环境变量（API Keys）
~/.openclaw/workspace/ # 工作目录
```
## 技术支持
- 📖 **文档**: https://docs.openclaw.ai
- 💬 **Discord**: https://discord.com/invite/clawd
- 📧 **安装服务**: ¥99 起
## 更新日志
### v1.0.1 (2026-03-20)
- 🐛 修复文档与实际功能不匹配的问题
- ✅ 移除未实现的功能说明
### v1.0.0 (2026-03-20)
- ✨ 首次发布
- ✅ 支持 DeepSeek/GLM/Qwen 配置
- ✅ 环境检测功能
- ✅ 连接测试功能
## License
MIT-0
FILE:check-env.js
#!/usr/bin/env node
/**
* OpenClaw CN Installer - Environment Checker
* 检测系统环境是否满足 OpenClaw 运行要求
*/
const { execSync } = require('child_process');
const os = require('os');
const fs = require('fs');
const path = require('path');
const GREEN = '\x1b[32m';
const RED = '\x1b[31m';
const YELLOW = '\x1b[33m';
const RESET = '\x1b[0m';
function check(text, pass, detail = '') {
const icon = pass ? `GREEN✅` : `RED❌`;
console.log(`icon textRESETdetail ? ` (${detail)` : ''}`);
return pass;
}
console.log('\n🔍 OpenClaw 中文环境检测\n');
console.log('─'.repeat(50));
const results = [];
// 1. Node.js 版本
try {
const nodeVersion = process.version.replace('v', '');
const major = parseInt(nodeVersion.split('.')[0]);
const pass = major >= 18;
results.push(check('Node.js 版本', pass, `vnodeVersion`));
} catch (e) {
results.push(check('Node.js 版本', false, '未安装'));
}
// 2. 操作系统
const platform = os.platform();
const arch = os.arch();
const osMap = { darwin: 'macOS', win32: 'Windows', linux: 'Linux' };
results.push(check('操作系统', true, `osMap[platform] || platform (arch)`));
// 3. 内存
const memGB = Math.round(os.totalmem() / 1024 / 1024 / 1024);
results.push(check('内存', memGB >= 4, `memGBGB`));
// 4. npm 镜像
try {
const registry = execSync('npm config get registry', { encoding: 'utf-8' }).trim();
const isCnMirror = registry.includes('npmmirror') || registry.includes('taobao');
results.push(check('npm 镜像', true, isCnMirror ? '国内镜像 🇨🇳' : '官方镜像'));
if (!isCnMirror) {
console.log(`YELLOW💡 建议: npm config set registry https://registry.npmmirror.comRESET`);
}
} catch (e) {
results.push(check('npm 镜像', false, '无法检测'));
}
// 5. 网络连接
try {
execSync('curl -s --connect-timeout 3 https://registry.npmmirror.com > /dev/null', { stdio: 'ignore' });
results.push(check('网络连接', true, '正常'));
} catch (e) {
results.push(check('网络连接', false, '无法访问 npm 镜像'));
}
// 6. OpenClaw 配置目录
const openclawDir = path.join(os.homedir(), '.openclaw');
const hasConfig = fs.existsSync(openclawDir);
results.push(check('OpenClaw 目录', hasConfig, hasConfig ? '已存在' : '未创建'));
// 7. 检查常用命令
const commands = ['git', 'curl', 'python3'];
commands.forEach(cmd => {
try {
execSync(`which cmd`, { stdio: 'ignore' });
results.push(check(`cmd 命令`, true));
} catch (e) {
results.push(check(`cmd 命令`, false, '未安装'));
}
});
console.log('─'.repeat(50));
const passCount = results.filter(Boolean).length;
const totalCount = results.length;
console.log(`\n📊 检测结果: passCount/totalCount 通过\n`);
if (passCount === totalCount) {
console.log(`GREEN✨ 环境完美，可以开始使用 OpenClaw！RESET\n`);
} else if (passCount >= totalCount * 0.7) {
console.log(`YELLOW⚠️ 部分功能可能受限，建议修复上述问题RESET\n`);
} else {
console.log(`RED❌ 环境不满足要求，请先安装必要的依赖RESET\n`);
}
// 推荐下一步
console.log('📖 推荐阅读:');
console.log(' OpenClaw 文档: https://docs.openclaw.ai');
console.log(' 中文教程: 运行 node setup-ai.js deepseek\n');
FILE:package.json
{
"name": "openclaw-cn-installer",
"version": "1.0.1",
"description": "OpenClaw 中文安装配置助手 - 一键检测环境、配置国产AI模型、国内镜像加速",
"main": "check-env.js",
"bin": {
"openclaw-cn-check": "./check-env.js",
"openclaw-cn-setup": "./setup-ai.js",
"openclaw-cn-test": "./test-connection.js"
},
"scripts": {
"check": "node check-env.js",
"setup": "node setup-ai.js",
"test": "node test-connection.js"
},
"keywords": [
"openclaw",
"chinese",
"installer",
"deepseek",
"zhipu",
"qwen",
"ai",
"agent",
"setup"
],
"author": "OpenClaw CN",
"license": "MIT",
"repository": {
"type": "git",
"url": "https://github.com/openclaw-cn/openclaw-cn-installer"
},
"engines": {
"node": ">=18.0.0"
}
}
FILE:setup-ai.js
#!/usr/bin/env node
/**
* OpenClaw CN Installer - AI Model Setup
* 配置国产 AI 模型（DeepSeek/智谱/通义千问）
*/
const fs = require('fs');
const path = require('path');
const os = require('os');
const readline = require('readline');
const openclawDir = path.join(os.homedir(), '.openclaw');
const envFile = path.join(openclawDir, '.env');
const configFile = path.join(openclawDir, 'config.json');
const MODELS = {
deepseek: {
name: 'DeepSeek V3',
envKey: 'DEEPSEEK_API_KEY',
envUrl: 'https://api.deepseek.com',
model: 'deepseek-chat',
price: '¥0.27/M tokens (输入)',
getUrl: 'https://platform.deepseek.com',
},
zhipu: {
name: '智谱 GLM-4',
envKey: 'ZHIPU_API_KEY',
envUrl: 'https://open.bigmodel.cn/api/paas/v4',
model: 'glm-4',
price: '¥0.1/M tokens',
getUrl: 'https://open.bigmodel.cn',
},
qwen: {
name: '阿里通义千问',
envKey: 'DASHSCOPE_API_KEY',
envUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
model: 'qwen-plus',
price: '¥0.3/M tokens',
getUrl: 'https://dashscope.console.aliyun.com',
},
};
function ensureDir() {
if (!fs.existsSync(openclawDir)) {
fs.mkdirSync(openclawDir, { recursive: true });
console.log('📁 创建配置目录:', openclawDir);
}
}
function loadEnv() {
if (fs.existsSync(envFile)) {
const content = fs.readFileSync(envFile, 'utf-8');
const env = {};
content.split('\n').forEach(line => {
const [key, ...rest] = line.split('=');
if (key && rest.length) {
env[key.trim()] = rest.join('=').trim();
}
});
return env;
}
return {};
}
function saveEnv(env) {
const content = Object.entries(env)
.map(([k, v]) => `k=v`)
.join('\n');
fs.writeFileSync(envFile, content + '\n');
console.log('💾 保存配置:', envFile);
}
function updateConfig(model, modelId) {
const config = fs.existsSync(configFile)
? JSON.parse(fs.readFileSync(configFile, 'utf-8'))
: {};
config.model = config.model || {};
config.model.provider = model;
config.model.model = modelId;
fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
console.log('⚙️ 更新主配置:', configFile);
}
async function prompt(rl, question) {
return new Promise(resolve => {
rl.question(question, answer => {
resolve(answer.trim());
});
});
}
async function setupModel(modelKey) {
const model = MODELS[modelKey];
if (!model) {
console.error('❌ 未知模型:', modelKey);
console.log('支持的模型:', Object.keys(MODELS).join(', '));
process.exit(1);
}
console.log(`\n🤖 配置 model.name\n`);
console.log(` 价格: model.price`);
console.log(` 获取 API Key: model.getUrl\n`);
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
try {
const apiKey = await prompt(rl, `请输入 model.envKey: `);
if (!apiKey) {
console.log('⚠️ 跳过配置（未输入 API Key）');
return false;
}
// 保存到 .env
const env = loadEnv();
env[model.envKey] = apiKey;
saveEnv(env);
// 更新 config.json
updateConfig(modelKey, model.model);
console.log(`\n✅ model.name 配置完成！\n`);
return true;
} finally {
rl.close();
}
}
async function main() {
const args = process.argv.slice(2);
const target = args[0] || 'help';
ensureDir();
if (target === 'help' || target === '--help' || target === '-h') {
console.log(`
用法: node setup-ai.js <model>
支持的模型:
deepseek - DeepSeek V3 (推荐，性价比最高)
zhipu - 智谱 GLM-4 (中文能力强)
qwen - 阿里通义千问 (多模态)
all - 配置全部模型
示例:
node setup-ai.js deepseek
node setup-ai.js all
`);
return;
}
if (target === 'all') {
for (const key of Object.keys(MODELS)) {
await setupModel(key);
}
} else {
await setupModel(target);
}
console.log('📖 下一步:');
console.log(' 1. 运行 node test-connection.js 测试连接');
console.log(' 2. 运行 openclaw run 启动 OpenClaw\n');
}
main().catch(console.error);
FILE:test-connection.js
#!/usr/bin/env node
/**
* OpenClaw CN Installer - Connection Tester
* 测试 AI 模型 API 连接是否正常
*/
const https = require('https');
const fs = require('fs');
const path = require('path');
const os = require('os');
const GREEN = '\x1b[32m';
const RED = '\x1b[31m';
const YELLOW = '\x1b[33m';
const RESET = '\x1b[0m';
const openclawDir = path.join(os.homedir(), '.openclaw');
const envFile = path.join(openclawDir, '.env');
const API_ENDPOINTS = {
DEEPSEEK_API_KEY: {
name: 'DeepSeek',
url: 'api.deepseek.com',
path: '/v1/chat/completions',
model: 'deepseek-chat',
},
ZHIPU_API_KEY: {
name: '智谱 GLM',
url: 'open.bigmodel.cn',
path: '/api/paas/v4/chat/completions',
model: 'glm-4-flash',
},
DASHSCOPE_API_KEY: {
name: '通义千问',
url: 'dashscope.aliyuncs.com',
path: '/compatible-mode/v1/chat/completions',
model: 'qwen-turbo',
},
};
function loadEnv() {
if (!fs.existsSync(envFile)) {
return {};
}
const content = fs.readFileSync(envFile, 'utf-8');
const env = {};
content.split('\n').forEach(line => {
const [key, ...rest] = line.split('=');
if (key && rest.length) {
env[key.trim()] = rest.join('=').trim();
}
});
return env;
}
function testAPI(name, apiKey, config) {
return new Promise((resolve) => {
const startTime = Date.now();
const data = JSON.stringify({
model: config.model,
messages: [{ role: 'user', content: 'Hi' }],
max_tokens: 5,
});
const options = {
hostname: config.url,
port: 443,
path: config.path,
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer apiKey`,
'Content-Length': Buffer.byteLength(data),
},
timeout: 10000,
};
const req = https.request(options, (res) => {
let body = '';
res.on('data', chunk => body += chunk);
res.on('end', () => {
const latency = Date.now() - startTime;
if (res.statusCode === 200) {
console.log(`GREEN✅ name API: 连接成功 (latencyms)RESET`);
resolve(true);
} else if (res.statusCode === 401) {
console.log(`RED❌ name API: API Key 无效RESET`);
resolve(false);
} else if (res.statusCode === 429) {
console.log(`YELLOW⚠️ name API: 请求频率限制 (但连接正常)RESET`);
resolve(true);
} else {
console.log(`RED❌ name API: HTTP res.statusCodeRESET`);
resolve(false);
}
});
});
req.on('error', (e) => {
console.log(`RED❌ name API: e.messageRESET`);
resolve(false);
});
req.on('timeout', () => {
req.destroy();
console.log(`RED❌ name API: 超时RESET`);
resolve(false);
});
req.write(data);
req.end();
});
}
async function main() {
console.log('\n🔌 测试 AI 模型连接\n');
console.log('─'.repeat(50));
const env = loadEnv();
if (Object.keys(env).length === 0) {
console.log(`YELLOW⚠️ 未找到配置文件RESET`);
console.log('请先运行: node setup-ai.js deepseek\n');
return;
}
const results = [];
for (const [key, config] of Object.entries(API_ENDPOINTS)) {
const apiKey = env[key];
if (apiKey) {
const success = await testAPI(config.name, apiKey, config);
results.push({ name: config.name, success });
}
}
if (results.length === 0) {
console.log(`YELLOW⚠️ 未配置任何 AI 模型RESET`);
console.log('请运行: node setup-ai.js <model>\n');
return;
}
console.log('─'.repeat(50));
const passCount = results.filter(r => r.success).length;
console.log(`\n📊 测试结果: passCount/results.length 连接成功\n`);
if (passCount === results.length) {
console.log(`GREEN✨ 所有模型连接正常，可以开始使用！RESET`);
console.log('启动 OpenClaw: openclaw run\n');
}
}
main().catch(console.error);Simple memory management for OpenClaw. Save, retrieve, and search important information. Store facts, decisions, preferences, and anything you want to rememb...
---
name: openclaw-memorize
description: Simple memory management for OpenClaw. Save, retrieve, and search important information. Store facts, decisions, preferences, and anything you want to remember across sessions. Use when you need to persist information for future reference.
---
# OpenClaw Memorize
Store and retrieve important information across sessions. Never forget a decision or preference again.
## Installation
```bash
npx clawhub@latest install openclaw-memorize
```
## Usage
```bash
# Save a memory
node ~/.openclaw/skills/openclaw-memorize/memorize.js save "key" "value"
# Retrieve a memory
node ~/.openclaw/skills/openclaw-memorize/memorize.js get "key"
# List all memories
node ~/.openclaw/skills/openclaw-memorize/memorize.js list
# Search memories
node ~/.openclaw/skills/openclaw-memorize/memorize.js search "keyword"
# Delete a memory
node ~/.openclaw/skills/openclaw-memorize/memorize.js delete "key"
```
## Features
- ✅ Save key-value memories
- ✅ Retrieve memories by key
- ✅ Search memory contents
- ✅ List all stored memories
- ✅ Delete unwanted memories
- ✅ Persistent storage in workspace
## Examples
```bash
# Save a decision
node ~/.openclaw/skills/openclaw-memorize/memorize.js save "model-choice" "Use Claude Sonnet 4.6 for code review"
# Save a preference
node ~/.openclaw/skills/openclaw-memorize/memorize.js save "preferred-editor" "Cursor"
# Retrieve a memory
node ~/.openclaw/skills/openclaw-memorize/memorize.js get "model-choice"
# Search memories
node ~/.openclaw/skills/openclaw-memorize/memorize.js search "editor"
# List all memories
node ~/.openclaw/skills/openclaw-memorize/memorize.js list
```
## Use Cases
- 📝 **Project decisions**: Remember important technical choices
- 👤 **User preferences**: Store settings and preferences
- 📊 **Key metrics**: Track important numbers
- 💡 **Ideas**: Capture thoughts for later
- 🔗 **Links**: Save important URLs
## Need Help?
If you need help with OpenClaw:
- 📧 **Installation Service**: ¥99-299
- 🔗 **Landing Page**: https://yang1002378395-cmyk.github.io/openclaw-install-service/
## License
MIT
FILE:memorize.js
#!/usr/bin/env node
/**
* Simple Memory Management
* Save, retrieve, and search memories
*/
const fs = require('fs');
const path = require('path');
const MEMORIES_FILE = path.join(process.env.HOME || process.env.USERPROFILE, '.openclaw', 'workspace', 'memories.json');
// Load memories from file
function loadMemories() {
try {
if (fs.existsSync(MEMORIES_FILE)) {
const data = fs.readFileSync(MEMORIES_FILE, 'utf8');
return JSON.parse(data);
}
return {};
} catch (error) {
return {};
}
}
// Save memories to file
function saveMemories(memories) {
const dir = path.dirname(MEMORIES_FILE);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
fs.writeFileSync(MEMORIES_FILE, JSON.stringify(memories, null, 2));
}
// Save a memory
function saveMemory(key, value) {
const memories = loadMemories();
memories[key] = {
value,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString()
};
saveMemories(memories);
console.log(`✅ Saved memory: key`);
console.log(` Value: value`);
}
// Get a memory
function getMemory(key) {
const memories = loadMemories();
const memory = memories[key];
if (!memory) {
console.log(`❌ Memory not found: key`);
return;
}
console.log(`📝 key`);
console.log(` Value: memory.value`);
console.log(` Updated: new Date(memory.updatedAt).toLocaleString()`);
}
// List all memories
function listMemories() {
const memories = loadMemories();
const keys = Object.keys(memories);
if (keys.length === 0) {
console.log('📝 No memories yet. Save one with "node memorize.js save <key> <value>"');
return;
}
console.log('\n📝 Saved Memories');
console.log('─'.repeat(80));
// Sort by updatedAt (most recent first)
const sorted = keys.sort((a, b) => {
return new Date(memories[b].updatedAt) - new Date(memories[a].updatedAt);
});
sorted.forEach(key => {
const memory = memories[key];
const value = memory.value.length > 60 ? memory.value.substring(0, 60) + '...' : memory.value;
const updated = new Date(memory.updatedAt).toLocaleString();
console.log(`🔑 key`);
console.log(` value`);
console.log(` 📅 updated`);
console.log();
});
}
// Search memories
function searchMemories(keyword) {
const memories = loadMemories();
const keys = Object.keys(memories);
const keywordLower = keyword.toLowerCase();
const matches = keys.filter(key => {
const memory = memories[key];
return key.toLowerCase().includes(keywordLower) ||
memory.value.toLowerCase().includes(keywordLower);
});
if (matches.length === 0) {
console.log(`🔍 No memories found matching: keyword`);
return;
}
console.log(`\n🔍 Search results for "keyword"`);
console.log('─'.repeat(80));
matches.forEach(key => {
const memory = memories[key];
const value = memory.value.length > 60 ? memory.value.substring(0, 60) + '...' : memory.value;
const updated = new Date(memory.updatedAt).toLocaleString();
console.log(`🔑 key`);
console.log(` value`);
console.log(` 📅 updated`);
console.log();
});
console.log(`\n✅ Found matches.length match''\n`);
}
// Delete a memory
function deleteMemory(key) {
const memories = loadMemories();
if (!memories[key]) {
console.log(`❌ Memory not found: key`);
return;
}
delete memories[key];
saveMemories(memories);
console.log(`🗑️ Deleted memory: key`);
}
// Show help
function showHelp() {
console.log(`
📝 OpenClaw Memorize
Usage:
node memorize.js save <key> <value>
node memorize.js get <key>
node memorize.js list
node memorize.js search <keyword>
node memorize.js delete <key>
Examples:
node memorize.js save "model-choice" "Use Claude Sonnet 4.6"
node memorize.js get "model-choice"
node memorize.js list
node memorize.js search "model"
node memorize.js delete "model-choice"
Use Cases:
📝 Project decisions
👤 User preferences
📊 Key metrics
💡 Ideas
🔗 Links
`);
}
// Main function
function main() {
const args = process.argv.slice(2);
const command = args[0];
switch (command) {
case 'save': {
const key = args[1];
const value = args.slice(2).join(' ');
if (!key || !value) {
console.log('❌ Please provide both key and value');
showHelp();
process.exit(1);
}
saveMemory(key, value);
break;
}
case 'get': {
const key = args[1];
if (!key) {
console.log('❌ Please provide a key');
showHelp();
process.exit(1);
}
getMemory(key);
break;
}
case 'list':
case 'ls':
listMemories();
break;
case 'search': {
const keyword = args[1];
if (!keyword) {
console.log('❌ Please provide a search keyword');
showHelp();
process.exit(1);
}
searchMemories(keyword);
break;
}
case 'delete':
case 'del': {
const key = args[1];
if (!key) {
console.log('❌ Please provide a key');
showHelp();
process.exit(1);
}
deleteMemory(key);
break;
}
default:
showHelp();
break;
}
}
main();
Simple task reminder for OpenClaw agents. Create, list, and manage tasks with priority levels. Use for tracking to-dos and getting reminders for important wo...
---
name: openclaw-task-reminder
description: Simple task reminder for OpenClaw agents. Create, list, and manage tasks with priority levels. Use for tracking to-dos and getting reminders for important work. Keep your workspace organized and never miss deadlines.
---
# OpenClaw Task Reminder
Simple task management for your OpenClaw workflow. Track to-dos, set priorities, and stay organized.
## Installation
```bash
npx clawhub@latest install openclaw-task-reminder
```
## Usage
```bash
# Add a new task
node ~/.openclaw/skills/openclaw-task-reminder/task.js add "Your task description"
# List all tasks
node ~/.openclaw/skills/openclaw-task-reminder/task.js list
# Mark task as done
node ~/.openclaw/skills/openclaw-task-reminder/task.js done <task_id>
# Clear completed tasks
node ~/.openclaw/skills/openclaw-task-reminder/task.js clear
```
## Features
- ✅ Add tasks with priorities (high/medium/low)
- ✅ List tasks by priority
- ✅ Mark tasks as done
- ✅ Persistent storage in workspace
- ✅ Simple and fast
## Priority Levels
- 🔴 **High**: Urgent tasks that need immediate attention
- 🟡 **Medium**: Regular tasks to complete today
- 🟢 **Low**: Nice-to-have tasks for later
## Examples
```bash
# Add high priority task
node ~/.openclaw/skills/openclaw-task-reminder/task.js add "Review PR #123" --priority high
# List all tasks
node ~/.openclaw/skills/openclaw-task-reminder/task.js list
# Mark task as done
node ~/.openclaw/skills/openclaw-task-reminder/task.js done 1
```
## Need Help?
If you need help with OpenClaw:
- 📧 **Installation Service**: ¥99-299
- 🔗 **Landing Page**: https://yang1002378395-cmyk.github.io/openclaw-install-service/
## License
MIT
FILE:task.js
#!/usr/bin/env node
/**
* Simple Task Reminder
* Manage tasks with priorities
*/
const fs = require('fs');
const path = require('path');
const TASKS_FILE = path.join(process.env.HOME || process.env.USERPROFILE, '.openclaw', 'workspace', 'tasks.json');
// Load tasks from file
function loadTasks() {
try {
if (fs.existsSync(TASKS_FILE)) {
const data = fs.readFileSync(TASKS_FILE, 'utf8');
return JSON.parse(data);
}
return [];
} catch (error) {
return [];
}
}
// Save tasks to file
function saveTasks(tasks) {
const dir = path.dirname(TASKS_FILE);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
fs.writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
}
// Get priority emoji
function getPriorityEmoji(priority) {
switch (priority) {
case 'high': return '🔴';
case 'medium': return '🟡';
case 'low': return '🟢';
default: return '⚪';
}
}
// Get priority order
function getPriorityOrder(priority) {
switch (priority) {
case 'high': return 1;
case 'medium': return 2;
case 'low': return 3;
default: return 4;
}
}
// Add a new task
function addTask(description, priority = 'medium') {
const tasks = loadTasks();
const newTask = {
id: Date.now(),
description,
priority: priority.toLowerCase(),
status: 'pending',
createdAt: new Date().toISOString()
};
tasks.push(newTask);
saveTasks(tasks);
console.log(`✅ Task added: description (getPriorityEmoji(newTask.priority) newTask.priority)`);
}
// List all tasks
function listTasks() {
const tasks = loadTasks();
if (tasks.length === 0) {
console.log('📋 No tasks yet. Add one with "node task.js add <description>"');
return;
}
// Sort by status (pending first), then priority
const sorted = tasks.sort((a, b) => {
if (a.status !== b.status) {
return a.status === 'pending' ? -1 : 1;
}
return getPriorityOrder(a.priority) - getPriorityOrder(b.priority);
});
console.log('\n📋 Task List');
console.log('─'.repeat(80));
sorted.forEach(task => {
const status = task.status === 'pending' ? '⬜' : '✅';
const priority = getPriorityEmoji(task.priority);
const desc = task.description.length > 50 ? task.description.substring(0, 50) + '...' : task.description;
console.log(`status priority desc`);
});
console.log('─'.repeat(80));
const pendingCount = tasks.filter(t => t.status === 'pending').length;
console.log(`\n📊 pendingCount pending task''\n`);
}
// Mark task as done
function doneTask(taskId) {
const tasks = loadTasks();
const task = tasks.find(t => t.id === parseInt(taskId));
if (!task) {
console.log('❌ Task not found');
return;
}
task.status = 'done';
task.completedAt = new Date().toISOString();
saveTasks(tasks);
console.log(`✅ Task completed: task.description`);
}
// Clear completed tasks
function clearTasks() {
const tasks = loadTasks();
const completedCount = tasks.filter(t => t.status === 'done').length;
if (completedCount === 0) {
console.log('📋 No completed tasks to clear');
return;
}
const remaining = tasks.filter(t => t.status !== 'done');
saveTasks(remaining);
console.log(`🧹 Cleared completedCount completed task''`);
}
// Show help
function showHelp() {
console.log(`
📋 OpenClaw Task Reminder
Usage:
node task.js add "<description>" [--priority high|medium|low]
node task.js list
node task.js done <task_id>
node task.js clear
Examples:
node task.js add "Review PR #123" --priority high
node task.js add "Write documentation"
node task.js list
node task.js done 1234567890
node task.js clear
Priorities:
🔴 high - Urgent tasks
🟡 medium - Regular tasks
🟢 low - Nice-to-have tasks
`);
}
// Main function
function main() {
const args = process.argv.slice(2);
const command = args[0];
switch (command) {
case 'add': {
let description = args[1];
let priority = 'medium';
// Parse flags
const priorityFlag = args.indexOf('--priority');
if (priorityFlag !== -1 && args[priorityFlag + 1]) {
priority = args[priorityFlag + 1];
}
if (!description) {
console.log('❌ Please provide a task description');
showHelp();
process.exit(1);
}
addTask(description, priority);
break;
}
case 'list':
case 'ls':
listTasks();
break;
case 'done': {
const taskId = args[1];
if (!taskId) {
console.log('❌ Please provide a task ID');
showHelp();
process.exit(1);
}
doneTask(taskId);
break;
}
case 'clear':
clearTasks();
break;
default:
showHelp();
break;
}
}
main();
AI model cost calculator. Compare pricing across Claude, GPT, DeepSeek, and other AI models. Calculate token costs, optimize API spending, and find the best...
---
name: openclaw-ai-cost-calc
description: AI model cost calculator. Compare pricing across Claude, GPT, DeepSeek, and other AI models. Calculate token costs, optimize API spending, and find the best value model for your use case. Use when choosing AI models or estimating API costs.
---
# AI Cost Calculator
Compare AI model pricing and calculate costs. Find the best value model for your needs.
## Installation
```bash
npx clawhub@latest install openclaw-ai-cost-calc
```
## Usage
Run the calculator:
```bash
node ~/.openclaw/skills/openclaw-ai-cost-calc/calc.js
```
## Features
- ✅ Compare pricing across major AI models
- ✅ Calculate token costs
- ✅ Find best value for your use case
- ✅ Interactive prompts
- ✅ Support for Claude, GPT, DeepSeek, and more
## Example Models Supported
- Claude Opus 4.6: $5.00 / $25.00 (¥175-210 per万tokens)
- Claude Sonnet 4.6: $3.00 / $15.00 (¥99-126 per万tokens)
- GPT-5.4: $2.50 / $15.00 (¥140-175 per万tokens)
- GPT-5 mini: $0.25 / $2.00 (¥18 per万tokens)
- DeepSeek-V3: ¥0.27 / ¥1.08 (¥1.4 per万tokens)
## Why Use This?
Save money by choosing the right AI model:
- DeepSeek is 150x cheaper than Claude Opus
- GPT-5 mini is 10x cheaper than GPT-5.4
- Find the best performance/price ratio
## Need Help?
If you need help with OpenClaw:
- 📧 **Installation Service**: ¥99-299
- 🔗 **Landing Page**: https://yang1002378395-cmyk.github.io/openclaw-install-service/
## License
MIT
FILE:calc.js
#!/usr/bin/env node
/**
* AI Cost Calculator
* Compare pricing across AI models and calculate costs
*/
const models = {
'claude-opus-4.6': {
name: 'Claude Opus 4.6',
inputPrice: 5.00,
outputPrice: 25.00,
currency: 'USD'
},
'claude-sonnet-4.6': {
name: 'Claude Sonnet 4.6',
inputPrice: 3.00,
outputPrice: 15.00,
currency: 'USD'
},
'gpt-5.4': {
name: 'GPT-5.4',
inputPrice: 2.50,
outputPrice: 15.00,
currency: 'USD'
},
'gpt-5-mini': {
name: 'GPT-5 mini',
inputPrice: 0.25,
outputPrice: 2.00,
currency: 'USD'
},
'deepseek-v3': {
name: 'DeepSeek V3',
inputPrice: 0.00027,
outputPrice: 0.00108,
currency: 'CNY'
}
};
function calculateCost(modelId, inputTokens, outputTokens) {
const model = models[modelId];
if (!model) {
return null;
}
const inputCost = (inputTokens / 1000000) * model.inputPrice;
const outputCost = (outputTokens / 1000000) * model.outputPrice;
const totalCost = inputCost + outputCost;
return {
model: model.name,
inputCost: model.currency === 'USD' ? `$inputCost.toFixed(4)` : `¥inputCost.toFixed(4)`,
outputCost: model.currency === 'USD' ? `$outputCost.toFixed(4)` : `¥outputCost.toFixed(4)`,
totalCost: model.currency === 'USD' ? `$totalCost.toFixed(4)` : `¥totalCost.toFixed(4)`,
currency: model.currency
};
}
function formatNumber(num) {
return num.toLocaleString();
}
function compareModels(inputTokens, outputTokens) {
console.log('\n📊 AI Model Cost Comparison');
console.log('─'.repeat(80));
console.log(`Input: formatNumber(inputTokens) tokens | Output: formatNumber(outputTokens) tokens`);
console.log('─'.repeat(80));
console.log(`\n'Model'.padEnd(25) 'Input'.padEnd(12) 'Output'.padEnd(12) 'Total'.padEnd(12) 'Currency'`);
console.log('─'.repeat(80));
const results = [];
for (const [id, model] of Object.entries(models)) {
const cost = calculateCost(id, inputTokens, outputTokens);
if (cost) {
console.log(`cost.model.padEnd(25) cost.inputCost.padEnd(12) cost.outputCost.padEnd(12) cost.totalCost.padEnd(12) cost.currency`);
results.push({ id, ...cost });
}
}
console.log('─'.repeat(80));
// Sort by total cost and find cheapest
const sorted = results.sort((a, b) => {
// Normalize to USD for comparison (rough estimate: 1 USD = 7 CNY)
const aCostUSD = a.currency === 'USD' ? parseFloat(a.totalCost.slice(1)) : parseFloat(a.totalCost.slice(1)) / 7;
const bCostUSD = b.currency === 'USD' ? parseFloat(b.totalCost.slice(1)) : parseFloat(b.totalCost.slice(1)) / 7;
return aCostUSD - bCostUSD;
});
const cheapest = sorted[0];
console.log(`\n💰 Best Value: cheapest.model - cheapest.totalCost\n`);
// Calculate savings vs most expensive
const expensive = sorted[sorted.length - 1];
const cheapestUSD = cheapest.currency === 'USD' ? parseFloat(cheapest.totalCost.slice(1)) : parseFloat(cheapest.totalCost.slice(1)) / 7;
const expensiveUSD = expensive.currency === 'USD' ? parseFloat(expensive.totalCost.slice(1)) : parseFloat(expensive.totalCost.slice(1)) / 7;
const savings = expensiveUSD - cheapestUSD;
if (savings > 0) {
console.log(`💡 Savings vs expensive.model: '¥'savings.toFixed(4) (((savings / expensiveUSD) * 100).toFixed(1)%)\n`);
}
}
// Default comparison
function main() {
const args = process.argv.slice(2);
let inputTokens = 1000000; // 1M input tokens
let outputTokens = 1000000; // 1M output tokens
if (args.length > 0) {
inputTokens = parseInt(args[0]);
}
if (args.length > 1) {
outputTokens = parseInt(args[1]);
}
if (isNaN(inputTokens) || isNaN(outputTokens)) {
console.log('Usage: node calc.js [inputTokens] [outputTokens]');
console.log('Example: node calc.js 1000000 500000');
process.exit(1);
}
compareModels(inputTokens, outputTokens);
}
main();
Free web search for OpenClaw without API keys. Uses a free search service to search the web and get results. No Brave/Perplexity API key required. Use when y...
---
name: openclaw-free-search
description: Free web search for OpenClaw without API keys. Uses a free search service to search the web and get results. No Brave/Perplexity API key required. Use when you need to search the web but don't have API keys configured.
---
# OpenClaw Free Web Search
Search the web without API keys. This skill provides free web search capability using a no-cost search service.
## Installation
```bash
npx clawhub@latest install openclaw-free-search
```
## Usage
After installation, use the search script:
```bash
node ~/.openclaw/skills/openclaw-free-search/search.js 'your search query'
```
## Features
- ✅ No API keys required
- ✅ English and Chinese queries supported
- ✅ JSON output available (with --json flag)
- ✅ Fast and reliable
## Examples
```bash
# Basic search
node ~/.openclaw/skills/openclaw-free-search/search.js 'OpenClaw installation guide'
# JSON output
node ~/.openclaw/skills/openclaw-free-search/search.js 'AI agent automation' --json
```
## Need Help?
If you need help with OpenClaw:
- 📧 **Installation Service**: ¥99-299
- 🔗 **Landing Page**: https://yang1002378395-cmyk.github.io/openclaw-install-service/
## License
MIT
FILE:search.js
#!/usr/bin/env node
/**
* 免 Key 网络搜索（嫁接层）
* 用 DuckDuckGo Instant Answer API，无需注册。
* OpenClaw agent 在 web_search 不可用时，可 exec 本脚本获取检索结果。
*
* 用法: node free_search.js "你的搜索词"
* 或: node free_search.js "搜索词" --json
*/
const query = process.argv[2];
if (!query || query.startsWith('-')) {
console.error('用法: node free_search.js "搜索词" [--json]');
process.exit(1);
}
const wantJson = process.argv.includes('--json');
const url = `https://api.duckduckgo.com/?q=encodeURIComponent(query)&format=json&no_html=1`;
async function main() {
let data;
try {
const res = await fetch(url, {
headers: { 'User-Agent': 'Mozilla/5.0 (compatible; OpenClaw/1.0)' },
});
if (!res.ok) throw new Error(`HTTP res.status`);
data = await res.json();
} catch (fetchErr) {
// 国内可能无法直连 DuckDuckGo，尝试用 curl（会走系统代理若有）
try {
const { execFileSync } = require('child_process');
const out = execFileSync('curl', ['-s', '-L', '--max-time', '15', url], {
encoding: 'utf-8',
maxBuffer: 1024 * 1024,
});
data = JSON.parse(out);
} catch (curlErr) {
console.error('搜索失败: 无法访问 DuckDuckGo（若在国内需代理或 VPN）', fetchErr?.message || fetchErr);
process.exit(2);
}
}
try {
const out = {
query: data.Heading || query,
abstract: data.Abstract ? { text: data.Abstract, url: data.AbstractURL } : null,
related: (data.RelatedTopics || [])
.filter((r) => r.Text)
.slice(0, 10)
.map((r) => ({ text: r.Text, url: r.FirstURL || null })),
};
if (wantJson) {
console.log(JSON.stringify(out, null, 2));
return;
}
// 纯文本，方便 agent 直接读
const lines = [];
if (out.abstract) {
lines.push('[摘要] ' + out.abstract.text);
if (out.abstract.url) lines.push('链接: ' + out.abstract.url);
lines.push('');
}
out.related.forEach((r, i) => {
lines.push(`i + 1. r.text`);
if (r.url) lines.push(' ' + r.url);
});
console.log(lines.join('\n') || '未找到相关结果，可换关键词再试。');
} catch (e) {
console.error('解析失败:', e.message);
process.exit(2);
}
}
main();
Quick health check for OpenClaw installations by Yang. Checks Node.js version, Gateway status, config files, port conflicts, and common problems. Use when tr...
---
name: yang-openclaw-health
description: Quick health check for OpenClaw installations by Yang. Checks Node.js version, Gateway status, config files, port conflicts, and common problems. Use when troubleshooting OpenClaw installation or configuration issues.
---
# OpenClaw Health Check by Yang
Quick diagnostics for OpenClaw installation issues. Run this to check common problems.
## Installation
```bash
npx clawhub@latest install yang-openclaw-health
```
## What it checks
- ✅ Node.js version (requires 18+)
- ✅ Gateway status (running/stopped)
- ✅ Config file existence
- ✅ Port conflicts (default 3000)
- ✅ Environment variables
- ✅ Permission issues
## Usage
After installation, run:
```bash
node ~/.openclaw/skills/yang-openclaw-health/diagnose.js
```
## Need Help?
If diagnostics show issues you can't fix:
- 📧 **Installation Service**: ¥99-299
- 🔗 **Landing Page**: https://yang1002378395-cmyk.github.io/openclaw-install-service/
## License
MIT
FILE:diagnose.js
#!/usr/bin/env node
/**
* OpenClaw Installation Diagnostics
* Run this script to identify common installation issues
*/
const { execSync, existsSync, readFileSync } = require('fs');
const fs = require('fs');
const path = require('path');
const os = require('os');
const CHECKS = [];
const HOME = os.homedir();
const OPENCLAW_DIR = path.join(HOME, '.openclaw');
const CONFIG_FILE = path.join(OPENCLAW_DIR, 'gateway.json');
function check(name, fn) {
try {
const result = fn();
CHECKS.push({ name, status: '✅', message: result || 'OK' });
} catch (err) {
CHECKS.push({ name, status: '❌', message: err.message });
}
}
console.log('\n🔍 OpenClaw Installation Diagnostics\n');
console.log('='.repeat(50));
// Check 1: Node.js version
check('Node.js Version', () => {
const version = process.version;
const major = parseInt(version.slice(1).split('.')[0]);
if (major < 18) throw new Error(`Node version - requires 18+`);
return `Node version ✓`;
});
// Check 2: OpenClaw directory
check('OpenClaw Directory', () => {
if (!existsSync(OPENCLAW_DIR)) throw new Error('Directory not found');
return `Found at OPENCLAW_DIR`;
});
// Check 3: Gateway config
check('Gateway Config', () => {
if (!existsSync(CONFIG_FILE)) throw new Error('gateway.json not found');
const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
return `Config exists with Object.keys(config).length settings`;
});
// Check 4: Gateway status
check('Gateway Status', () => {
try {
const result = execSync('pgrep -f "openclaw gateway" || echo "not_running"', { encoding: 'utf8' });
if (result.includes('not_running')) {
return 'Gateway not running (run: openclaw gateway start)';
}
return 'Gateway running ✓';
} catch {
return 'Gateway not running (run: openclaw gateway start)';
}
});
// Check 5: Port 3000
check('Port 3000', () => {
try {
const result = execSync('lsof -i :3000 2>/dev/null || echo "free"', { encoding: 'utf8' });
if (result.includes('free')) return 'Port 3000 available ✓';
return 'Port 3000 in use (check for conflicts)';
} catch {
return 'Port check skipped (lsof not available)';
}
});
// Check 6: Environment
check('Environment', () => {
const env = process.env;
const hasModel = env.OPENAI_API_KEY || env.ANTHROPIC_API_KEY || env.DEEPSEEK_API_KEY;
if (!hasModel) return 'No API keys detected (optional)';
return 'API keys configured ✓';
});
// Print results
console.log('\n');
CHECKS.forEach(c => {
console.log(`c.status c.name: c.message`);
});
const failed = CHECKS.filter(c => c.status === '❌');
console.log('\n' + '='.repeat(50));
if (failed.length === 0) {
console.log('\n✅ All checks passed! OpenClaw looks healthy.\n');
} else {
console.log(`\n⚠️ failed.length issue(s) found:\n`);
failed.forEach(c => console.log(` - c.name: c.message`));
console.log('\n💡 Need help? Visit: https://yang1002378395-cmyk.github.io/openclaw-install-service/\n');
}
自动化报销流程，票据识别 + 审批加速。
---
name: ai-intelligent-expense-reimbursement
version: 1.0.0
description: 自动化报销流程，票据识别 + 审批加速。
metadata:
openclaw:
emoji: "🤖"
requires:
bins: []
---
# AI 智能报销管理系统
## 描述
自动化报销流程，票据识别 + 审批加速。
## 功能
- 票据识别（OCR自动识别）
- 智能审批（规则引擎）
- 费用分析（支出统计）
- 合规检查（发票验真）
- 自动打款（财务集成）
## 定价
- 基础版：¥99/月（100 单/月）
- 专业版：¥499/月（1000 单/月）
- 企业版：¥1999/月（无限单）
## 适用场景
- 企业报销
- 差旅费用
- 办公采购
- 员工福利
## 技术栈
- Python + FastAPI
- OCR（票据识别）
- 审批工作流
- 财务 API 集成
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-expense-reimbursement
cd ai-intelligent-expense-reimbursement
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-expense-reimbursement",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-expense-reimbursement",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}
新员工入职，流程自动化。
---
name: ai-intelligent-employee-onboarding
version: 1.0.0
description: 新员工入职，流程自动化。
metadata:
openclaw:
emoji: "🤖"
requires:
bins: []
---
# AI 智能员工入职系统
## 描述
新员工入职，流程自动化。
## 功能
- 入职流程（标准化流程）
- 资料收集（在线填写）
- 设备申请（自动申请）
- 培训安排（自动排课）
- 入职礼包（自动发放）
## 定价
- 基础版：¥49/月（10 人/月）
- 专业版：¥199/月（100 人/月）
- 企业版：¥799/月（无限人数）
## 适用场景
- 新员工入职
- 企业 HR
- 流程自动化
- 体验优化
## 技术栈
- Python + FastAPI
- 流程引擎
- 表单系统
- 通知系统
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-employee-onboarding
cd ai-intelligent-employee-onboarding
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-employee-onboarding",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-employee-onboarding",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}
邮件自动化，发送/接收/分析。
---
name: ai-intelligent-email-automation
version: 1.0.0
description: 邮件自动化，发送/接收/分析。
metadata:
openclaw:
emoji: "⚡"
requires:
bins: []
---
# AI 智能邮件自动化系统
## 描述
邮件自动化，发送/接收/分析。
## 功能
- 批量发送（邮件群发）
- 自动回复（智能回复）
- 邮件分类（自动分类）
- 邮件追踪（已读/点击）
- 模板管理（模板库）
## 定价
- 基础版：¥49/月（500 封/月）
- 专业版：¥199/月（5000 封/月）
- 企业版：¥799/月（无限封）
## 适用场景
- 邮件营销
- 客户通知
- 自动回复
- 邮件管理
## 技术栈
- Python + FastAPI
- SMTP/IMAP
- 模板引擎
- 追踪系统
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-email-automation
cd ai-intelligent-email-automation
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-email-automation",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-email-automation",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}
在线客服，实时聊天 + AI 问答。
---
name: ai-intelligent-live-chat
version: 1.0.0
description: 在线客服，实时聊天 + AI 问答。
metadata:
openclaw:
emoji: "🤖"
requires:
bins: []
---
# AI 智能在线客服系统
## 描述
在线客服，实时聊天 + AI 问答。
## 功能
- 实时聊天（WebSocket）
- AI 问答（GPT集成）
- 多客服接入（客服分配）
- 聊天记录（历史记录）
- 满意度评价（评价系统）
## 定价
- 基础版：¥199/月（3 客服）
- 专业版：¥999/月（30 客服）
- 企业版：¥2999/月（无限客服）
## 适用场景
- 在线客服
- 销售咨询
- 技术支持
- 售后服务
## 技术栈
- Python + FastAPI
- WebSocket
- GPT 集成
- 客服系统
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-live-chat
cd ai-intelligent-live-chat
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-live-chat",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-live-chat",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}
企业知识管理，知识沉淀 + 智能检索。
---
name: ai-intelligent-knowledge-base
version: 1.0.0
description: 企业知识管理，知识沉淀 + 智能检索。
metadata:
openclaw:
emoji: "🤖"
requires:
bins: []
---
# AI 智能知识库系统
## 描述
企业知识管理，知识沉淀 + 智能检索。
## 功能
- 知识沉淀（文档管理）
- 智能检索（语义搜索）
- 知识图谱（关联推荐）
- 知识问答（AI问答）
- 权限管理（分级授权）
## 定价
- 基础版：¥199/月（1000 文档）
- 专业版：¥999/月（10000 文档）
- 企业版：¥2999/月（无限文档）
## 适用场景
- 企业知识库
- 技术文档
- 培训资料
- FAQ 系统
## 技术栈
- Python + FastAPI
- 向量数据库（Milvus）
- 语义搜索（Embedding）
- 知识图谱
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-knowledge-base
cd ai-intelligent-knowledge-base
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-knowledge-base",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-knowledge-base",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}
审计日志，操作记录 + 合规审计。
---
name: ai-intelligent-audit-logging
version: 1.0.0
description: 审计日志，操作记录 + 合规审计。
metadata:
openclaw:
emoji: "🔍"
requires:
bins: []
---
# AI 智能审计日志系统
## 描述
审计日志，操作记录 + 合规审计。
## 功能
- 操作记录（操作日志）
- 审计查询（审计查询）
- 合规检查（合规审计）
- 数据分析（行为分析）
- 报告生成（审计报告）
## 定价
- 基础版：¥99/月（10 万条/月）
- 专业版：¥499/月（100 万条/月）
- 企业版：¥1999/月（无限条）
## 适用场景
- 合规审计
- 操作审计
- 安全审计
- 数据审计
## 技术栈
- Python + FastAPI
- 日志记录
- 审计查询
- 报告生成
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-audit-logging
cd ai-intelligent-audit-logging
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-audit-logging",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-audit-logging",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}
行为分析，动作识别 + 异常检测。
---
name: ai-intelligent-behavior-analysis
version: 1.0.0
description: 行为分析，动作识别 + 异常检测。
metadata:
openclaw:
emoji: "🤖"
requires:
bins: []
---
# AI 智能行为分析系统
## 描述
行为分析，动作识别 + 异常检测。
## 功能
- 动作识别（动作分类）
- 异常行为（打架/跌倒）
- 人群分析（密度/流向）
- 轨迹分析（行为模式）
- 预警推送（实时告警）
## 定价
- 基础版：¥399/月（1 路/月）
- 专业版：¥1999/月（10 路/月）
- 企业版：¥5999/月（无限路）
## 适用场景
- 安防监控
- 工厂安全
- 养老监护
- 校园安全
## 技术栈
- Python + FastAPI
- 行为识别模型
- 视频分析
- 实时告警
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-behavior-analysis
cd ai-intelligent-behavior-analysis
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-behavior-analysis",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-behavior-analysis",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}
备份自动化，自动备份 + 恢复测试。
---
name: ai-intelligent-backup-automation
version: 1.0.9
description: 备份自动化，自动备份 + 恢复测试。
metadata:
openclaw:
emoji: "⚡"
requires:
bins: []
---
# AI 智能备份自动化系统
## 描述
备份自动化，自动备份 + 恢复测试。
## 功能
- 自动备份（定时备份）
- 增量备份（增量备份）
- 备份验证（完整性检查）
- 恢复测试（恢复演练）
- 备份报告（备份统计）
## 定价
- 基础版：¥99/月（1 TB）
- 专业版：¥499/月（10 TB）
- 企业版：¥1999/月（无限量）
## 适用场景
- 数据备份
- 容灾备份
- 云备份
- 本地备份
## 技术栈
- Python + FastAPI
- 备份引擎
- 增量备份
- 恢复测试
## 安装
```bash
git clone https://github.com/openclaw-skills/ai-intelligent-backup-automation
cd ai-intelligent-backup-automation
pip install -r requirements.txt
python app.py
```
---
创建：2026-03-13
作者：OpenClaw Skills Team
FILE:skill.json
{
"name": "ai-intelligent-backup-automation",
"version": "1.0.0",
"description": "AI intelligent ai-intelligent-backup-automation",
"author": "yang1002378395-cmyk",
"tags": ["ai", "intelligent", "automation"]
}