1. 项目概述：从Python脚本到智能体技能

最近在折腾一些自动化流程，手头攒了不少Python脚本，从数据抓取到文件处理，再到一些简单的逻辑判断，零零散散。这些脚本单个用起来还行，但每次都要手动去命令行里敲 python xxx.py ，或者还得记着传什么参数，总觉得不够“智能”。正好在探索一些AI智能体（Agent）的应用，比如OpenClaw龙虾这个平台，它允许你为智能体创建自定义技能（Skill），让AI能直接调用你的代码能力。这不就巧了吗？我就在想，能不能把我这些散落的Python脚本，都封装成OpenClaw龙虾能直接理解和使用的技能，让AI来当我的“命令行”，甚至能组合多个脚本完成更复杂的任务。

简单来说，这个项目就是 将已有的、功能独立的Python代码模块，通过一套标准的封装和定义流程，转化为OpenClaw龙虾智能体平台可识别、可调用的“Skill” 。这不仅仅是简单的包装，更涉及到接口标准化、依赖管理、错误处理以及如何让AI（大语言模型）理解你这个技能是干什么的、怎么用。对于任何有现成Python工具库，又想将其能力接入AI工作流的朋友来说，这是一个非常实用的工程化课题。无论你是开发者、数据分析师还是自动化爱好者，只要你想让自己的代码“活”起来，被更自然地调用，这篇内容都会给你一条清晰的路径。

2. 核心思路与方案选型

要把Python代码变成Skill，核心在于建立一座桥梁：一边是你的原始代码（可能是一个函数、一个类或者一整个脚本），另一边是OpenClaw龙虾平台期望的Skill格式。OpenClaw龙虾（以下简称“龙虾平台”）的Skill本质上是一个遵循特定规范的Python包，它需要明确告诉平台：我这个技能叫什么、描述是什么、需要哪些输入参数、会输出什么结果、以及具体执行的入口函数在哪里。

2.1 技能封装的核心组件

基于对龙虾平台常见模式的理解，一个标准的Skill通常包含以下几个关键部分：

  1. 技能描述文件（如 skill.yaml 或 manifest.json ） ：这是技能的“身份证”和“说明书”。它用结构化的数据（YAML或JSON格式）定义了技能的基本元信息，例如技能的唯一标识符（ID）、名称、版本、作者、简短描述、详细的功能说明等。最重要的是，它需要声明技能的输入参数（ inputs ）和输出结果（ outputs ）的格式。

  2. 执行入口点（Entry Point） ：这是一个特定的Python函数，平台在调用该技能时，实际执行的就是这个函数。这个函数需要接收一个包含所有输入参数的字典（通常由平台根据描述文件解析后传入），并返回一个包含输出结果的字典。你的原始Python代码逻辑需要被整合到这个函数中。

  3. 依赖管理（ requirements.txt 或 pyproject.toml ） ：你的原始代码可能依赖一些第三方库。为了让技能能在龙虾平台的环境中正常运行，必须明确列出所有依赖项及其版本。

  4. 错误处理与日志 ：在AI调用的场景下，清晰的错误反馈至关重要。技能的执行函数需要有完善的异常捕获机制，并将错误信息以结构化的方式返回给平台，而不是让进程直接崩溃。同时，适当的日志记录有助于调试。

2.2 方案选型：轻量封装 vs 框架适配

面对一堆功能各异的Python脚本，通常有两种主流思路：

方案一：逐个手工封装（轻量、灵活） 这种方法适合脚本数量不多、逻辑相对独立、且你想完全掌控封装过程的情况。你需要为每个脚本手动创建上述的四个组件。优点是理解深刻，可以对每个技能做深度定制（比如优化输入参数描述，让AI更好理解）。缺点是重复劳动多，如果脚本有几十上百个，效率很低。

方案二：使用自动化脚手架或模板（高效、统一） 这种方法适合脚本较多，或者希望建立团队规范的情况。你可以先创建一个标准的Skill项目模板，然后通过脚本批量扫描你的Python代码库，自动或半自动地生成技能描述文件和入口函数框架。例如，可以通过解析Python文件的函数签名、文档字符串（docstring）来推断输入输出。社区中也有一些工具尝试做类似的事情。优点是效率高，风格统一。缺点是对代码规范要求高（比如必须有清晰的函数定义和文档），且生成的技能描述可能不够精准，需要人工复核。

