本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：trap（Transaction Rate Analysis and Performance Test）是一款轻量级但功能强大的压力测试工具，支持HTTP、HTTPS、FTP等多种协议，能够模拟高并发用户请求，用于评估服务器、数据库及网络服务在极限负载下的性能表现。本文详细介绍trap的安装使用、测试脚本配置、多种负载模式应用以及测试结果分析方法。通过Web应用、数据库等实际场景的测试案例，帮助测试人员掌握系统瓶颈识别与性能优化的关键技术，确保系统在高并发环境下的稳定性与可靠性。

trap 压力测试工具：从并发模拟到全链路性能观测的现代实践

在当今这个微服务横行、云原生泛滥的时代，系统架构越来越像一张错综复杂的蜘蛛网。一个用户点击“下单”按钮，背后可能触发十几个服务调用，涉及缓存、数据库、消息队列甚至第三方支付接口。这时候你还敢说：“我本地跑得挺快啊，上线应该没问题”？😎

别闹了，朋友。

真正让工程师夜不能寐的，不是代码写不出来，而是—— 上线后突然发现 QPS 掉到了个位数，P99 延迟飙到 5 秒以上，运维群里已经开始刷屏报警信息 。

所以，我们到底需要什么样的压力测试工具？

它不能是那种启动就得半小时、内存占用动辄几个 G 的“老古董”；也不能是只能发个 HTTP GET 就完事的“玩具级”脚本；更不能只告诉你“平均响应时间 200ms”，却对尾部延迟视而不见。

我们需要的是：轻量、灵活、精准、可观测性强，并且能无缝嵌入 CI/CD 流水线的现代压测利器。

而 trap ，正是为解决这些问题而生的。

trap 是什么？为什么它不一样？

简单来说， trap 是一款面向云原生和微服务架构的轻量级压力测试框架 。但它远不止是一个“发请求”的工具，而是一整套性能验证体系的核心组件。

它的设计理念很明确： 高效、灵活、可集成 。

  • 高效 ：基于 Go 编写，单二进制部署，无依赖环境，启动飞快，内存占用通常不到 50MB。
  • 灵活 ：支持多种协议（HTTP/HTTPS/FTP/gRPC）、多种负载模式（恒定/逐步/随机）、复杂行为建模。
  • 可集成 ：YAML 配置驱动，天然适合 DevOps 场景，轻松接入 Prometheus/Grafana/Jaeger 等生态。 
# 想要最简压测？一行配置搞定
target: "https://api.example.com"
concurrency: 100
rps: 500
duration: "60s"
protocol: "http"

就这么几行，就能在 60 秒内以每秒 500 请求、100 并发的方式发起压测。没有 XML 树形结构，没有 GUI 点点点操作，一切皆配置，一切皆版本化 ✅。

相比 JMeter 动辄几百 MB 的内存消耗，或者 Locust 对 Python 运行时的强依赖，trap 更像是一个“隐形战士”——你几乎感觉不到它的存在，但它已经完成了任务。

更重要的是，它可以被直接扔进 CI/CD 流水线里跑： 

trap run --config load-test.yaml --report-format json --output report.json
if jq '.error_rate > 0.01' report.json; then exit 1; fi

这段脚本会自动执行压测并检查错误率是否超过 1%。如果超标，直接中断发布流程 —— 实现真正的“性能红线”管控 🔴。

而且，trap 不只是对外部接口施压那么简单。它还能把指标推送到 Prometheus，联动 Grafana 展示趋势图，形成完整的可观测闭环。

在微服务场景下，你可以针对某个 API 单独施压，避免传统“全链路压测”带来的环境复杂性和成本问题。再加上对 Kubernetes 的良好适配性，甚至可以直接在一个 Pod 里运行 trap，实现“在哪部署，就在哪测试”的运维范式革新 🚀。

高并发是怎么做到的？协程 vs 线程，Go 的魔法在这里

说到高并发，很多人第一反应就是“多线程”。但你知道吗？传统的线程模型其实在高并发面前早就不堪重负了。

想象一下：你要模拟 10,000 个用户同时访问服务器。如果是每个用户对应一个操作系统线程……那意味着你要创建 10,000 个内核态线程。

每个线程默认栈空间 8MB，光是栈内存就吃掉 80GB！🤯
上下文切换频繁，CPU 大部分时间都在做无用功……

