1. 从“搬砖”到“动嘴”：一个骑行爱好者的自动化觉醒

如果你和我一样，是个骑行爱好者，每周都会产生大量的骑行数据——可能是佳明手表导出的.fit文件，可能是Strava、黑鸟这类App的GPX轨迹，又或者是码表里一堆需要手动整理的CSV。日复一日，把这些数据从A处导出，再手动上传、整理到B处（比如自己的数据分析平台、云端备份或者骑行社群），这个过程枯燥、重复，还容易出错。我管这叫“数据搬砖”，纯纯的体力活。

更让人头疼的是，这些数据源和目的地往往协议不一、格式各异。Strava的API有调用限制，本地文件需要解析，有些平台只接受特定格式。手动操作不仅效率低下，一旦流程复杂起来（比如需要先转换格式，再调用某个API，最后还要发个通知），就完全是一场灾难。我曾经尝试过写一些Python脚本来自动化部分流程，但每个脚本都是孤岛，逻辑硬编码在里面，想要调整一个参数或者增加一个步骤，就得重新读代码、改代码、测试，维护成本极高。这感觉就像为了喝杯牛奶，得先养头牛，还得学会挤奶。

直到我遇到了OpenClaw。最初看到这个名字，还以为是某个新的爬虫框架或者SSH工具。深入了解后才发现，它更像是一个“智能体操作中枢”。简单来说，它允许你用自然语言（也就是“动动嘴皮子”）来描述一个任务，比如“把我今天佳明导出的.fit文件，转换成GPX格式，然后上传到我的个人网盘备份，再提取本次骑行的平均速度和距离，发到我的飞书群里”。OpenClaw会理解你的意图，并自动调用、编排一系列底层的工具（它称之为“工具”或“技能”）来完成这个任务，这些工具可以是执行SSH命令、运行Python脚本、调用HTTP API等等。

这个概念瞬间击中了我。这不正是我梦寐以求的“救赎之路”吗？我不再需要关心具体哪个脚本怎么调用、参数如何传递、错误怎么处理。我只需要告诉OpenClaw“我想要什么”，它来负责“怎么做到”。于是，我的目标从“写一个自动上传脚本”变成了“教会OpenClaw如何帮我打理骑行数据”。这条路走下来，有踩坑的郁闷，也有豁然开朗的畅快。这篇文章，就是我这段时间从“手动搬砖工”转型为“自动化指挥官”的完整实践记录，我会详细拆解如何利用OpenClaw构建一个属于你自己的、可自然语言交互的骑行数据自动化流水线。

2. 理解OpenClaw：它不是什么，以及它到底是什么

在开始动手之前，我们必须先统一认知，避免走入误区。根据网络上的搜索热词，很多人对OpenClaw的第一印象是混乱的：有人把它当成SSH客户端（类似Bitvise SSH），有人以为是Python库，还有人遇到了 opencode 、 claude 不是有效命令的错误。这些混淆恰恰说明了理清概念的重要性。

OpenClaw不是SSH工具，也不是一个独立的可执行程序。 你无法在命令行直接输入 openclaw 命令来启动它（那会报错：“无法将‘openclaw’项识别为 cmdlet、函数、脚本文件或可运行程序的名称”）。同样，它也不是VSCode的SSH插件或者Navicat的破解脚本。这些热词反映的是大家在自动化运维、远程开发中遇到的普遍痛点，而OpenClaw旨在从更高层面解决这些问题。

OpenClaw的核心是一个“智能体框架”或“工作流编排器”。 你可以把它想象成一个非常聪明的“项目经理”或“调度中心”。这个项目经理自己不会写代码、不会执行命令，但它手下有一大批身怀绝技的“专家员工”（即工具）。你的角色是“老板”，你只需要用人类语言向项目经理（OpenClaw）下达指令。项目经理会理解你的指令，判断需要哪些专家员工协作，然后指挥他们按顺序工作，并最终把结果汇总给你。

在这个比喻里：