对于大多数个人开发者或小团队起步，我推荐从 方案一 开始。亲手封装几个技能后，你会对整套机制有肌肉记忆般的理解，之后如果真有批量需求，再基于经验去设计自动化方案，会稳妥得多。本篇内容也将主要围绕手工封装的最佳实践来展开。

注意 ：在开始前，请务必查阅你所使用的OpenClaw龙虾平台的最新官方文档，确认其对Skill包的具体格式要求（如描述文件是YAML还是JSON，是否有特定的字段名）。不同版本或分支可能有细微差别，以下内容基于通用模式，你需要根据实际情况调整。

3. 实操详解：四步将Python脚本转化为Skill

下面，我们通过一个具体的例子，一步步完成封装。假设我有一个用于查询天气的Python脚本 weather_checker.py ，它包含一个主要函数 get_weather(city: str) -> dict 。

3.1 第一步：分析原始代码与接口

首先，深度理解你的原始代码。打开 weather_checker.py ，我们关注以下几点：

  • 核心功能 ：输入一个城市名，返回该城市的天气信息（温度、湿度、天气状况等）。
  • 输入接口 ：函数 get_weather 接受一个字符串参数 city 。
  • 输出接口 ：函数返回一个字典，例如 {“temperature”: 22, “humidity”: 65, “condition”: “Sunny”} 。
  • 外部依赖 ：脚本内部可能使用了 requests 库来调用某个天气API。
  • 可能的错误 ：城市名无效、网络请求失败、API密钥错误等。

明确这些信息是后续所有步骤的基础。如果原始代码结构混乱（比如所有逻辑都写在 if __name__ == “__main__”: 里），你需要先将其重构为清晰的函数或类方法。

3.2 第二步：创建Skill项目结构

为这个天气查询技能创建一个独立的项目文件夹，这是良好工程实践的起点。结构如下：

weather_skill/          # 技能根目录
├── skill.yaml          # 技能描述文件 (核心)
├── requirements.txt    # 依赖列表
├── src/               # 源代码目录
│   └── weather_skill/
│       ├── __init__.py
│       └── main.py    # 技能执行入口
└── README.md          # 可选，本地说明文档
  • skill.yaml ：这是龙虾平台识别技能的关键。
  • requirements.txt ：列出运行所需的所有Python包。
  • src/weather_skill/main.py ：这里将放置我们封装好的执行函数。使用 src 目录是一种更专业的打包方式，可以避免很多潜在的导入路径问题。

3.3 第三步：编写技能描述文件 ( skill.yaml )

这是最关键的一步，它定义了AI如何理解和使用你的技能。YAML格式清晰易读，下面是一个针对天气查询技能的示例：

id: com.yourname.weather_checker  # 技能唯一ID，建议用反向域名格式
name: 天气查询
version: 1.0.0
author: 你的名字
description: 根据城市名称查询实时天气信息，包括温度、湿度和天气状况。
inputs:
  - name: city
    type: string
    description: 需要查询天气的城市名称，例如“北京”、“Shanghai”。
    required: true
outputs:
  - name: weather_report
    type: object
    description: 包含详细天气信息的JSON对象。
    properties:
      temperature:
        type: number
        description: 摄氏温度
      humidity:
        type: number
        description: 湿度百分比
      condition:
        type: string
        description: 天气状况，如“晴朗”、“多云”、“小雨”
      city:
        type: string
        description: 查询的城市名
execution:
  handler: src.weather_skill.main.get_weather_skill
  runtime: python3

关键字段解析：

  • id : 全局唯一标识。使用类似Java包名的格式可以避免冲突。
  • inputs : 定义了技能所需的参数。每个参数都需要 name , type (string, number, boolean, object等), description (这个描述非常重要！AI靠它来理解参数含义)，以及 required 。
    • 实操心得 ： description 要写得具体、无歧义。好的描述能让AI在调用时更准确地填充参数。例如，与其写“城市名”，不如写“需要查询天气的城市中文名称或拼音，例如‘北京’或‘beijing’”。
  • outputs : 定义了技能返回的数据结构。同样，清晰的 description 和 properties 能帮助AI理解结果，并可能用于后续的决策或展示。
  • execution.handler : 指定了执行入口函数的完整导入路径。格式为 模块.路径.函数名 。

3.4 第四步：实现技能执行入口 ( main.py )