这就是所谓的 C10K 问题 —— 如何让单台机器处理一万个并发连接？早在二十年前，这个问题就逼出了 Nginx 这样的事件驱动架构。而现在，trap 把这套思想搬到了“客户端侧”。

它是怎么做的？

答案是： goroutine + 异步非阻塞 I/O 。

Go 语言的 goroutine 是一种用户态轻量级线程，初始栈仅约 2KB，按需动态扩展。成千上万个 goroutine 可以共存于单个进程中，完全不会崩溃。

下面这段代码展示了 trap 如何用 Go 启动 10,000 个虚拟用户（VU）： 

package main

import (
    "context"
    "sync"
    "time"
    "log"
    "github.com/trap-performance/toolkit/vu"
)

func main() {
    const concurrency = 10000
    var wg sync.WaitGroup
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    for i := 0; i < concurrency; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            v := vu.New(ctx)
            v.SetHeader("X-User-ID", fmt.Sprintf("%d", id))
            err := v.Get("https://api.example.com/health")
            if err != nil {
                log.Printf("VU %d failed: %v", id, err)
            }
        }(i)
        time.Sleep(1 * time.Millisecond) // 模拟逐步启动
    }

    wg.Wait()
}

逐行来看：

  • 第 9 行：定义并发总数为 10,000。
  • 第 10 行：使用 sync.WaitGroup 来等待所有 goroutine 结束。
  • 第 11 行：带超时的上下文，防止某个 VU 卡死影响整体。
  • 第 14–24 行：循环启动 10,000 个 goroutine，每个代表一个虚拟用户。
  • 第 17 行： go 关键字开启新协程，这才是真正的并行执行。
  • 第 19 行：初始化 VU 实例，绑定生命周期。
  • 第 20 行：设置唯一头信息，便于后端追踪。
  • 第 21 行：发送 HTTP GET 请求。
  • 第 22–24 行：失败也不退出，记录日志即可。
  • 第 27 行： wg.Wait() 阻塞主函数直到全部完成。

是不是特别简洁？没有复杂的线程池管理，也没有回调地狱。Go runtime 自动帮你调度这些 goroutine，在极低资源消耗下实现了超高并发。

再来看看两种 I/O 模型的区别： 

graph TD
    A[应用发起 Read 请求] --> B{是否阻塞?}
    B -->|是| C[线程进入休眠]
    C --> D[等待内核通知数据到达]
    D --> E[唤醒线程继续处理]
    B -->|否| F[立即返回 EAGAIN 错误]
    F --> G[将 fd 加入 epoll 监听集]
    G --> H[事件循环监听可读事件]
    H --> I[数据到达触发回调]
    I --> J[唤醒对应协程处理数据]

可以看到，非阻塞 I/O 将“被动等待”变成了“主动监听”，使得单个线程可以高效管理成千上万个连接。这也是 trap 能以极小资源开销支撑大规模压测的关键所在。

此外，trap 还内置了连接池机制：

  • HTTP/1.1 默认启用 Keep-Alive；
  • HTTP/2 利用单一连接上的多路复用流进一步降低延迟。

实测数据显示，在一次 RESTful API 压测中，trap 成功用单节点模拟出 50,000 并发用户，平均 RPS 达到 120,000，内存稳定在 1.8GB 左右，CPU 峰值未超 75%。

这表现，甩传统 Java 线程模型几条街都不止 💪。

虚拟用户的灵魂：不只是发请求，更是模拟真实行为

你以为压测就是不停地发请求？太天真了。

真实的用户是有状态的、有节奏的、会思考的。他们登录 → 浏览商品 → 加购物车 → 下单 → 支付，这一连串动作之间还有“思考时间”。

如果你的压测工具只会傻乎乎地狂刷 /api/user/profile ，那你得到的结果根本不可信。

所以，trap 提供了一套完整的 虚拟用户（Virtual User, VU）生命周期管理体系 ，让你能精准控制每一个细节。

用户怎么启动？速率可控才是关键

流量从来不是瞬间爆发的。现实中，用户是逐渐涌入系统的。如果压测一开始就拉满并发，很容易造成瞬时冲击，导致目标服务雪崩。