• 你（老板） ：提出需求，例如“处理骑行数据”。
• OpenClaw（项目经理） ：理解需求，分解任务，调度工具。
• 工具/技能（专家员工） ：具体干活的单元。一个工具可能是一个Python函数（负责解析.fit文件），另一个可能是一个Shell命令（负责SCP上传文件），第三个可能是一个HTTP请求（调用飞书Webhook）。

那么，OpenClaw是如何理解人类语言并调度工具的呢？这依赖于其背后的大语言模型（LLM）能力。OpenClaw通常需要与一个LLM服务（如Ollama本地部署的模型，或通过API调用云端模型）协同工作。LLM充当了“自然语言理解与规划引擎”。当你对OpenClaw说“处理骑行数据”时，OpenClaw会将这句话连同可用工具的“能力说明书”（函数签名、描述）一起提交给LLM。LLM会分析出：要完成这个任务，需要先后调用“文件监听工具”、“格式转换工具”、“API上传工具”、“消息通知工具”。

所以， 部署OpenClaw，本质上是部署一个“智能体框架服务” 。它通常以Docker容器、Python包或某种服务的形式运行在后台，等待你的指令。你通过向这个服务发送HTTP请求、使用命令行客户端（CLI）或图形界面来与它交互。这也是为什么直接输入 openclaw 会报错——你缺少了与这个服务交互的“客户端”或者没有正确启动服务本身。