现在，我们需要在 src/weather_skill/main.py 中创建平台会调用的那个入口函数。这个函数的作用是“适配器”，将平台传入的标准化参数，转换为你原始代码所需的格式，调用原始逻辑，再处理结果和异常。

# src/weather_skill/main.py
import logging
from typing import Dict, Any
# 假设你的原始代码逻辑在一个模块里，这里我们直接写核心逻辑作为示例
# 在实际项目中，你可能是 from my_original_weather_module import get_weather

# 设置日志，便于调试
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def get_weather_original(city: str) -> Dict[str, Any]:
    """
    原始的天气查询逻辑（模拟）。
    在实际项目中，这里是你已有的函数。
    """
    # 这里应该是调用真实API的代码，例如：
    # import requests
    # response = requests.get(f"https://api.weather.com/v1/{city}")
    # data = response.json()
    # return {“temperature”: data[‘temp’], ...}
    
    # 为了示例，我们返回模拟数据
    logger.info(f“正在查询城市【{city}】的天气...”)
    # 模拟一些业务逻辑
    if not city or len(city.strip()) == 0:
        raise ValueError(“城市名称不能为空”)
    
    # 模拟根据城市名返回不同天气
    mock_data = {
        “北京”: {“temperature”: 25, “humidity”: 40, “condition”: “晴朗”},
        “上海”: {“temperature”: 28, “humidity”: 75, “condition”: “多云”},
        “广州”: {“temperature”: 32, “humidity”: 85, “condition”: “雷阵雨”},
    }
    if city in mock_data:
        return mock_data[city]
    else:
        # 模拟未找到城市
        raise KeyError(f“未找到城市 {city} 的天气信息”)

def get_weather_skill(inputs: Dict[str, Any]) -> Dict[str, Any]:
    """
    OpenClaw龙虾技能的标准入口函数。
    Args:
        inputs: 一个字典，包含了在skill.yaml中定义的所有输入参数。
                例如: {‘city’: ‘北京’}
    Returns:
        一个字典，包含了在skill.yaml中定义的所有输出。
                例如: {‘weather_report’: {‘temperature’: 25, ...}}
    """
    try:
        logger.info(f“技能被调用，输入参数: {inputs}”)
        
        # 1. 参数提取与验证
        city = inputs.get(‘city’)
        if not city:
            return {
                “success”: False,
                “error”: “缺少必要参数 ‘city’”，
                “weather_report”: None
            }
        
        # 2. 调用原始业务逻辑
        weather_data = get_weather_original(city)
        
        # 3. 格式化输出以匹配skill.yaml中的定义
        result = {
            “success”: True,
            “error”: None,
            “weather_report”: {
                “temperature”: weather_data[“temperature”],
                “humidity”: weather_data[“humidity”],
                “condition”: weather_data[“condition”],
                “city”: city
            }
        }
        logger.info(f“技能执行成功，结果: {result}”)
        return result
        
    except ValueError as e:
        error_msg = f“输入参数错误: {e}”
        logger.error(error_msg)
        return {“success”: False, “error”: error_msg, “weather_report”: None}
    except KeyError as e:
        error_msg = f“查询失败，城市可能不存在: {e}”
        logger.error(error_msg)
        return {“success”: False, “error”: error_msg, “weather_report”: None}
    except Exception as e:
        # 捕获其他所有未预见的异常
        error_msg = f“技能执行过程中发生未知错误: {str(e)}”
        logger.exception(error_msg) # 这会记录完整的异常堆栈
        return {“success”: False, “error”: error_msg, “weather_report”: None}

代码要点解析：

  1. 函数签名 ： get_weather_skill(inputs: Dict[str, Any]) -> Dict[str, Any] 这是一个非常标准的格式。平台会把一个字典传给你，你也必须返回一个字典。
  2. 健壮的错误处理 ：这是区别于简单脚本的关键。我们使用 try...except 包裹核心逻辑，捕获可能发生的各种异常（参数错误、业务错误、未知异常）。 绝对不要让异常未经处理就抛出 ，否则会导致技能调用在平台端显示为难以调试的失败。
  3. 结构化的返回 ：返回的字典中，我习惯包含一个 success 字段明确指示成功与否，一个 error 字段携带错误信息（成功时为None），以及业务数据本身（ weather_report ）。这虽然不是平台强制要求，但是一种非常清晰、利于AI后续处理的约定。
  4. 日志记录 ：使用 logging 模块记录关键步骤和错误。在云端环境调试时，日志往往是唯一的问题排查手段。