为此，trap 支持 spawn_rate 参数来控制用户启动速率： 

virtual_users:
  count: 5000
  spawn_rate: 100/s
  lifecycle:
    init:
      - exec: "login.sh"
        timeout: 10s
    steps:
      - name: "fetch_profile"
        method: GET
        url: "/api/v1/user/profile"
        think_time: 2s
      - name: "update_settings"
        method: POST
        url: "/api/v1/user/settings"
        body: '{"theme": "dark", "lang": "zh-CN"}'
        headers:
          Content-Type: application/json
    teardown:
      - exec: "logout.py"

这里的 spawn_rate: 100/s 表示每秒启动 100 个用户，持续 50 秒才能达到 5000 并发。这种渐进式加压方式更贴近真实场景。

init 阶段常用于执行前置逻辑，比如调用 login.sh 获取 token；
steps 定义主要行为链，支持 Think Time 模拟用户思考；
teardown 在结束前清理资源，如登出或释放文件句柄。

整个过程由 context 控制，支持超时中断与异常捕获，健壮性极高。

并发数能动态调吗？当然可以！

生产环境的流量是有波峰波谷的。早上通勤时段、午休刷手机、晚高峰抢购……这些都是典型的流量波动。

为了更真实地模拟这种情况，trap 支持运行时动态调整并发数： 

trap scale --target=10.0.1.100:8080 --increase=+500 --duration=2m

这条命令会在两分钟内将目标服务的并发用户数增加 500 名，形成平滑的压力上升曲线。

系统内部通过原子计数器维护活跃 VU 数量，并配合 ticker 定时器实现平滑扩缩容。

甚至可以通过 Prometheus 指标联动实现智能调节： 

func autoScale(client *trap.Client, targetRPS float64) {
    ticker := time.NewTicker(10 * time.Second)
    for range ticker.C {
        currentRPS := getCurrentRPSFromPrometheus()
        diff := targetRPS - currentRPS
        if abs(diff) > 50 {
            delta := int(diff / 10)
            client.Scale(delta) // 正值扩容，负值缩容
        }
    }
}

这种方式可用于闭环反馈控制系统，根据实际输出吞吐量自动调节输入压力，确保测试稳定性。

用户行为怎么个性化？Lua 和 JS 来帮忙！

不同用户有不同的操作路径。有人喜欢先看评论再买，有人直接一键下单。这种多样性必须体现在压测中。

trap 支持通过 Lua 或 JavaScript 脚本嵌入复杂逻辑，实现个性化的会话保持。

例如，模拟电商用户的完整购物流程： 

function behavior(vu)
    local session = vu.session()
    local uid = math.random(10000, 99999)
    -- 登录并保存 token
    local resp = vu.post("/login", {username = "user_"..uid, password="123"})
    session:set("token", resp.json.token)
    vu.header("Authorization", "Bearer " .. session:get("token"))

    -- 浏览商品
    vu.get("/products?page=1")

    -- 添加至购物车
    vu.post("/cart", {product_id=101, qty=1})

    -- 提交订单
    vu.post("/orders", {payment_method="alipay"})

    return true
end

每个 VU 都有自己的 session 存储空间，支持跨请求保持 Cookie、Token、临时变量等状态信息，从而准确模拟有状态交互流程。

此外，trap 还支持“Think Time 分布建模”，允许设置固定、随机或正态分布的等待间隔，增强行为真实性。

多种负载模式：不只是“打满”，更要“打得聪明”

压测不是越猛越好。不同的测试目标需要不同的负载策略。

trap 提供了三种核心负载模式： 恒定负载、逐步加压、随机负载 ，分别对应不同的业务场景。

恒定负载：稳态性能评估的基石

恒定负载（Constant Load）是指在整个测试周期内维持固定的请求速率，比如每秒 500 个请求。

它的价值在于评估系统的 长期稳定性 和 资源占用均衡性 。

典型应用场景包括：

  • 验证服务在日常平均流量下的 CPU 使用率是否稳定；
  • 观察内存是否存在缓慢泄漏；
  • 测试数据库连接池在持续高并发下的复用效率；
  • 基准对比不同版本之间的吞吐量表现。

例如，某电商后台订单查询接口日均 QPS 为 800，你可以设置恒定 RPS=800 进行长达 30 分钟的压测，观察 P99 延迟是否始终低于 200ms，同时确认无错误率上升或 GC 频繁触发。