注意：网络热词中提到的 openclaw llamap svr operator(): got exception: { "error": { "code": 400 这类错误，通常是客户端在请求OpenClaw服务时，发送了错误格式或内容的请求导致的，属于API调用层面的问题，而非OpenClaw本身安装失败。

厘清了这一点，我们就能抛开那些干扰信息，专注于如何搭建这个“调度中心”并为其招募“员工”（配置工具），来实现我们的骑行数据自动化。

3. 搭建你的自动化指挥中心：OpenClaw部署实战

部署OpenClaw是第一步，也是劝退很多人的一步。因为它的生态还在快速演进，安装方式可能多样。结合热词中提到的 docker容器部署openclaw 和 ollama安装openclaw教程 ，我推荐目前最稳定、隔离性最好的方式： Docker Compose部署 。这种方式能一次性搞定OpenClaw及其依赖（如LLM服务），避免复杂的本地Python环境配置冲突。

3.1 基础环境准备

你需要一台Linux服务器（云服务器或本地虚拟机均可，Ubuntu 22.04为例），或者一台配置尚可的Mac/Windows电脑（需要安装Docker Desktop）。确保已经安装了最新版的Docker和Docker Compose。

# 检查Docker和Docker Compose是否安装
docker --version
docker-compose --version

如果未安装，请参考官方文档安装。这是后续所有操作的基础。

3.2 获取部署配置文件

OpenClaw社区通常会提供标准的 docker-compose.yml 文件。你需要创建一个专门的工作目录。

mkdir ~/openclaw-ride-data && cd ~/openclaw-ride-data

接下来，你需要获取 docker-compose.yml 文件。由于OpenClaw项目可能更新，建议从其官方Git仓库或最新教程中获取。这里我提供一个概念性的示例，实际部署时请以官方文件为准。

# 示例 docker-compose.yml (请务必核对最新版本)
version: '3.8'
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"
    networks:
      - openclaw-net

  openclaw:
    image: ghcr.io/openclaw/openclaw:latest # 镜像地址可能变化
    container_name: openclaw
    restart: unless-stopped
    depends_on:
      - ollama
    environment:
      - OPENCLAW_LLM_API_BASE=http://ollama:11434/api
      - OPENCLAW_LLM_MODEL=llama3.2:latest # 或 qwen2.5:7b 等，需先在ollama中pull
      - OPENCLAW_SERVER_HOST=0.0.0.0
      - OPENCLAW_SERVER_PORT=8000
    volumes:
      - ./tools:/app/tools # 挂载本地工具目录，非常重要！
      - ./data:/app/data   # 挂载数据目录
    ports:
      - "8000:8000"
    networks:
      - openclaw-net

networks:
  openclaw-net:
    driver: bridge

volumes:
  ollama_data:

这个配置定义了两个服务：

1. ollama ：一个本地运行大模型的容器。我们用它来为OpenClaw提供“大脑”。它监听11434端口。
2. openclaw ：OpenClaw主服务。它依赖ollama，环境变量 OPENCLAW_LLM_API_BASE 告诉它去哪里找LLM。我们将本地的 tools 和 data 目录挂载到容器内，这是后续自定义工具和存放数据的关键。它对外暴露8000端口。

3.3 启动服务与模型拉取

首先，你需要拉取并启动Ollama服务，然后为Ollama下载一个合适的模型。模型不需要太大，7B参数左右的模型（如Llama 3.2、Qwen2.5）在理解工具调用任务上已经足够，且对硬件要求友好。

# 1. 启动服务（后台运行）
docker-compose up -d

# 2. 查看日志，确认服务启动
docker-compose logs -f ollama
docker-compose logs -f openclaw
# 等待片刻，直到看到服务正常启动的信息，没有报错退出。

# 3. 进入ollama容器，拉取模型（也可以在宿主机上操作，如果安装了ollama命令行）
docker exec -it ollama ollama pull llama3.2:latest
# 拉取需要时间，取决于你的网络和模型大小。

3.4 验证部署成功

服务启动并拉取模型后，进行验证。

# 验证OpenClaw API服务是否健康
curl http://localhost:8000/health
# 预期返回一个包含状态信息的JSON，如 {"status": "healthy"}

# 验证Ollama服务及模型是否可用
curl http://localhost:11434/api/tags
# 预期返回已拉取模型的列表JSON

如果以上步骤都成功，那么你的“自动化指挥中心”就已经在 localhost:8000 准备就绪了。接下来，我们将为它配置第一个，也是最重要的“员工”——处理骑行数据的工具。

4. 招募“专家员工”：为OpenClaw编写骑行数据处理工具

OpenClaw本身不会处理.fit或.GPX文件，这些能力需要我们通过“工具”来提供。工具本质上是一个个独立的函数，OpenClaw通过某种协议（如MCP - Model Context Protocol，或简单的Python模块导入）来发现和调用它们。这里我们采用最直观的方式：编写Python工具脚本，并将其放在部署时挂载的 ./tools 目录下。

4.1 设计工具蓝图：我们需要哪些工具？

在动手写代码前，先规划一下整个“骑行数据搬运”流水线需要哪些环节，每个环节对应一个工具：

1. 文件监听与发现工具 ：监控某个指定文件夹（如 ~/Downloads/Rides ），当有新的.fit或.gpx文件放入时，触发流程。
2. 格式解析与转换工具 ：读取.fit文件，解析出轨迹、心率、功率等数据，并能转换为GPX或JSON等通用格式。
3. 数据上传工具 ：将处理好的文件或数据，上传到指定的目的地，如云存储（S3/MinIO）、WebDAV服务器或通过SFTP传到远程服务器。
4. 数据分析与摘要工具 ：从骑行数据中提取关键指标，如骑行时长、距离、平均速度、爬升海拔、平均心率等。
5. 通知工具 ：将处理结果或数据摘要，发送到即时通讯工具，如飞书、钉钉、Slack的Webhook。

我们将先实现最核心的 格式解析转换工具 和 数据摘要工具 。

4.2 实现工具一：Fit文件解析器 ( fit_parser.py )

我们将使用Python的 fitparse 库来解析.fit文件。首先在项目目录下安装依赖并创建工具文件。

# 在宿主机上，进入项目目录
cd ~/openclaw-ride-data
# 创建一个requirements.txt管理依赖
echo -e "fitparse\ngpxpy\nrequests" > requirements.txt
# 如果你希望工具在容器内运行，需要在Dockerfile中安装这些依赖。
# 更简单的方式：在宿主机开发测试，最终通过挂载卷让容器也能访问。
# 我们先在宿主机测试。

pip install -r requirements.txt

创建工具文件 tools/fit_parser.py ：

# tools/fit_parser.py
import json
from typing import Dict, Any, Optional
import fitparse
from gpxpy.gpx import GPX, GPXTrack, GPXTrackSegment, GPXTrackPoint
import gpxpy
from datetime import datetime, timedelta
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def parse_fit_to_summary(fit_file_path: str) -> Dict[str, Any]:
    """
    解析.fit文件，返回骑行摘要信息（核心指标）。
    这是一个OpenClaw工具。

    Args:
        fit_file_path: .fit文件的绝对路径。

    Returns:
        包含骑行摘要信息的字典。
    """
    logger.info(f"开始解析文件: {fit_file_path}")
    try:
        fitfile = fitparse.FitFile(fit_file_path, data_processor=fitparse.StandardUnitsDataProcessor())
        
        # 初始化统计变量
        total_distance = 0.0  # 米
        total_timer_time = 0.0  # 秒
        avg_heart_rate = 0
        avg_speed = 0.0  # 米/秒
        total_ascent = 0.0  # 米
        total_descent = 0.0  # 米
        start_time = None
        end_time = None
        hr_samples = []
        speed_samples = []
        altitude_samples = []
        
        # 遍历所有数据记录
        for record in fitfile.get_messages('record'):
            # 获取时间戳
            timestamp = record.get_value('timestamp')
            if timestamp:
                if not start_time:
                    start_time = timestamp
                end_time = timestamp
            
            # 距离
            dist = record.get_value('distance')
            if dist is not None:
                total_distance = dist  # 记录中的距离通常是累计值，最后一个即总距离
            
            # 心率
            hr = record.get_value('heart_rate')
            if hr is not None:
                hr_samples.append(hr)
            
            # 速度
            speed = record.get_value('speed')
            if speed is not None:
                speed_samples.append(speed)
            
            # 海拔
            altitude = record.get_value('altitude')
            if altitude is not None:
                altitude_samples.append(altitude)
                # 简单的爬升计算（仅作示例，实际更复杂）
                if len(altitude_samples) > 1:
                    diff = altitude_samples[-1] - altitude_samples[-2]
                    if diff > 0:
                        total_ascent += diff
                    else:
                        total_descent += abs(diff)
        
        # 计算平均值
        avg_heart_rate = sum(hr_samples) / len(hr_samples) if hr_samples else 0
        avg_speed = (sum(speed_samples) / len(speed_samples)) if speed_samples else 0
        # 计算运动时长（秒）
        duration_sec = (end_time - start_time).total_seconds() if start_time and end_time else total_timer_time
        
        # 整理摘要信息
        summary = {
            "file_name": fit_file_path.split('/')[-1],
            "start_time": start_time.isoformat() if start_time else None,
            "end_time": end_time.isoformat() if end_time else None,
            "duration_seconds": round(duration_sec, 1),
            "duration_human": str(timedelta(seconds=int(duration_sec))),
            "total_distance_km": round(total_distance / 1000, 2),
            "avg_speed_kmh": round(avg_speed * 3.6, 1),  # 转换 m/s 到 km/h
            "avg_heart_rate_bpm": int(avg_heart_rate),
            "total_ascent_m": int(total_ascent),
            "total_descent_m": int(total_descent),
            "data_points": len(hr_samples)
        }
        
        logger.info(f"文件解析成功: {summary['file_name']}")
        return summary
        
    except Exception as e:
        logger.error(f"解析.fit文件失败: {e}", exc_info=True)
        return {"error": f"解析失败: {str(e)}"}

def convert_fit_to_gpx(fit_file_path: str, output_gpx_path: Optional[str] = None) -> Dict[str, Any]:
    """
    将.fit文件转换为.gpx格式文件。
    这是一个OpenClaw工具。

    Args:
        fit_file_path: .fit文件的绝对路径。
        output_gpx_path: 输出的.gpx文件路径。如果为None，则生成同名.gpx文件。

    Returns:
        包含转换状态和文件路径的字典。
    """
    logger.info(f"开始转换文件到GPX: {fit_file_path}")
    try:
        if output_gpx_path is None:
            output_gpx_path = fit_file_path.rsplit('.', 1)[0] + '.gpx'
        
        fitfile = fitparse.FitFile(fit_file_path)
        gpx = GPX()
        
        # 创建一个GPX轨迹
        gpx_track = GPXTrack()
        gpx.tracks.append(gpx_track)
        
        # 创建一个轨迹段
        gpx_segment = GPXTrackSegment()
        gpx_track.segments.append(gpx_segment)
        
        # 遍历记录，提取经纬度和时间点
        for record in fitfile.get_messages('record'):
            lat = record.get_value('position_lat')
            lon = record.get_value('position_long')
            timestamp = record.get_value('timestamp')
            altitude = record.get_value('altitude')
            
            if lat is not None and lon is not None:
                # FIT文件存储的是半圆度，需要转换
                lat_deg = lat * (180.0 / 2**31)
                lon_deg = lon * (180.0 / 2**31)
                
                point = GPXTrackPoint(latitude=lat_deg, longitude=lon_deg, time=timestamp)
                if altitude is not None:
                    point.elevation = altitude
                gpx_segment.points.append(point)
        
        # 写入GPX文件
        with open(output_gpx_path, 'w', encoding='utf-8') as f:
            f.write(gpx.to_xml())
        
        logger.info(f"GPX文件已生成: {output_gpx_path}")
        return {
            "status": "success",
            "message": "Fit文件已成功转换为GPX格式。",
            "input_file": fit_file_path,
            "output_file": output_gpx_path
        }
        
    except Exception as e:
        logger.error(f"转换.fit文件到GPX失败: {e}", exc_info=True)
        return {"status": "error", "message": f"转换失败: {str(e)}"}

# 以下部分用于向OpenClaw注册此工具。
# OpenClaw通常通过装饰器或特定函数来注册。
# 这里假设使用一个简单的函数注册方式（具体取决于OpenClaw版本）。
# 例如，某些版本可能要求这样：
def openclaw_tools():
    """返回此模块中所有可用的工具函数列表。"""
    return [parse_fit_to_summary, convert_fit_to_gpx]

这个工具提供了两个核心函数： parse_fit_to_summary 用于提取骑行摘要， convert_fit_to_gpx 用于格式转换。它们都包含了详细的错误处理和日志，这是生产级工具必备的。

4.3 实现工具二：飞书通知工具 ( feishu_notifier.py )

数据处理完了，我们需要把结果通知自己。这里以实现飞书群机器人为例。

# tools/feishu_notifier.py
import json
import requests
from typing import Dict, Any, Optional
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def send_feishu_message(webhook_url: str, message_type: str = "text", content: Dict[str, Any] = None, title: Optional[str] = None) -> Dict[str, Any]:
    """
    发送消息到飞书群机器人。
    这是一个OpenClaw工具。

    Args:
        webhook_url: 飞书群机器人的Webhook地址。
        message_type: 消息类型，支持 "text" 或 "post" (富文本)。
        content: 消息内容。对于text类型，是 {"text": "消息内容"}；对于post类型，是飞书post格式的字典。
        title: 当message_type为"post"时，卡片的标题。

    Returns:
        包含飞书API响应状态的字典。
    """
    if not webhook_url.startswith("https://"):
        return {"status": "error", "message": "无效的Webhook URL"}
    
    if content is None:
        content = {"text": "Empty message from OpenClaw."}
    
    payload = {}
    if message_type == "text":
        payload = {"msg_type": "text", "content": content}
    elif message_type == "post":
        # 飞书post消息结构较复杂，这里做简化示例
        if title:
            # 构建一个简单的卡片
            card_content = [
                {
                    "tag": "div",
                    "text": {"tag": "lark_md", "content": content.get("text", "No content")}
                }
            ]
            payload = {
                "msg_type": "interactive",
                "card": {
                    "config": {"wide_screen_mode": True},
                    "header": {"title": {"tag": "plain_text", "content": title}},
                    "elements": card_content
                }
            }
        else:
            payload = {"msg_type": "text", "content": {"text": "使用post类型时必须提供title参数。"}}
    else:
        return {"status": "error", "message": f"不支持的message_type: {message_type}"}
    
    headers = {'Content-Type': 'application/json'}
    
    try:
        response = requests.post(webhook_url, data=json.dumps(payload), headers=headers, timeout=10)
        response.raise_for_status()
        result = response.json()
        logger.info(f"飞书消息发送成功: {result}")
        return {"status": "success", "feishu_response": result}
    except requests.exceptions.RequestException as e:
        logger.error(f"发送飞书消息失败: {e}")
        return {"status": "error", "message": f"网络请求失败: {str(e)}"}
    except json.JSONDecodeError as e:
        logger.error(f"解析飞书响应失败: {e}")
        return {"status": "error", "message": f"响应解析失败: {str(e)}"}

def openclaw_tools():
    """返回此模块中所有可用的工具函数列表。"""
    return [send_feishu_message]

4.4 让OpenClaw认识新员工：工具注册与发现

仅仅把工具文件放在 ./tools 目录下，OpenClaw可能还无法自动识别。我们需要通过OpenClaw的机制来注册这些工具。具体方法取决于OpenClaw的版本和配置。常见的方式有：

1. MCP Server模式 ：将每个工具集包装成一个独立的MCP服务器，OpenClaw作为客户端连接。这是最模块化、最推荐的方式，但初期配置稍复杂。
2. Python模块扫描 ：OpenClaw启动时，自动扫描指定目录（如我们挂载的 /app/tools ）下的Python文件，并导入其中通过特定函数（如 openclaw_tools() ）暴露的工具函数。
3. 配置文件声明 ：在一个统一的配置文件中，列出每个工具的函数路径。

由于我们的部署方式是通过Docker挂载，假设OpenClaw支持 方式二 。我们需要确保OpenClaw的配置中启用了工具目录的自动加载。这通常需要在OpenClaw的环境变量或配置文件中设置，例如 OPENCLAW_TOOLS_DIR=/app/tools 。

如果自动加载不生效，我们可能需要创建一个工具注册的入口文件，例如在 tools/__init__.py 中显式导入所有工具：

# tools/__init__.py
from .fit_parser import openclaw_tools as fit_tools
from .feishu_notifier import openclaw_tools as feishu_tools

def get_all_tools():
    all_tools = []
    all_tools.extend(fit_tools())
    all_tools.extend(feishu_tools())
    return all_tools

然后，在OpenClaw的主配置中指向这个 get_all_tools 函数。 具体配置方法请务必查阅你所使用的OpenClaw版本的官方文档 ，因为这是连接“指挥中心”和“员工”的关键一步。配置成功后，重启OpenClaw服务，它就应该能“看到”我们新编写的工具了。

docker-compose restart openclaw
docker-compose logs -f openclaw
# 观察日志中是否有成功加载tools的提示。

5. 动动嘴皮子：用自然语言指挥OpenClaw工作

工具就位，指挥中心在线，现在到了最激动人心的环节：用自然语言下达指令。我们将通过OpenClaw提供的API接口来与它交互。通常，OpenClaw会提供一个HTTP端点（如 /v1/tasks ）来接收任务描述。

5.1 你的第一个自然语言指令

假设我们已经将今天的骑行文件 morning_ride_20240515.fit 放到了挂载的 ./data 目录下（对应容器内的 /app/data ）。现在，我们想完成：“解析这个fit文件，告诉我这次骑行的摘要信息。”

我们可以使用 curl 命令来模拟这个请求：

curl -X POST http://localhost:8000/v1/tasks \
  -H "Content-Type: application/json" \
  -d '{
    "instruction": "请分析并总结我放在 /app/data/morning_ride_20240515.fit 这个文件中的骑行数据，给我一份核心指标的摘要。",
    "context": {
      "current_focus": "骑行数据分析"
    }
  }'

发生了什么？

1. 你将自然语言指令和少量上下文发送给OpenClaw服务。
2. OpenClaw服务收到请求后，会将指令和它已知的所有工具描述（函数名、参数、功能说明）一起，发送给后端的LLM（Ollama）。
3. LLM分析指令，判断出需要调用 parse_fit_to_summary 这个工具，并且知道需要传入参数 fit_file_path ，其值应该是 /app/data/morning_ride_20240515.fit 。
4. LLM将规划好的工具调用返回给OpenClaw。
5. OpenClaw执行工具调用，即运行 parse_fit_to_summary(‘/app/data/morning_ride_20240515.fit’) 。
6. 工具执行完成后，将结果（包含距离、速度、心率的字典）返回给OpenClaw。
7. OpenClaw将结果返回给你。

你会在终端看到类似这样的响应：

{
  "task_id": "task_123456",
  "status": "completed",
  "result": {
    "file_name": "morning_ride_20240515.fit",
    "start_time": "2024-05-15T07:30:00",
    "end_time": "2024-05-15T09:15:00",
    "duration_human": "1:45:00",
    "total_distance_km": 42.5,
    "avg_speed_kmh": 24.3,
    "avg_heart_rate_bpm": 152,
    "total_ascent_m": 450,
    "total_descent_m": 440,
    "data_points": 6300
  }
}

看，你没有写一行调用 fitparse 的代码，只是说了一句话，就拿到了结构化的数据分析结果。这就是“动嘴”的力量。

5.2 组合技：串联多个工具的复杂任务

单一工具只是开始，OpenClaw的强大在于编排。现在我们来一个复杂任务：“把 /app/data/morning_ride.fit 转换成GPX格式，保存到 /app/data/processed/ 目录下，然后分析一下这次骑行的数据，最后把摘要发到我的飞书群里。”

这个指令包含了三个子任务：转换格式、解析摘要、发送通知。我们需要飞书机器人的Webhook URL，假设我们已经将其配置为环境变量 FEISHU_WEBHOOK_URL 。

curl -X POST http://localhost:8000/v1/tasks \
  -H "Content-Type: application/json" \
  -d '{
    "instruction": "请处理我的骑行文件：首先，将 /app/data/morning_ride.fit 转换为GPX格式，输出到 /app/data/processed/morning_ride.gpx。然后，分析这个fit文件，生成骑行数据摘要。最后，将这个摘要以文本消息的形式，发送到我的飞书群。飞书机器人的Webhook地址是 https://open.feishu.cn/open-apis/bot/v2/hook/xxxxxx。",
    "context": {
      "env": {
        "FEISHU_WEBHOOK_URL": "https://open.feishu.cn/open-apis/bot/v2/hook/xxxxxx"
      }
    }
  }'