3.5 第五步：定义依赖与本地测试

在 requirements.txt 中列出依赖。对于我们的示例，如果原始代码用了 requests ，就加上：

requests>=2.28.0

在将技能部署到龙虾平台之前，强烈建议在本地进行测试。你可以创建一个简单的测试脚本 test_skill.py 在项目根目录：

# test_skill.py
import sys
sys.path.insert(0, ‘./src’) # 将src目录加入路径

from weather_skill.main import get_weather_skill

# 模拟平台调用
test_input = {“city”: “北京”}
result = get_weather_skill(test_input)
print(“测试结果:”, result)

# 测试错误情况
test_input_bad = {“city”: “”}
result_bad = get_weather_skill(test_input_bad)
print(“错误测试结果:”, result_bad)

运行这个脚本，确保你的技能函数能按预期工作，正确返回结果和处理错误。

4. 技能封装的高级技巧与避坑指南

掌握了基本流程后，下面分享一些能让你技能更“专业”、更好用的进阶经验。

4.1 让AI更好理解你的技能：描述的艺术

skill.yaml 中的 description 字段是你与AI（大语言模型）沟通的主要渠道。写得好，AI调用起来精准无比；写得差，AI可能会误解或错误使用。

  • 差描述 ： “查询天气”
  • 好描述 ： “根据提供的城市中文名称（例如‘北京’、‘上海’）或拼音（例如‘beijing’），查询该城市当前的天气实况，返回包括温度（摄氏度）、湿度（百分比）、天气现象（如晴、雨、雪）以及风速在内的详细信息。仅支持中国境内主要城市。”

好描述明确了：

  1. 输入格式 ：中文名或拼音。
  2. 功能边界 ：当前实况，不是预报。
  3. 输出内容 ：具体包含哪些字段。
  4. 限制条件 ：仅支持中国主要城市。

这能极大减少AI的误调用。对于复杂技能，你甚至可以在描述中举例说明典型用法。

4.2 处理复杂参数与配置

有时你的脚本需要API密钥、文件路径等配置信息。这些不适合作为每次调用的输入参数。常见的做法是使用 环境变量 或 平台提供的配置管理 。

  • 在 skill.yaml 中声明配置需求 ：

    configuration:
  - name: API_KEY
    type: string
    description: 访问天气API所需的密钥
    required: true
    secret: true  # 标记为密钥，平台可能会以安全方式存储和注入

  • 在代码中读取配置 ：

    import os
api_key = os.environ.get(“API_KEY”)
if not api_key:
    raise RuntimeError(“未配置API_KEY环境变量”)

在部署技能到平台时，你就需要在平台的管理界面填写这些配置值。这样既安全，又实现了代码与配置的分离。

4.3 技能的性能与状态管理

  • 避免在技能函数内进行昂贵的初始化 ：例如，加载大型模型、建立数据库连接池。这些操作应该在函数外部、模块加载时执行一次（利用Python的模块单例特性），或者使用惰性加载。

    # src/weather_skill/main.py
_expensive_model = None

def load_model_once():
    global _expensive_model
    if _expensive_model is None:
        logger.info(“正在加载AI模型，此操作仅发生一次...”)
        # 模拟耗时加载
        import time
        time.sleep(2)
        _expensive_model = {“name”: “My Heavy Model”}
    return _expensive_model

def my_skill(inputs):
    model = load_model_once() # 后续调用直接使用缓存
    # ... 使用model进行处理

    注意，这取决于平台如何运行你的技能。如果每次调用都是全新的进程，则缓存无效。需要了解平台的技能运行模型（通常是容器，可能复用）。

  • 技能应该是无状态的 ：设计技能时，尽量让其输出只由输入参数决定，不要依赖上一次调用的内部状态。这符合云函数的理念，能保证技能在任何情况下行为一致，也便于扩展和调试。如果必须有状态（如访问计数器），考虑使用外部存储（如Redis、数据库）。