虽然无法探测系统极限，但它是回归测试或上线前最终验证阶段的最佳选择。 

load:
  type: constant
  rps: 300
  duration: 5m

trap 内部使用令牌桶算法控制发射节奏，每秒精确释放 300 个“请求令牌”，只有获得令牌的协程才能发起请求。

也可以基于并发数进行恒定压测： 

load:
  type: constant
  concurrency: 100
  duration: 3m

适用于需要保持连接复用的场景。

逐步加压：找出系统的“拐点”

想知道自己系统的极限在哪里？那就得试试 逐步加压 （Step Load）。

这是一种渐进式增加请求强度的方式，常用于容量规划测试。 

load_profile:
  type: step
  steps:
    - duration: 60s
      rps: 100
    - duration: 60s
      rps: 300
    - duration: 60s
      rps: 600
    - duration: 60s
      rps: 900
    - duration: 60s
      rps: 1200

每隔一分钟提升一次压力，形成阶梯状曲线。每个阶段持续 60 秒，以便系统充分进入稳态后再采集数据。

为什么要这么做？

因为在排队论中有一个经典现象：当请求到达率接近服务处理能力上限时，队列长度呈指数级增长，导致延迟急剧恶化。这个临界点被称为“性能拐点”。

通过逐步加压，你可以清晰看到响应时间何时开始陡升，从而确定系统的最佳承载能力。

比如某微服务在 RPS=800 时 P99 为 150ms，但在 RPS=900 时跃升至 800ms —— 很明显，它的安全边界就是 800 RPS。

随机负载：仿真突发流量的真实感

节假日促销、社交媒体引爆、热点新闻推送……这些都会引发短时流量激增。

这类“脉冲式”访问很难用恒定或线性加压模拟。于是，trap 引入了基于统计学模型的 随机负载 机制。

核心思想是利用 泊松过程 来建模请求到达时间间隔。其概率质量函数为：

$$
P(k) = \frac{\lambda^k e^{-\lambda}}{k!}
$$

其中 $\lambda$ 是平均请求速率（RPS），$k$ 是实际发生请求数。

trap 在底层通过反向变换采样法生成符合指数分布的请求间隔时间 $T \sim Exp(\lambda)$，从而保证整体请求流符合统计规律。

示例代码如下： 

func generateInterArrivalTime(rps float64) time.Duration {
    lambda := rps
    interval := rand.ExpFloat64() / lambda
    return time.Duration(interval * float64(time.Second))
}

优势很明显：

  • 避免“同步冲击”：所有虚拟用户不会在同一毫秒发起请求；
  • 更好地测试缓存穿透、限流算法的有效性；
  • 可结合权重规则模拟特定页面跳转路径的概率分布。

比如某新闻网站在重大事件发布后，访问量几秒内从 100 RPS 飙升至 5000 RPS。使用随机负载就能很好地模拟这种“浪涌”效应，检验 CDN 缓存命中率与源站弹性扩容机制。

多协议支持：不只 HTTP，FTP 也能压！

现代系统通信依赖多种协议。如果压测工具只支持 HTTP，那显然不够看。

trap 的一大亮点就是对 HTTP/HTTPS/FTP 的原生支持，尤其在连接复用、加密握手、双通道传输等方面做了深度优化。

HTTP/1.1 vs HTTP/2：连接复用差异有多大？

特性 HTTP/1.1 HTTP/2
连接复用方式 持久连接，最多6个TCP连接 单个TCP连接上多路复用多个流
并发限制 受同源并发数限制 理论上无限制
头部压缩 无 使用 HPACK 算法压缩

trap 针对这两种协议分别实现了独立的客户端驱动： 

type HTTPClient interface {
    Do(request *HTTPRequest) (*HTTPResponse, error)
}

type HTTP1Client struct {
    client *http.Client
}

type HTTP2Client struct {
    conn net.Conn
    session h2quic.Session
}

当你指定 protocol: http2 时，trap 会自动选用 HTTP2Client ，并启用帧级流量控制： 

endpoint: "https://api.example.com/data"
method: GET
protocol: http2
concurrency_per_vu: 100