OpenClaw背后的LLM会进行任务分解：

1. 调用 convert_fit_to_gpx(fit_file_path=‘/app/data/morning_ride.fit’, output_gpx_path=‘/app/data/processed/morning_ride.gpx’) 。
2. 调用 parse_fit_to_summary(fit_file_path=‘/app/data/morning_ride.fit’) ，得到摘要结果。
3. 调用 send_feishu_message(webhook_url=‘https://...’, message_type=‘text’, content={“text”: “骑行摘要：...”}) ，其中消息内容由前一步的摘要结果格式化而成。

整个过程完全自动化。你可能会在飞书群里收到这样一条消息： “【骑行数据简报】文件：morning_ride.fit， 骑行时长：1小时45分， 距离：42.5公里， 平均速度：24.3 km/h， 平均心率：152 bpm， 累计爬升：450米。”

5.3 从命令行到生活：打造无缝体验

每次都使用 curl 命令还是不够“动嘴”。我们可以更进一步：

• 封装为Shell脚本/别名 ：创建一个脚本 process_ride.sh ，内容就是上面的 curl 命令，但接受文件名作为参数。这样在终端里只需要输入 ./process_ride.sh my_ride.fit 。
• 使用OpenClaw CLI客户端 ：如果OpenClaw提供了命令行客户端，安装后可以直接用 openclaw run “处理我的骑行文件...” 这样的命令。
• 与文件夹监控联动 ：编写一个简单的守护进程（如用Python的 watchdog 库），监控你的骑行文件下载目录。一旦有新文件，自动触发向OpenClaw发送处理指令。这才是真正的“全自动流水线”。
• 集成到图形化工具 ：为常用的效率工具（如Alfred、Raycast、Quicker）制作插件，通过快捷键呼出输入框，直接输入自然语言指令。

至此，一个完整的、由自然语言驱动的骑行数据自动化处理流水线就构建完成了。你从需要手动执行多个步骤的“搬砖工”，变成了只需描述需求的“指挥官”。