4.4 本地开发与调试工作流

  1. 使用虚拟环境 ：为每个技能项目创建独立的Python虚拟环境（ venv ），避免依赖冲突。 python -m venv venv ，然后 source venv/bin/activate (Linux/Mac) 或 venv\Scripts\activate (Windows)。
  2. 安装依赖 ：在虚拟环境中运行 pip install -r requirements.txt 。
  3. 单元测试 ：为你的技能入口函数编写单元测试（使用 pytest ），模拟各种正常和异常的输入，确保逻辑正确。这是保证技能质量最有效的手段。
  4. 模拟平台调用 ：就像前面的 test_skill.py 一样，建立一个本地测试套件，方便快速迭代。

5. 部署上线与集成测试

完成本地开发和测试后，下一步就是将技能部署到OpenClaw龙虾平台，并进行集成测试。

5.1 技能打包与上传

龙虾平台通常支持两种方式安装技能：

  1. 源码打包上传 ：将整个技能目录（ weather_skill/ ）打包成ZIP文件，在平台的管理界面上传。平台会自动识别 skill.yaml 并安装。这是最简单直接的方式。
  2. 通过Git仓库 ：如果你的技能项目托管在Git（如GitHub, GitLab）上，平台可能支持通过仓库URL安装。你需要在仓库根目录放置 skill.yaml ，平台会拉取代码并安装。这种方式便于版本管理和持续集成。

打包前检查清单 ：

  • skill.yaml 格式正确，无语法错误。
  • requirements.txt 包含了所有必要的依赖，且版本范围合理。
  • 项目中不包含无关的大文件（如测试数据、 .git 目录、 __pycache__ ），可以通过 .gitignore 或手动清理。
  • 确保 src 目录结构正确， __init__.py 文件存在（可以是空文件），以确保能作为包被导入。

5.2 平台端配置与验证

技能上传后，需要在平台进行配置：

  1. 填写配置项 ：如果 skill.yaml 中定义了 configuration ，在平台技能管理页面找到对应技能，填入API密钥等配置值。
  2. 技能测试 ：大多数平台会提供一个测试界面，允许你手动输入参数并触发技能执行。 务必在这里进行测试！ 输入你在本地测试用过的用例，验证技能在云端环境是否能正常运行并返回预期结果。
  3. 查看日志 ：测试时，密切关注平台提供的日志输出功能。这能帮助你定位云端环境特有的问题，如网络权限、依赖安装失败等。

5.3 在智能体（Agent）中调用技能

技能安装并测试通过后，就可以在创建或配置智能体时添加这个技能了。

  1. 技能发现 ：在智能体的技能配置页面，你应该能在列表中找到你刚上传的“天气查询”技能。勾选它，将其添加到该智能体的技能库中。
  2. 权限与上下文 ：有些平台允许你设置技能在什么情况下可以被AI调用（例如，仅当用户明确询问天气时）。合理设置这些规则，可以防止AI滥用或误调用技能。
  3. 自然语言交互测试 ：这是最激动人心的环节。与集成了该技能的智能体进行对话。尝试用自然语言说：“今天北京天气怎么样？”、“帮我查一下上海的湿度。”。观察AI是否能正确理解你的意图，并调用“天气查询”技能，将结果以友好的方式呈现给你。

集成测试常见问题 ：

  • AI不调用技能 ：检查技能描述是否足够清晰。AI可能无法从你的描述中准确匹配用户意图。尝试优化 skill.yaml 中的 name 和 description ，使其更贴近用户的自然问法。
  • 参数传递错误 ：AI可能误解了参数含义，传入了错误的值。检查 inputs 中每个参数的 description ，确保其明确无歧义。可以在描述中增加示例。
  • 技能执行超时或失败 ：查看云端日志。可能是网络问题、依赖缺失、或者你的代码在云端环境下有路径等问题。确保你的代码对运行环境没有特殊假设（如绝对路径）。

6. 复杂脚本与工程化封装策略

前面的例子是一个简单的单函数脚本。现实中，我们可能面对更复杂的代码库：多个模块、类、配置文件等。如何封装它们？

6.1 封装一个完整的Python项目

假设你有一个数据分析项目 data_analyzer ，结构如下：

data_analyzer/
├── config/
│   └── settings.py
├── core/
│   ├── __init__.py
│   ├── data_loader.py
│   └── analyzer.py
├── utils/
│   └── helpers.py
└── main.py