此时，单个 TCP 连接上可并发发起 100 个 stream，避免 HTTP/1.1 中的队头阻塞问题。实验显示，吞吐量可提升 3~5 倍。

HTTPS 握手太慢？TLS 优化了解一下

HTTPS 的广泛采用提升了安全性，但也带来了 TLS 握手开销的问题。

特别是在大量短连接场景中，频繁的非对称加密运算会导致 CPU 使用率飙升。

trap 提供两种优化策略：

  1. 会话复用 ：启用 Session Tickets 或 Session IDs，减少完整握手次数；
  2. 连接池预热 ：提前建立一批已握手的连接，供 VU 复用。

配置示例如下： 

tls:
  session_resumption: true
  cipher_suites:
    - TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
  cert_file: "/path/to/client-cert.pem"
  key_file: "/path/to/client-key.pem"

实测表明，在每秒 5000 请求的场景下，启用会话复用后 TLS 层 CPU 占用下降 40%，有效释放客户端资源。

FTP 文件传输：双通道协议也能压！

FTP 是典型的双通道协议，包含命令通道和数据通道。主动模式与被动模式切换时，还需要处理端口映射和防火墙穿越。

trap 对 FTP 的支持覆盖了登录认证、目录操作、文件上传下载等全生命周期动作。

以下是一个批量上传大文件的 YAML 配置： 

protocol: ftp
host: ftp.example.com
credentials:
  username: $FTP_USER
  password: $FTP_PASS
tasks:
  - action: cd
    path: /inbound
  - action: put
    src: "/local/files/*.zip"
    dst: "/remote/batch/"
    concurrency: 10
  - action: list
    path: "/remote/batch/"
    expect_count: 50

该配置表示：进入目录 → 并发上传 ZIP 文件 → 验证远程数量是否匹配。支持失败重试与断点续传，适用于金融、电信等行业的大宗数据交换压测。

性能监控怎么做？黑盒 + 白盒 + 灰盒三位一体

压测不只是“打”，还得“看”。

trap 构建了一套完整的性能数据采集与分析体系，涵盖客户端到服务器端的全链路监控。

黑盒、白盒、灰盒，三者缺一不可

类型 数据来源 优点 缺点 适用场景
黑盒 客户端侧请求记录 反映真实用户体验 无法定位内部瓶颈 压测主指标输出
白盒 服务器Agent/Node Exporter 揭示资源瓶颈 需额外部署 系统容量评估
灰盒 应用埋点（APM） 结合调用栈追踪 增加应用复杂度 微服务热点分析

推荐采用三者融合的混合监控模式：

  • trap 自身负责黑盒指标采集（延迟/RPS/错误率）；
  • 通过 Node Exporter 实现白盒采集（CPU/内存/IO）；
  • 结合 OpenTelemetry 实现灰盒追踪（trace ID 注入）。 
graph TD
    A[trap 发起压测] --> B{采集维度}
    B --> C[黑盒: 请求延迟/RPS/错误率]
    B --> D[白盒: CPU/内存/IO]
    B --> E[灰盒: 分布式追踪/日志关联]
    C --> F[汇总为性能报告]
    D --> G[绘制资源曲线]
    E --> H[生成调用拓扑图]
    F --> I[综合分析瓶颈]
    G --> I
    H --> I

只有将三类数据对齐，才能实现真正的根因定位。

关键指标选哪些？别让噪声淹没真相

并不是所有指标都值得监控。trap 建议围绕以下几个核心 KPI 构建基线：

  1. 响应时间 ：重点关注 P95/P99，反映大多数用户的体验水平；
  2. 吞吐量（RPS） ：单位时间内成功处理的请求数；
  3. 错误率 ：HTTP 5xx、连接超时等异常比例；
  4. 资源使用率 ：CPU、内存、网络带宽。

这些指标的选择标准是： 可操作、可比、可预测 。

例如，“CPU > 90%”可触发扩容；“P99 > 800ms”应告警降压。

trap 支持灵活过滤与聚合： 

metrics:
  include:
    - response_time_p95
    - throughput_rps
    - system_cpu_usage_percent
  sampling_interval: 1s
  output_format: json

内置监控模块：零侵入式数据采集

trap 的一大优势在于其 零依赖、内嵌式监控能力 。