封装策略：

  1. 确定技能边界 ：这个项目可能提供多种分析功能。不要试图做一个“万能数据分析”技能。应该按核心功能拆分成多个细粒度的技能，例如：

    • 数据导入技能 ：对应 data_loader.py 的功能。
    • 趋势分析技能 ：对应 analyzer.py 中的某个特定分析函数。
    • 报告生成技能 ：对应另一个功能。 每个技能一个独立的 skill.yaml 和入口函数。

  2. 创建技能包装层 ：在原有项目旁，新建一个 skills/ 目录，为每个技能创建独立的子目录。

    data_analyzer/
├── ... (原有代码)
└── skills/
    ├── trend_analysis_skill/
    │   ├── skill.yaml
    │   ├── requirements.txt (可以继承主项目的)
    │   └── src/
    │       └── trend_skill/
    │           ├── __init__.py
    │           └── main.py  # 这里导入并调用 core.analyzer 中的函数
    └── data_load_skill/
        └── ... (类似结构)

  3. 入口函数适配 ：在 main.py 中，你需要正确导入原有项目的模块。由于技能可能被打包到新环境，要处理好导入路径。一种可靠的方法是使用相对导入（如果技能代码和原代码在同一个包内），或者确保原项目被安装为依赖（通过 setup.py 或 pyproject.toml ）。

6.2 处理图形界面（GUI）或交互式脚本

如果你的原始脚本是GUI程序（如用Tkinter、PyQt写的）或者是需要命令行交互的脚本，封装会更具挑战性。因为Skill通常运行在无界面的服务器环境。

  • 策略一：剥离核心逻辑 ：这是最推荐的方式。将GUI脚本中的业务逻辑部分抽取出来，形成一个纯计算的函数或类库。然后为这个纯逻辑库创建Skill。GUI部分可以保留作为本地工具，或者重写为一个调用该Skill的轻量级前端。
  • 策略二：模拟交互（不推荐） ：对于简单的交互，理论上可以用 subprocess 调用脚本并通过管道传递输入/输出，但这非常脆弱，容易出错，且难以处理复杂状态。除非万不得已，否则避免使用。

6.3 技能间的组合与编排

单个技能能力有限，真正的威力在于组合。龙虾平台的智能体可以自主或在你的引导下，按顺序调用多个技能完成复杂任务。

例如，你可以有：

  1. fetch_stock_data_skill ：获取股票数据。
  2. calculate_indicators_skill ：计算技术指标。
  3. generate_report_skill ：生成分析报告。

当用户问“帮我分析一下茅台股票最近一周的情况”，AI可以自动编排这三个技能依次执行。

设计可组合技能的关键：

  • 输入输出标准化 ：尽量使用通用的、结构化的数据类型（如JSON对象）。例如，股票数据技能的输出，应该能被指标计算技能直接作为输入使用。
  • 明确的契约 ：在技能的 description 中说明其输入输出的具体格式，便于其他开发者（或未来的你）理解如何串联。
  • 幂等性与无状态 ：确保技能可以安全地被多次调用，且结果一致。这有利于重试和调试。

将已有的Python代码转化为OpenClaw龙虾的技能，是一个将静态工具“激活”为智能工作流组件的精彩过程。它考验的不仅是编程能力，更是对功能边界的界定、接口设计的清晰度以及对AI交互模式的理解。从简单的函数封装开始，逐步扩展到复杂项目，每一步都遵循“分析-定义-实现-测试”的循环。最深的体会是， 为AI设计技能，本质是在设计一种精确的语言 ——通过 skill.yaml 和结构化的输入输出，告诉AI你能做什么、需要什么、会返回什么。这个过程本身就会倒逼你重新审视和优化自己的代码，使其更模块化、更健壮、更清晰。当你看到自己写的工具被AI自然流畅地调用并融入对话时，那种成就感远超写一个孤立的脚本。不妨就从手边最常用的那个Python小工具开始，试试给它赋予“技能”，开启人机协作的新方式。

Logo
亚马逊云科技技术品牌专区

更多推荐

cover

【JVS更新日志】JVS-Tellix 、JVS-Narrivo、JVS-Draw、JVS-PPT编辑器插件8.19更新说明！

avatar 亚马逊云科技技术品牌专区
cover

如果AI说「我有意识」，我们凭什么判断它是真的？-龍德明宇

avatar 亚马逊云科技技术品牌专区
cover

2026东莞GEO系统服务商技术路径与选型参考——微三云与其他的差异化分析

avatar 亚马逊云科技技术品牌专区