无需修改被测系统代码，即可自动收集：

  • 请求延迟直方图（Histogram）
  • 吞吐量（RPS）
  • 错误率分类统计
  • TDigest 算法估算 P95/P99

还支持动态采样频率调节，确保监控过程本身不对系统造成负担。 

graph LR
    A[启动压测] --> B{资源采样}
    B --> C[监测trap自身CPU]
    C --> D[是否 > 5%?]
    D -- 是 --> E[增大采样间隔]
    D -- 否 --> F[维持当前频率]
    E --> G[重新评估]
    F --> G

Web 服务器实战：从准备到执行的全流程演练

最后，让我们走一遍完整的 Web 应用服务器压测流程。

明确目标：你是要找极限？还是要验稳定性？

测试类型 目标
容量规划 找出系统拐点与极限吞吐量
稳定性验证 验证长时间运行下的健壮性
峰值模拟 模拟秒杀等突发流量
故障恢复测试 验证熔断与自动恢复机制
回归性能对比 对比不同版本间的性能变化

构建真实拓扑

建议使用 Docker Compose 搭建包含 Nginx、Spring Boot、Redis、MySQL 的微服务架构，并接入 Prometheus + Grafana 实现可视化。 

graph TD
    A[trap 控制节点] --> B[压测代理集群]
    B --> C[Nginx 反向代理]
    C --> D[Spring Boot 实例1]
    C --> E[Spring Boot 实例2]
    D --> F[Redis 缓存]
    E --> G[MySQL 主从]
    F --> H[Prometheus]
    G --> I[Grafana]
    H --> I

编写基准脚本模板 

name: "web-server-benchmark"
duration: "30m"
rampup: "5m"
target: "http://nginx-gateway"

scenarios:
  - name: "user-login-flow"
    weight: 30
    requests:
      - method: GET
        url: "/api/user/profile"
        headers:
          Authorization: "Bearer {{token}}"
        expect:
          status: 200
          latency_p99: "<800ms"

此脚本可通过 CI/CD 自动调用，实现每日夜间性能回归测试。

结语：trap 不只是一个工具，更是一种工程思维

trap 的意义，远不止于“我能压多少并发”。

它代表着一种新的性能工程理念： 左移预防、自动化验证、可观测闭环 。

在这个快速迭代的时代，每一次发布都应该伴随着可靠的性能保障。而 trap，正是那把打开高质量交付之门的钥匙 🔑。

“最好的压测，是你根本没感觉到它存在，但它已经在默默守护你的系统。” – 某不愿透露姓名的 SRE 工程师 😎

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：trap（Transaction Rate Analysis and Performance Test）是一款轻量级但功能强大的压力测试工具，支持HTTP、HTTPS、FTP等多种协议，能够模拟高并发用户请求，用于评估服务器、数据库及网络服务在极限负载下的性能表现。本文详细介绍trap的安装使用、测试脚本配置、多种负载模式应用以及测试结果分析方法。通过Web应用、数据库等实际场景的测试案例，帮助测试人员掌握系统瓶颈识别与性能优化的关键技术，确保系统在高并发环境下的稳定性与可靠性。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
乐奇 Rokid 开放社区

更多推荐

Word Embedding ：从分布式假设到神经网络语言模型

Word Embedding（词嵌入）是一种将离散的词汇符号映射到连续的低维稠密向量空间的技术。在这个向量空间中，语义相似的词在几何距离上彼此接近，从而实现了从"符号匹配"到"语义计算"的跨越。核心定义词嵌入是将单词（或多词短语）表示为固定维度的实值向量，这些向量之间的距离（例如余弦相似度）反映了单词之间的相关性，这种相关性基于单词通常出现的上下文。分布式假设（1954）↓统计共现分析（LSA/S

avatar 乐奇 Rokid 开放社区

镜游小导：运行在 Rokid AR 眼镜上的景区实景讲解智能体

项目以 RokidAIUI 开放智能体形态交付：页面用.ink描述，运行在眼镜端智能体运行时，直接调用系统能力。AGENTS.md身份镜游小导v1.0.0，景区 AR 实景讲解智能体；权限（Capabilities）microphonenetworkaudiogyroscope；技能（Skills）。

avatar 乐奇 Rokid 开放社区
cover

AI 智能眼镜技术文档

avatar 乐奇 Rokid 开放社区