Skip to main content
Glama

@m00nsolutions/mcp-server

npm CI node license

通过 MCP 实现代理式测试管理。这个服务器让 AI 助手能够实际执行工作,而不是只能阅读相关说明:编写测试用例,规划并填充手动测试执行,将自动化关联回其覆盖的用例,发布版本,并在 M00N Report 中查看项目健康状况——这是一个 AI 原生的测试管理平台。

m00nreport/mcp-server MCP server

我需要哪种安装方式?

本 npm 包(stdio)

托管的远程连接器

运行方式

npx @m00nsolutions/mcp-server 作为本地进程运行

无需本地进程;客户端通过 HTTP 与 API 通信

身份验证

M00N_API_KEY 中的 MCP 密钥

OAuth 2.1 with PKCE,浏览器同意屏幕

客户端

任何 MCP 客户端:Claude Code、Claude Desktop、Cursor 等

仅限 claude.ai 和 claude.com

如果你不是从 claude.ai 或 claude.com 连接,请使用带 MCP 密钥的本包。这就是此 README 的其余内容。关于连接器,请参阅 连接器指南。

Related MCP server: @testneo/mcp-server

要求

Node 20 或更高版本,以及任何支持 MCP 的客户端。

安装

无需安装步骤。客户端会按下面的配置用 npx 启动它。

要在共享或 CI 环境中固定版本,请在 args 中的包名后追加版本号,例如 ["-y", "@m00nsolutions/mcp-server@<version>"]。npm view @m00nsolutions/mcp-server versions 会列出已发布的所有版本。这里是故意用占位符而不是实际数字:具体的示例会在下次版本发布后过时,而过时的示例会建议固定到一个不再包含当前修复的版本上。

快速开始

1. 获取 MCP 密钥

在 M00N Report 中,打开 Settings -> MCP Keys,然后创建一个密钥。它会以 m00n_mcp_ 开头,后接 48 个十六进制字符。这不是测试报告器所使用的凭据;它们的凭据以 m00n_ 开头,在这里会被拒绝。

一个 MCP 密钥恰好只带有其所属账户的权限,绝不会更多,而且可以进一步缩小作用域。缩小作用域会从客户端看到的列表中移除工具,因此工具列表比预期更短是作用域限定的结果,而不是错误。

密钥应放在你机器上的 MCP 客户端配置中。不要把它放在仓库中的某些工作区文件里。

2. 连接你的客户端

Claude Code,只需一行:

claude mcp add m00n --env M00N_API_URL=https://m00nreport.com --env M00N_API_KEY=m00n_mcp_... -- npx -y @m00nsolutions/mcp-server

其他所有客户端都采用相同的 JSON 配置块:

{
  "mcpServers": {
    "m00n": {
      "command": "npx",
      "args": ["-y", "@m00nsolutions/mcp-server"],
      "env": {
        "M00N_API_URL": "https://m00nreport.com",
        "M00N_API_KEY": "m00n_mcp_your_key_here"
      }
    }
  }
}

这个配置块放在哪里:

客户端

配置文件

Cursor

~/.cursor/mcp.json

Claude Desktop,macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Claude Desktop,Windows

%APPDATA%\Claude\claude_desktop_config.json

对于自托管实例,请将 M00N_API_URL 指向你自己的根地址,不要使用 /api 后缀。末尾的斜杠会自动去除。

3. 确认连接

重启客户端,然后向它提问:

列出我的 M00N Report 项目

出现你的项目列表,就说明服务器已连接且密钥有效。如果报错,或者助手说没有这个工具,则说明没有连接成功;请参见 故障排除。

工具

涵盖八个方面。包含参数的完整列表位于 /documentation/mcp/tools,保持在代码旁边。服务器会在启动时从你的实例获取自己的列表,因此你的客户端所看到的就是你的实例在客户端连接时所支持的内容。

区域

涵盖内容

项目与分析

项目、启动趋势与统计、逐测试历史、跨自动化测试搜索

测试用例

创建、读取、更新、移动、删除、编辑批量或关联自动化测试到其覆盖的用例

文件夹和套件

文件夹与套件层级,以及每个文件夹的统计

测试集合

可复用的命名用例集合,可插入任意执行中

手动执行

从套件、集合或单个用例构建执行,然后记录每个用例的结果

发布

创建并管理发布版本,以及附加或分离发布所属于的 test run 结果

健康与覆盖率

综合健康检查、双向的覆盖缺口、用例建议、功能扫描、feature 导出

外部链接

在用例上附加或移除 Jira 或 Linear 工单

一次执行就是一次手动测试运行包:对象、环境、日期,以及根据每个用例在加入时的快照而记录的每个测试步骤的结果。

你的密钥可以看到多少个工具,由你的实例决定:

curl -s -H "X-MCP-Key: $M00N_API_KEY" "$M00N_API_URL/api/mcp/tools" | jq .count

作用域受限的密钥看到工具数量会有所减少。这里故意不给出具体数字:这界面会随 release 变化,而 README 中的数字就是没有人记得去更新的地方。

提示(Prompts)

客户端可按名称提供的多步骤第步作流引导。每个提示词均接受一个可选的 project 参数,参数值为项目名称或 UUID;省略它,并且当前范围内只有一个项目时,服务器就会选择这个项目。

Prompt

Project 版本 (仅通过工具列表体现)

analyze_flaky_tests

找出频繁不属性变化的测试,并按名字加以排序

debug_test_failure

从历史记录和时间追踪中将单个失败反复到某个因素

release_readiness

判断该版本是否可安全部署

generate_test_cases

为还没有测试用例的领域起草生成手动测试用例

weekly_health_report

总结本周项目中各项目的情况

investigate_regression

发现某次 pass 与 fail 运行之间发生了什么变化

run_manual_execution

将手动测试周期从测试生成到逐用例结果完成

资源

预定义视图供并客户端用于无需提示器直接检索印章资源:全部项目、项目健康摘要、不稳定测试报告、当前正在失败的测试、文件夹结构、等级报告、测试用例内容、发布摘要。

配置

环境变量

是否必需

默认

说明

M00N_API_URL

需要

你的 M00N Report 的 URL。根地址,不包含 /将 前缀。尾部 / 会自动去除。

M00N_API_KEY

需要

你的 MCP 密钥(M00N_API_KEY)。任何没有该前缀的值都会在第一个请求前被拒绝。

M00N_DEBUG

否

false

是否在 stderr 输出每个请求的详细信息,包括每次工具调用的参数。启动步骤和错误总是会记录。

M00N_TIMEOUT_MS

否

30000

请求超时的毫秒数(纯数字)。会拒绝 60s、1e4、30,000 和 1.5,并会给出 stderr 警告,然后使用默认值。

M00N_INSECURE_SSL

否

false

是否接受自签名证书。仅用于自托管实例。

两个布尔值要求改成对应开关的值为 true、1 或 yes,区分大小写不计。其他任何值(包括 false 和 0)都会关闭它们。

这两个基本命令,要么同时设置,要么都不设置。只设置其中一个会被视为错误并拒绝,因为一个配置了一半就已启动的服务器比不启动的服务器更难诊断。

这里的根 URL 是 M00N_API_URL;测试报告器引用的同一个 URL 也被称为 M00N_SERVER_URL。所有六个浏览器扩展都会读取 M00N_API_KEY,但它们的密钥是项目 API 的密钥,而非 MCP 密钥,所以同一个导出的 shell 变量无法同时服务两者。

无密钥运行

如果在没有 M00N_API_URL 和 M00N_API_KEY 的情况下启动,服务器就会进入第三方浏览模式:它会根据附带的快照,列出工具、提示词和资源,并通过说明需要设置密钥什么信息来拒绝每个调用。因为没有传递地址可返回,所以不会向任何地方发送任何数据。

这就是为什么当服务器还没有接入之前,巡查器、客户端或 indexer 就能展示其可预留给工具的直接画面。它只是服务器的描述,并不是一个可用的贡献者;列表因此来自快照而不是你的实例:一个带作用域范围的密钥通常比快照中显示的工具数量少。

维护者可以使用无作用域的密钥通过 npm run snapshot:refresh 来刷新快照。

自托管

将 M00N_API_URL 指向你自己的实例,并从该实例签发 MCP 密钥。其他所有操作都是相同的这一点(当原因是你的测试数据格外重要时,也正是因为不能离开你的网络,所以需要自托管)。

使用自签名证书时,请在同一个 env 块中添加 "M00N_INSECURE_SSL": "true"。详细说明:/documentation/mcp/self-hosted。

发送哪些内容

通过 HTTPS 向 M00N_API_URL 发送的是:你的助手发出的工具调用及参数。该服务器只是你的实例的一个代理,自身不会存储任何内容。

每次工具调用都会写入一个 MCP 审计日志,并使用应用内的 UI;按密钥进行的速率限制会限制第三方失控。密钥永远不会写入审计日志,也不会写入 stderr。在 M00N_DEBUG 下,每次工具调用的参数都会打印到 stderr,因此请像保护数据本本身那样对待该日志内容。

Troubleshooting

故障排除

(No body)

症状

原因

客户端没有显示 M00N Report 工具

配置未重新加载。请完全重启客户端,而不仅仅是重启对话。

工具已列出,但每次调用都返回 running unconfigured

M00N_API_URL 和 M00N_API_KEY 都未到达进程,因此它以预览模式运行。请检查 env 块是否确实应用于该服务器。

M00N_API_KEY should start with "m00n_mcp_"

那是项目 API 密钥,就是测试报告者使用的那种。MCP 密钥是独立的:设置 -> MCP Keys。

Authentication failed: Invalid or expired MCP key

密钥错误、已撤销,或来自另一个实例。或者 M00N_API_URL 带有 /api 后缀,这会使每个请求都返回 401,无论密钥多么正常。先检查 URL,然后再签发新密钥。

WARNING: M00N_API_URL is http://...

这不是错误,服务器会继续运行。它意味着密钥会以未加密方式随每个请求发送。除非实例位于受信任的专用网络上,否则请使用 https。环回地址不会触发警告。

... redirected to ...

URL 返回了重定向,而重定向不会被跟随,因为 MCP 密钥会被发送到它们指向的任何位置。请将 M00N_API_URL 设置为直接响应的地址,通常是 https:// 形式。

Cannot connect to M00N Report API at ...

该 URL 上没有服务在监听。实例已关闭,或者端口未对你开放。

Cannot resolve M00N Report API host

主机名无法解析。可能是拼写错误,或者从网络外部访问了专用名称。

Request to M00N Report API timed out

调高 M00N_TIMEOUT_MS,或检查网络路径。

SSL certificate error connecting to ...

自托管实例使用自签名证书。请将 M00N_INSECURE_SSL 设置为 true。

Not found during ...

该行其余部分是服务器自身的响应,通常点明修复方法,例如哪些项目存在。在改动设置前请先阅读。

Rate limit exceeded. Retry after Ns.

每个密钥每分钟 1000 次工具调用,基于滑动窗口。消息会提示等待时间。执行任务的智能体很少接近该限制;出现此消息通常意味着存在循环。

工具数量少于预期

密钥受权限范围限制,或实例版本旧于软件包。工具列表来自你的实例。

无论是否设置 M00N_DEBUG,服务器都会向 stderr 记录日志,大多数客户端会在其 MCP 面板中显示这些日志。将 M00N_DEBUG 设置为 true,可为每个请求及其参数添加日志。

已知限制

  • 工具列表会在启动时读取一次。 重新调整密钥范围或升级实例后,客户端会保留旧列表,直到你完全重启客户端。

  • GET /api/health 必须在配置后不可正常访问。 它会在其他一切运行前被检查,一旦失败服务器就会停止;因此,一个只转发 /api/mcp/* 的代理即使每个工具都能工作,也会无法显示任何工具。

  • 作用域为零个工具的文件不会启动。 服务器会退出,而不是使用空列表连接。这是已配置路径的路径;如果没有配置任何凭据,它会以预览模式启动。

  • 提示和资源是可选的。 如果这些列表获取失败,服务器会继续启动、失败原因会写入 stderr,并且客户端在整个会话中都看不到它们。

  • 重定向会被拒绝,而不会跟随。 密钥位于自定义标头中,而重定向跟随者只会剥离它们可识别的身份验证标头;因此,跟随重定向会把密钥交给重定向后的目标主机。重定向消息中会包含其指向的地址。

  • 仅支持 stdio。 如需 HTTP 传输,请使用托管连接器。

支持

许可证

MIT 许可证。参见 LICENSE。

Available Tools

55 tools
add_cases_to_collectionA
Idempotent

Add test cases to an existing test collection. Cases must exist and belong to the same project. Duplicate cases are skipped.

Inputs: caseIds (required), collectionId (required).

add_cases_to_executionA

Add individual test cases to a Manual Test Execution as a new named group. Unlike suites and Collections, loose cases have no identity of their own, so name is required and the group it creates is what appears in the execution; the call returns its groupId. caseIds are NUMERIC ids, never TC-numbers. Use add_suites_to_execution or add_collections_to_execution when the cases are already gathered into one of those. Cases from another project are skipped, and an empty result creates no group. Returns {added, skipped, groupId}.

Inputs: name (required), caseIds (required), executionId (required).

add_collections_to_executionA

Add whole Test Collections to a Manual Test Execution. Each is snapshotted in and keeps its own identity inside the execution. Pick this when the work is already gathered into a Collection. Use add_suites_to_execution to take the current cases of a suite instead, and add_cases_to_execution for loose cases, which need a new named group. Collections from another project are skipped, as are shadow collections, and one already in the execution is skipped rather than snapshotted twice. Returns {added, skipped}.

Inputs: executionId (required), collectionIds (required).

add_suites_to_executionA

Add whole Suites to a Manual Test Execution. The cases each suite holds are snapshotted in as they stand now, and the suite keeps its own identity inside the execution. Pick this when the work is organised by suite. Use add_collections_to_execution when it is already gathered into a Test Collection, and add_cases_to_execution for loose cases, which need a new named group instead. Suites from another project are skipped, and a suite already in the execution is skipped rather than snapshotted twice. Returns {added, skipped}.

Inputs: suiteIds (required), executionId (required).

bulk_update_casesA
Idempotent

Update many test cases in one call - status, priority and tags - up to 100 at a time, all belonging to the same project. Returns updated, skipped, notFound and an errors array. Two different failure modes, and only one of them is all-or-nothing. Unknown or archived ids do NOT stop the batch: they land in notFound and in errors while every other case is still written, so read updated rather than treating the call as a whole. An unrecognised status or priority value, or ids spanning two projects, is rejected outright with nothing written. Each field is replace-all across the batch and there is no undo, so snapshot the current values with list_test_cases first if you may need to put them back.

Inputs: caseIds (required), updates (required).

create_executionA

Create a Manual Test Execution, the top-level container on the Executions page, which aggregates Test Collections, suites and named case groups. NOT the same as a Test Collection: use create_test_collection for a single grouping of cases, and this to assemble an execution out of several. Returns the whole execution under an execution key: id, name, description, status, priority, environment, assignedTo, startDate, endDate, projectId and createdAt. The id you need for everything else is execution.id, not a top-level id. It starts empty, so follow with add_suites_to_execution, add_collections_to_execution or add_cases_to_execution to put something in it.

Inputs: name (required), projectId (required), status, endDate, +6 more.

create_folderA

Create a folder or a suite in a project. Use type "suite" for a leaf that holds test cases, and "folder" for a container that holds other folders and suites. Omitting type gives "folder" at the root and "suite" when nested, which is usually what you want. Suites cannot be parents, so a suite always needs parentId. Returns the new folder id, its type, and its path. To read an existing one use get_folder; to list them use list_folders.

Inputs: name (required), projectId (required), type, parentId.

create_releaseA

Create a new release in a project. Releases track versions and aggregate manual and automated test results. projectId comes from list_projects. Omit status to default to "planned". Returns the created release with id, name, version, description, status, startDate, endDate, projectId, projectName, createdAt and updatedAt; keep the id, it is what the other release tools take. Not idempotent - calling twice with the same name creates two separate releases, so check list_releases first. When the release already exists and only its name, version, dates or status should change, use update_release instead. The new release starts empty and nothing else is modified: attach automated launches with link_launches_to_release, and attach manual executions from the execution side via the releaseIds argument of create_execution or update_execution.

Inputs: name (required), projectId (required), status, endDate, +3 more.

create_test_caseA

Create a new test case in a test suite. Test cases MUST live inside a suite (not a bare folder). You can provide either: (A) a folderId pointing to an existing suite, or (B) a projectId with optional folderName/suiteName to auto-create the folder→suite hierarchy. If folderId points to a folder (not a suite), a suite is auto-created inside it. Returns the full created case object including shareUrl. Tags are auto-created if they do not exist. IMPORTANT: omit status and priority and the case takes whichever values THIS PROJECT marks as its defaults, which are Draft and Medium only until a project edits them. Call get_project to see what a given project uses.

Inputs: title (required), tags, steps, status, +9 more.

create_test_collectionA

Create a Test Collection and optionally add test cases to it. This is one Test Collection, NOT the top-level Executions-page container - use create_execution for that (an execution can then include this collection via add_collections_to_execution). Returns the created collection with count of added tests. Omit priority to default to "medium". A new Collection always starts at status not_started and there is no status argument here: use update_test_collection if it needs to start anywhere else, which is a second call.

Inputs: name (required), projectId (required), caseIds, folderId, +5 more.

delete_executionA
DestructiveIdempotent

Soft-delete an entire Manual Test Execution, and unlink any Test Collections that pointed to it. The Collections themselves, and the suites and cases behind every source, are left intact: only the execution and its result rows go. Reversible only via support or the database, so use with care. IMPORTANT: do any per-source cleanup FIRST. Once the execution is deleted, remove_source_from_execution answers Execution not found, so there is no route back to its sources. To remove just one source group instead of the whole execution, use remove_source_from_execution. Returns deleted: true.

Inputs: executionId (required).

delete_folderA
DestructiveIdempotent

Soft delete (archive) a folder and all its contents. Archives all nested folders and test cases recursively. Can be restored via the UI.

Inputs: folderId (required).

delete_releaseA
DestructiveIdempotent

Soft delete (archive) a release. The release can be restored via the UI. All linked Test Collections and launches are preserved.

Inputs: releaseId (required).

delete_test_caseA
DestructiveIdempotent

Soft delete (archive) a test case. The case can be restored via the UI. Also unlinks any connected autotests.

Inputs: caseId (required).

delete_test_collectionA
DestructiveIdempotent

Archive (soft delete) a test collection. The collection can be restored via the UI. Test executions are preserved.

Inputs: collectionId (required).

export_reportA
Read-onlyIdempotent

Generate a formatted report for a project. Supports summary, failures, trends, and release reports in markdown or JSON. Returns the report content as a string. The summary report carries a runs block of total, passed and failed, which counts LAUNCHES and does not add up: a launch stored as finished, running or interrupted is in total and in neither bucket, exactly as get_launches_statistics explains. It also carries a tests block of total, passed, failed, skipped, flaky and passRate, where passRate is (passed + flaky) / total: flaky counts as a pass because the test passed on a retry, and total excludes skipped, so passed + failed + flaky adds back to total and the figure can be checked by hand. It is floored to two decimals rather than rounded, so a period with a single failure never prints as a flat 100 - which also means it can sit a hundredth below the same rate from get_launches_statistics, which rounds. NOTE: reportType "release" requires the releaseId argument (get it from list_releases) and ignores days, since it covers everything linked to the release however old. It reports manualTesting with runCount, totalTests, passed, failed, blocked, inTesting and notExecuted, and automation with launchCount, totalTests, passedTests, failedTests, skippedTests, flakyTests and passRate.

Inputs: projectId (required), days, format, releaseId, +1 more.

get_case_execution_historyA
Read-onlyIdempotent

Get how one manual test case has fared over time, across every Manual Test Execution and release it appeared in, newest first. Returns executions and summary. The headline figures are NESTED under summary, not at the top level: summary carries totalExecutions, executedCount, passed, failed, blocked, inTesting, notExecuted and passRate. totalExecutions counts memberships, including times the case was added and never run. executedCount is every row that has actually been touched, which INCLUDES rows still in_testing, so passed + failed + blocked + notExecuted can come to less than totalExecutions and the shortfall is inTesting. passRate is passed divided by executedCount, so an unfinished in_testing row sits in the denominator and drags the rate down. That denominator is not the one list_executions uses: its progress.passRate divides by the total case count, counting never-run cases against the rate, so the two figures share a name and are not comparable. Each row carries id, status, runId, runName, executedBy, executedAt, notes and source. source is a STRING, not an object: it reads either "standalone", and then the row also carries executionId and executionName as siblings, or "release", and then it carries releaseId, releaseName and releaseVersion instead. Compare it as a string - row.source === "release" - because row.source.type is undefined on every row and filters silently to nothing. A row whose source is release carries releaseId, releaseName and releaseVersion but no executionId, even though it does sit inside a Manual Test Execution. It can still be traced there, by either of two joins: the row id is the same value get_execution_cases returns as executionCaseId, and the row runId is the same value get_execution returns as sources[].id. Both joins run FROM an execution, though, and nothing takes a runId or an executionCaseId and hands back the execution holding it. Use get_release on the releaseId the row does carry and match against its linkedExecutions: list_executions has NO releaseId filter, and an unrecognised argument is ignored rather than rejected, so passing one there silently returns every execution in the project. IMPORTANT: limit bounds the summary as well as the list, so those figures describe the returned page rather than the whole window, and days defaults to 30, so a case last tested longer ago returns almost nothing and reads as never tested. Pass days explicitly; 365 is the ceiling, so for a case older than a year there is no way to ask for all of its history at once. This covers MANUAL results only: use get_test_history for an automated test across launches, and get_execution_cases for the rows inside one execution.

Inputs: caseId (required), days, limit.

get_coverage_gapsA
Read-onlyIdempotent

Identify test coverage gaps across a whole project. Every count here is of LIVE cases: archived ones are excluded throughout, and a project can hold several times its reported total once includeDeleted is passed to list_test_cases. Returns summary (totalCases, linkedCases, unlinkedCases, automationRate), foldersWithLowCoverage (folderId, name, caseCount, linkedCount, automationRate) for folders under automationThreshold - counted over the cases held DIRECTLY by each folder, so leaf suites appear and the containers above them do not, whatever sits nested beneath - unlinkedCases (caseId, displayId, title, status, priority, folderName) for cases with no linked autotest, and the reverse gap unlinkedAutotests, meaning autotests seen in the most recent launches that are linked to no case. IMPORTANT: unlinkedCases is an array but unlinkedAutotests is an OBJECT, shaped launchesScanned, totalUnlinked and items. items is hard-capped at 50 rows however large totalUnlinked is and whatever limit you pass, since limit sizes unlinkedCases and does not reach it, and it is drawn only from the last recentLaunches launches, 10 by default. So a title missing from items does NOT mean it is linked: it may be beyond the cap or older than the window. Two different definitions of linked are at work in one response, so read them apart. unlinkedAutotests ALONE uses the broad one: a test counts as linked there if it was linked with link_autotest_to_case OR if its title carries a [TC-N] marker that ingest resolved onto the test row. summary.linkedCases, summary.automationRate, foldersWithLowCoverage and unlinkedCases all use the narrow one and see only explicit links, which is also what get_test_case and the automationStatus filter of list_test_cases see. A case can therefore be counted unlinked in the same payload whose unlinkedAutotests treats its marker-bound test as covered. To settle one title, read get_test_case with includeRecentExecutions: a marker-bound test shows up there against its case and nowhere else, and search_tests will not help because it returns no linkage fields at all. totalUnlinked counts DISTINCT test titles, not rows or attempts, and is scoped to the same recentLaunches window as items rather than to the whole project. Read-only, nothing is written; close a gap afterwards with link_autotest_to_case. Pick this when the question is which cases or folders lack automation project-wide. Prefer get_feature_scan when the scope is a single Jira issue and Jira is connected, run_health_check when you want one scored assessment in which coverage is only one dimension, search_tests when you already know the autotest and want its results, and suggest_test_cases when the gap is a case that does not exist yet rather than a missing link. projectId comes from list_projects.

Inputs: projectId (required), limit, recentLaunches, automationThreshold, +1 more.

get_executionA
Read-onlyIdempotent

Get one Manual Test Execution with everything attached to it. Returns execution (the container itself), sources (one entry per suite, Collection or case group added), releases, externalLinks, and progress. Each source carries id, name, sourceType, status and the case counts total, passed, failed, blocked, inTesting and notExecuted. Two traps in there. First, sources[].id is the id of the GROUP inside this execution, not the suite or Collection id you added: it is what remove_source_from_execution and set_execution_source_status take as runId. Second, execution.status and sources[].status come from two different vocabularies, execution_status and test_run_status, so not_executed and not_started are both correct in their own place; call get_project for the values a project actually uses. And both are SET BY A PERSON, not derived from the counts beside them: an execution can read passed with all four of its cases still not_executed, and a source can read completed with seven of seven unrun or blocked with nothing blocked. Never infer one from the other - read progress and the per-source counts for what actually happened. list_executions and get_release repeat these labels unchanged, so the same caution applies wherever they appear. progress carries the same counts across the whole execution PLUS passRate and completionRate, both whole percentages from 0 to 100. Their bases are not the same and the surprising one is passRate: it is passed divided by TOTAL, so every case not yet run counts against it and an execution with one pass, one failure and one unrun case reports 33 rather than 50. completionRate is (total - notExecuted) / total. The entries in sources carry the counts but not these two, so apply the same two formulas to a source if you need them per source. Use get_execution_cases for the individual case rows, which is also where report_case_result gets its executionCaseId, and list_executions to find an id.

Inputs: executionId (required).

get_execution_casesA
Read-onlyIdempotent

List the individual case-run rows of a Manual Test Execution so you can report results against them. Returns each row with executionCaseId (a UUID, and the value report_case_result takes), caseId, caseNumber, title, group and groupId, sourceType, current status, the case-level result fields (notes, causedBy, durationMinutes, executedBy, executedAt), parentCases, the externalLinks of the case (Jira or Linear tickets, present only if you also hold integrations:read), and steps (0-based index, action, expected, current step status, issueDescription). groupId is the one to keep: it is what report_case_result wants when the same case sits in more than one source group, while group is only that group name. sourceType says whether the group came from a suite, a Test Collection or a bare set of cases. Note that the title field is called title here while get_case_execution_history calls the same thing caseTitle. caseId is null on rows whose underlying case has been deleted, so target those by executionCaseId, which is always present. executedBy here is the internal user UUID of whoever last recorded a result, not a name, and nothing on this surface resolves a user UUID - get_case_execution_history returns that same field for the same rows as an EMAIL ADDRESS, so call that one when you need to say who. It can be null even where executedAt is set, on seeded or imported results, and it records who last WROTE a result rather than who owns the case: a case row carries no assignee at all. durationMinutes is written only by report_case_result and has no control in the UI, so it is null on most rows. Everything report_case_result writes reads back here. Use after add_suites_to_execution, add_collections_to_execution or add_cases_to_execution, and before report_case_result. Supports paging and filtering by group, status or title.

Inputs: executionId (required), limit, offset, search, +2 more.

get_feature_scanA
Read-onlyIdempotent

Get a comprehensive feature health scan by Jira issue key. Returns Jira context (summary, status, type, assignee), test coverage stats (case count, automation ratio, pass rate, risk score), linked test cases, and autotest results with recent run trends. UNITS: automationRatio, executionCoverage, autotestPassRate and manualPassRate are FRACTIONS from 0 to 1 here, so 0.2 means 20 percent. Every sibling answers in percent from 0 to 100 - get_coverage_gaps automationRate, run_health_check - so multiply before quoting one beside the other. IMPORTANT: each case row carries BOTH definitions of linked at once. automationStatus and linkedAutotestCount, and the automationRatio built from them, count only explicit links made with link_autotest_to_case, while the same row launches and lastAutotestResult also reflect a test bound by a [TC-N] title marker. So a row reading automationStatus manual with linkedAutotestCount 0 can sit beside passing automated launches: that case IS covered and was simply never linked explicitly. Read the row launches before calling a case uncovered, and treat automationRatio as a floor. Automatically detects issue hierarchy and aggregates child issues (2 levels deep: epic→story→subtask). Requires Jira to be connected to the organization.

Inputs: jiraKey (required).

get_folderA
Read-onlyIdempotent

Get one folder or suite by id. Returns id, name, type, parentId, projectId, projectName, path, depth, casesCount, childFolderCount, displayOrder, createdAt and updatedAt. casesCount counts cases DIRECTLY in this folder, so a container folder reports 0 however much sits beneath it; childFolderCount tells you whether that is the case. Set includeStats for a statistics object over the folder AND everything nested under it, which is where totalCases, automatedCases, automationRate, status and priority breakdowns, tag usage and time-based metrics live: expect statistics.totalCases to exceed casesCount. Cases whose status or priority is null are left out of those two breakdowns, so statusCounts and priorityCounts need not sum to totalCases, and the shortfall is the count of unset ones rather than an error. Set includeCases for the most recent cases directly in it, capped by casesLimit; they come back under recentCases, not cases. Every count here is of LIVE rows: archived cases and archived subfolders are excluded from casesCount, childFolderCount and the whole statistics object, so a suite reporting 45 can still answer with several times that through list_test_cases with includeDeleted. Use list_folders to see the tree or find an id; use this when you have one id and want detail.

Inputs: folderId (required), casesLimit, includeCases, includeStats.

get_launches_statisticsA
Read-onlyIdempotent

List the launches of a project, newest first, each with its own pass, fail, skip and duration figures. Every launch row carries id, launch, status, startedAt, endedAt, durationSeconds, tags and stats - the NAME of the launch is in a field called launch, not title or name. The status is REPORTED by the CI job rather than derived from the numbers beside it, and it runs BOTH ways. A launch can be stored failed with stats.failed 0, because the job failed for a reason no test recorded. And a launch that reported nothing at all can be stored passed with stats.total 0 - one here sits 75 minutes after a real run that failed 145 tests, so reading the newest launch as green clears nothing and the earlier failures still stand. Check stats.total before treating a green newest launch as evidence. Never infer one from the other; to answer what failed, read the tests with get_launch_tests. Every launch row also carries a stats object of total, passed, failed, skipped, flaky, retries and running. total EXCLUDES skipped even though skipped is printed beside it, so the identity that holds is passed + failed + flaky = total; retries counts retry ATTEMPTS, not tests that were retried, which is why it can exceed flaky. Returns launches, a summary over the whole window (totalRuns, passedRuns, failedRuns, runningRuns, runPassRate, totalTests, totalPassed, totalFailed, totalSkipped, totalFlaky, testPassRate, avgDurationSeconds), the period and filters applied, and pagination with the real total; there is no top-level total. Read the two rates carefully, because they answer different questions and neither denominator is obvious. runPassRate is the share of LAUNCHES that ended green, out of totalRuns - and totalRuns is EVERY launch in the window. Only three of the end statuses have a bucket - passedRuns, failedRuns and runningRuns - so a launch stored as finished, interrupted, timedOut or completed is counted in totalRuns and in none of them, and the three need not add up to totalRuns. That shortfall is why get_launches_trends and run_health_check answer a slightly higher run pass rate over the same window: they count only launches that passed or failed, so their denominator is smaller. testPassRate is the share of TESTS, computed as (totalPassed + totalFlaky) / totalTests: flaky counts as a pass, because a flaky test passed on a retry and the launch is green on it, and totalTests already EXCLUDES skipped, so totalPassed + totalFailed + totalFlaky is the whole of it while totalSkipped sits outside. Both rates are null, not 0, when the window held nothing at all - testPassRate with no tests, runPassRate with no launches - since nought percent would read as a verdict on work that never ran. IMPORTANT: days defaults to 30, so a project idle for longer returns an empty list, which means nothing in the window rather than nothing at all. Use limit, offset and search to page, statuses or tags to narrow. Reach for get_launches_trends when the question is about the project over time rather than about particular launches, and get_launch_tests when you have one launch and want the tests in it.

Inputs: projectId (required), days, tags, limit, +3 more.

get_launch_testsA
Read-onlyIdempotent

Get every test inside one launch, with results, error messages and stack traces for the failures. IMPORTANT: rows are one per retry ATTEMPT, not one per test, so a retried test appears more than once and the row count can exceed the launch stats counts, while the stats on the launch itself count tests rather than attempts. Two traps follow, and both have produced a wrong count. First, testId is minted per ROW, so every attempt has a different one and deduplicating on testId still counts attempts: the identity of a test across its attempts is titlePath, optionally with filePath. Second, retry is 0-based but a retry:0 row is NOT guaranteed to exist - a launch can hold a retry:1 row whose first attempt was never stored - so counting rows where retry is 0 undercounts. Count distinct titlePath. Each row also carries status, previousStatus, durationMs, tags and errors. previousStatus reads superseded on an attempt a later one replaced, which looks like the clean way to filter, and is not: on a measured launch of 4472 rows, dropping the superseded ones left 4460 against 4457 real tests, because a retried attempt can carry its own earlier result there instead. The launch stats embedded in this response follow the same convention as everywhere else: total EXCLUDES skipped, so a launch with total 4417 and skipped 40 really does hold 4457 distinct tests, and passed counts first-time passes with flaky held separately. Use this once you have a launch id, which get_launches_statistics gives you; use get_test_history to follow one test across launches instead. For each failed test that has artifacts the response carries an attachments array of id, name, contentType, size and url. The url is fully qualified: if it is an API URL, fetch it with the same X-MCP-Key header you use for this server, while presigned storage URLs need no header. That is how you reach screenshots, traces, videos and source files when investigating a failure.

Inputs: launchId (required), limit, offset, search, +2 more.

get_projectA
Read-onlyIdempotent

Get a project's configuration: its meta, the system-field vocabularies it actually uses (statuses/priorities/environments), and its case custom-field definitions. Call this to discover the VALID status and priority values before setting any of them: case_status and case_priority (test cases), execution_status (a Manual Test Execution overall), test_case_execution_status (a case inside one), test_run_status (a source group or a Test Collection), release_status (releases) and test_environment. Every one of them is project-customizable, so never hardcode a value or assume the stock list. Each entry is { value, label, isDefault }: send the VALUE to other tools, never the label, and isDefault marks what a create tool will use when you omit the field. Returns { project, systemFields{ case_status, case_priority, execution_status, test_case_execution_status, test_run_status, release_status, test_environment }, customFields[] }.

Inputs: projectId (required).

get_releaseA
Read-onlyIdempotent

Get one release by releaseId with full detail: name, version, status, projectId, projectName, dates, and a stats rollup for linked manual executions (count, total, passed, failed, blocked, inTesting, notExecuted) and linked automated launches (count, total, passed, failed, skipped). The status on a release is a label a person applied, not a verdict derived from these numbers, so read the rollup rather than the word. The manual rollup counts EXECUTIONS only: a Test Collection whose releaseId points at this release is not included and adds nothing to the counts, so a release can read total 0 while collections filed under it hold results. It also counts result ROWS rather than surviving cases: a row whose underlying case was deleted keeps its recorded result and stays in every figure here, showing up in get_execution_cases with caseId null - on one release 13 of the 16 reported passes are against cases that no longer exist. And rows are SUMMED across the linked executions with no deduplication, so a case in two executions counts twice and can read passed in one and not_executed in the other. Page get_execution_cases and count the null-caseId rows and the repeated caseIds before quoting these numbers anywhere that matters. Check list_test_collections with releaseId before reporting a release as untested. By default it also returns the linkedExecutions and launches arrays, each entry with its own name, status, dates and per-item stats; set includeLinkedExecutions or includeLaunches to false to drop an array and keep the response small, since the stats rollup comes back either way. Read the launches rollup carefully, because it does not follow the same convention as get_launches_statistics: passed here ALREADY INCLUDES flaky, there is no separate flaky field, and total excludes skipped - so passed + failed equals total exactly while skipped sits outside it, and adding skipped back appears to overshoot. Use list_releases instead to browse, search or filter the releases in a project and to obtain releaseId; it returns the same rollup per release but never those two arrays, so call get_release once the release of interest is known. Read only, nothing is modified. An archived release still resolves here, unlike list_releases which hides it unless includeDeleted is set; the deleted flag in the response says which it is.

Inputs: releaseId (required), includeLaunches, includeLinkedExecutions.

get_test_caseA
Read-onlyIdempotent

Get one manual test case in full: id, caseNumber, displayId, title, description, status, priority, tags, ordered steps, folderId/folderName, projectId/projectName, dependsOn, customFields, createdAt/updatedAt and a shareUrl for pasting into Slack or Jira. Optional flags add linkedAutotests (includeLinkedAutotests, default true), recentAutotestExecutions from CI runs (includeRecentExecutions) and an edit-history audit trail (includeHistory). Read-only; nothing is modified. caseId is the internal numeric id from list_test_cases / create_test_case, not a user-facing TC-N; the project is derived from the case. Choose list_test_cases instead to browse, filter or count many cases, or to turn a TC-N into an id - it returns summaries without steps, so use it to pick the case and this tool to read it. Choose get_case_execution_history instead for how the case has fared in Manual Test Executions over time (pass rate plus an execution timeline); includeRecentExecutions here reports automated CI results only. search_tests covers automated tests, which are separate records from manual cases. IMPORTANT if you plan to write back: description and steps are RICH TEXT and do not round-trip as they arrive. Both come back as arrays of formatting nodes rather than strings, and a step reads as title and expected while create_test_case and update_test_case take action and expected. So sending a step straight back sets the wrong field to the wrong type. Send plain strings or Markdown on write and the server converts them; to edit one step, rebuild the whole steps array from your own text, since steps is replace-all.

Inputs: caseId (required), includeHistory, includeLinkedAutotests, includeRecentExecutions.

get_test_collectionA
Read-onlyIdempotent

Get one Test Collection by UUID. Returns metadata (name, status, priority, environment, assignedTo, project, folder, release, dates), stats (totalTests, passed, failed, blocked, notExecuted, skipped, inTesting), and unless includeTestDetails is false a tests array of caseId, caseNumber, caseTitle, casePriority, status, executedBy, executedAt, notes. Each of those rows also carries an executionId, which is the id of the row itself inside this Collection and NOT a Manual Test Execution id: passing it to get_execution finds nothing. Read-only, changes nothing. collectionId comes from list_test_collections, which is the tool for finding or comparing collections across a project rather than inspecting one. For a Manual Test Execution (the Executions-page container) use get_execution and get_execution_cases instead - a different entity, and only the rows returned by get_execution_cases can be reported against with report_case_result.

Inputs: collectionId (required), includeTestDetails.

get_test_historyA
Read-onlyIdempotent

Get the history of one AUTOMATED test across launches, newest first. Returns executions and summary - the attempt rows are in executions, matching get_case_execution_history, and there is NO history key. The headline figures are NESTED under summary rather than at the top level: totalExecutions, passRate, flipCount and reliabilityStatus. titlePath takes ONE segment of the path - the argument is titlePath, not title - and matching is a case-insensitive substring, so it can hit many tests. The response says how many: matchedTests is the number of DISTINCT tests the substring found, matchedTitlePath is the one these figures describe (the most recently seen), and otherMatches lists up to ten of the rest. A common leaf title such as should reject unauthenticated request matches 25 tests in one project here. When matchedTests is above 1, narrow the substring before quoting anything: the summary describes matchedTitlePath alone, never the group. IMPORTANT: there is one row per retry ATTEMPT, not per launch, so a test retried three times inside one launch contributes three rows; the retry field is 0-based and tells them apart. Group by runId before quoting anything as a per-launch figure, because totalExecutions and passRate are attempt-level. Each row carries testId, titlePath, filePath, runId, runName, runStartedAt, runTags, status and durationMs. reliabilityStatus is derived from the pass ratio over the window and does NOT separate a test that fails every retry from one that passes on a later retry; read retry and flipCount together to tell broken from flaky. limit bounds the summary as well as the list, and days defaults to 30. search_tests will find a segment for you. Use get_case_execution_history for how a MANUAL case has fared, and get_launch_tests for every test inside one launch rather than one test across many.

Inputs: projectId (required), titlePath (required), days, limit.

list_executionsA
Read-onlyIdempotent

List Manual Test Executions for a project. Each row returns id, name, status, priority, environment, assignedTo, startDate, endDate, createdAt and progress. There is NO updatedAt on an execution, here or in get_execution, and startDate and endDate are planning dates a person types and are usually null - so createdAt cannot tell you when an execution was last worked on. For that, read get_execution_cases and take the newest executedAt across its rows. assignedTo is a bare user UUID that nothing on this surface resolves to a person. Use this to find an existing execution id before adding sources. progress carries every case bucket (passed/failed/blocked/inTesting/notExecuted, which sum to total) plus passRate and completionRate, both whole percentages from 0 to 100. passRate here is passed divided by TOTAL, so every case that has not been run yet counts against it and a young execution reads low through no fault of its results. That is a different denominator from get_case_execution_history, whose passRate divides by the rows actually executed, so do not compare the two numbers.

Inputs: projectId (required), limit, offset, search, +1 more.

list_foldersA
Read-onlyIdempotent

List the folder and suite tree of a project as a flat array under folders, with a total count. Every row carries id, name, type (folder or suite), parentId, path, depth, casesCount, childFolderCount, displayOrder, createdAt and updatedAt, which is enough to find the suites without a second call. It is NOT enough to rank folders by size: casesCount counts only the cases directly in a folder, so it reads 0 on most containers and ranking by it surfaces the biggest leaf rather than the biggest branch. For a size ranking, rebuild the tree from parentId and sum the descendants, or call get_folder with includeStats for one subtree at a time. casesCount and childFolderCount count LIVE rows only, so archived cases and archived subfolders are invisible here unless you pass includeDeleted. Use this to browse or to find an id, then get_folder for one folder in detail. Suites are the leaf nodes that hold test cases; use list_test_cases for the cases themselves.

Inputs: projectId (required), includeDeleted.

list_projectsA
Read-onlyIdempotent

List the projects this key can reach. START HERE: almost every other tool needs a project UUID and this is where you get one. Admins see every project in the organisation, managers and users only the ones they are assigned to, so an empty list means no access rather than no projects. Ordered by the display order set in the UI first, then oldest created first, so do not read anything into the first entry beyond that. Returns each project with its id, name and metadata. Use get_project for one project in detail, including the status and priority vocabularies it actually uses, which you need before setting any status.

Inputs: no named parameters.

list_releasesA
Read-onlyIdempotent

List releases for a project with aggregated stats for manual tests and automated launches. Returns project, a releases array, and pagination holding the real total; there is no top-level count or data field. Supports filtering by status and search. Reach for get_release when you have one id and want its linked executions and launches.

Inputs: projectId (required), limit, offset, search, +2 more.

list_test_casesA
Read-onlyIdempotent

List test cases in a project with filtering and pagination. Can filter by folder, status, priority, tags, or a search query. The cases come back in an array called cases, the available status and priority values under meta, and the row count under pagination.total; there is no top-level total. Every row also carries createdAt and updatedAt, and updatedAt tracks edits to the case DEFINITION only: recording a manual result, or an automated test running against the case, does not move it, so updatedAt equal to createdAt means never edited rather than never used. There is no lastExecutedAt on a row - for when a case was last actually run, use get_case_execution_history for manual results or get_test_case with includeRecentExecutions for automated ones. Every case row also carries hasLinkedAutotests and linkedAutotestCount, which is the cheapest way to answer whether a case is automated - they count links made with link_autotest_to_case, the same narrow definition the automationStatus filter uses and the same one behind get_coverage_gaps summary and automationRate. Only the unlinkedAutotests section of that tool additionally treats a [TC-N] title marker as coverage. meta.availablePriorities can contain the entry custom, which is a marker rather than a priority a case can hold. Each case includes a shareUrl for sharing in Slack, Jira and the like. To resolve a user-facing TC-30 (a displayId) to its internal numeric id, pass search: "TC-30", since search matches the case number and accepts the TC- prefix, then read the matching case id.

Inputs: projectId (required), tags, limit, offset, +6 more.

list_test_collectionsA
Read-onlyIdempotent

List Test Collections in a project - the groupings used for sprint, release or ad-hoc manual testing. Each entry returns id, name, status, priority, environment, assignedTo, folderId/folderName, releaseId/releaseName, start and end dates, and stats (totalTests, passed, failed, blocked, notExecuted, skipped, inTesting), plus a pagination block. Use it to find a collection UUID, filtered by folder, release or status; then call get_test_collection for one collection with its individual test cases and their execution status. A Test Collection is one grouping of cases, not the top-level Executions-page container, so use list_executions to find those. For the case library itself rather than runs of it, use list_test_cases. Shadow collections created inside an execution are never listed, and archived ones only with includeDeleted.

Inputs: projectId (required), limit, offset, status, +4 more.

move_test_caseA
Idempotent

Move a test case to a different folder within the same project. Cross-project moves are not supported.

Inputs: caseId (required), targetFolderId (required).

remove_cases_from_collectionA
DestructiveIdempotent

Remove test cases from a test collection. Returns collectionId, collectionName and removed (count of case rows actually deleted); ids not present in the collection are ignored rather than raising an error. Destructive and not reversible: the recorded status and step results for those cases in this collection are deleted with them, while the test cases themselves stay in the project library. add_cases_to_collection is the inverse. To retire the whole collection instead use delete_test_collection, which archives it and preserves executions; to drop a source group from an Executions-page container use remove_source_from_execution; to archive the case itself project-wide use delete_test_case. collectionId comes from list_test_collections; caseIds are the numeric internal ids from list_test_cases, not TC-numbers.

Inputs: caseIds (required), collectionId (required).

remove_source_from_executionA
DestructiveIdempotent

Remove a source group (a suite, collection, or named case-group - one execution_test_run) from an execution. This deletes that group and ALL its case-run rows and step results (cascade). Get the runId (group id) from get_execution (sources[].id) or get_execution_cases (groupId). Does not delete the execution itself. Returns { removed: true }.

Inputs: runId (required), executionId (required).

report_case_resultA
Idempotent

Record the result of running one case inside a Manual Test Execution: set per-step pass/fail and/or the case status, atomically and idempotently. Target the case by executionCaseId (from get_execution_cases) OR by executionId + caseId (numeric; if the case is in several groups, pass groupId or use executionCaseId). A Test Collection is NOT an Execution, and the trap has a name: the per-case rows get_test_collection returns carry a field called executionId, which is the id of the row inside that Collection and is rejected here with Execution case not found. To record results against a Collection, add it to an Execution with add_collections_to_execution and use the rows get_execution_cases gives you. status: an explicit value (passed/failed/blocked/in_testing/not_executed), or "auto" to derive it from the steps (failed then blocked then in_testing then passed), or omit it to leave the case status unchanged (e.g. when only writing one step). steps[].status is one of not_executed/passed/failed/blocked/skipped; index is the 0-based position in the case steps. The containing source group's status auto-rolls from its cases' results, where EXECUTED means anything other than not_executed - so a case parked in_testing counts as executed, and the same is true of the completionRate get_execution reports. A group whose every case is in_testing therefore reads completed, and the execution reads 100 percent complete, while the work is still going on. The rule: all not_executed -> not_started, some executed -> in_progress, all executed -> blocked if the group contains a blocked case, else completed (test_run_status has no failed; failures show via the group's counters). An explicit set_execution_source_status override lasts until the next report on that group recomputes it. The status of the EXECUTION itself does not roll at all: it stays wherever it was until you move it with update_execution, so an execution whose cases have all been run can still read not_executed. Returns the case status, the group status, the steps written, and fresh execution progress.

Inputs: notes, steps, caseId, status, +5 more.

run_health_checkA
Read-onlyIdempotent

Get a holistic health assessment for a project: a composite score from 0 to 100 blending automation stability, coverage and manual execution. IMPORTANT: healthScore is NOT comparable BETWEEN projects. The composite weights automation 50 percent, coverage 30 and manual execution 20, then RENORMALISES over whichever of the three actually have data - so a project with no manual executions is scored out of the other two rather than penalised for the gap, and a project holding one test case can score 100 on coverage. A project can therefore outrank another while scoring worse on every dimension the two share. Compare subScores one dimension at a time and say which dimensions each project has. The status label, healthy or warning or critical, is banded straight off that same number and is exactly as incomparable, so do not rank by the word either. Quote healthScore only for one project against itself, and only across calls made with the SAME days and the same include[] - a narrower include[] drops dimensions out of the divisor and moves the score on its own - a wider window can catch work that adds a whole dimension to the renormalisation and move the score with no change in health. One project here scores 20 at 30 days and 21 at 90 purely because two manual executions came into view. The default is 14, so three calls with three windows give three rankings. It returns per-dimension subScores and sections for automation, whose three failure counts mean three different things: failedTests is tests that ENDED failed, consistentlyFailingCount is tests that failed at least three times and NEVER passed in the window, and flakyTestCount is distinct tests that both passed and failed. A test that recovers on retry belongs to the last of those and to none of the others. Its testPassRate counts flaky as a pass, so it is (passedTests + flakyResults) / totalTests, the same formula get_launches_statistics uses, and like that tool it answers null rather than 0 when the window held nothing. This section counts ONLY launches that ended passed or failed, while get_launches_statistics counts every launch in the window, so a launch stored as finished, running, interrupted, timedOut or completed contributes its tests there and not here. The difference between the two totalTests is exactly the tests inside those launches, and it reconciles to the launch: subtract them and the counts match. The rates still agree to about a decimal place because the excluded launches are usually small; the section reports BOTH flaky numbers because they are different units, flakyResults being flaky results and flakyTestCount being DISTINCT tests that both passed and failed over the window, which is what drives the flakiness penalty), testAssets (case and suite counts, status and priority breakdown - both count only cases that HAVE a value, with no residual bucket for the unset ones, so neither is guaranteed to sum to totalCases: in one project here byStatus accounts for 65 of 87 and byPriority for 70), coverage (automation rate and pass-rate trend), manualExecution (pass, fail, blocked, completion) and releases (status counts and active releases). IMPORTANT: days defaults to 14 here while get_launches_trends defaults to 30, so pass the same days to both before comparing their answers. Use include[] to limit which sections are computed. Reach for get_coverage_gaps when you want the specific cases and folders that lack automation rather than one score, and get_feature_scan when the scope is a single Jira issue.

Inputs: projectId (required), days, include.

search_testsA
Read-onlyIdempotent

Search AUTOMATED tests by title, file path or tag, and get how each has been doing. Each row carries titlePath (an array; get_test_history wants ONE segment of it), filePath, lastStatus, reliability, totalExecutions, passedCount, failedCount, passRate, avgDurationMs and lastSeen. IMPORTANT: days defaults to 7 here, the shortest window of any tool - a test that has not run in the last week is simply absent, which reads as does not exist rather than has not run lately. Pass days explicitly whenever the question is not about this week. The counts are of ATTEMPTS, so a retried test contributes more than one, and passRate is passedCount divided by totalExecutions on that basis; reliability is derived from the same rows, reading flaky when both a pass and a failure appear in the window. It returns NO linkage information at all, so it cannot answer whether a test is tied to a manual case: use get_test_case with includeRecentExecutions for that. Use get_test_history for one test in full detail over a longer window - it takes the segment as titlePath, where this tool takes query - and get_launch_tests for every test in one launch.

Inputs: query (required), projectId (required), days, limit, +1 more.

set_execution_source_statusA
Idempotent

Set the status of one source group (a collection, suite, or named case-group - the per-group status dropdown on the execution page) inside an execution. Get the runId (group id) from get_execution (sources[].id) or get_execution_cases (groupId). status is validated against the project's test_run_status values (default: not_started, in_progress, completed, blocked) - call get_project to confirm. This is the GROUP status; use report_case_result for an individual case's status.

Inputs: runId (required), status (required), executionId (required).

suggest_test_casesA
Read-only

Return template-based test case scaffolding for a feature description: structured ideas with titles, steps and priorities. This is pattern matching, not model output. Use it as a project-aware starting point, refine it yourself, then persist the result with create_test_case.

Inputs: projectId (required), featureDescription (required), testType, maxSuggestions.

update_executionA
Idempotent

Update a Manual Test Execution's own fields, including its overall status. Set status to in_testing while running, and passed/failed/blocked when done. status is validated against the project's execution_status values (default: not_executed, in_testing, passed, failed, blocked) - call get_project to read the exact values a project uses; do not hardcode. Does not change case results - use report_case_result for those, or set_execution_source_status for a source group's status.

Inputs: executionId (required), name, status, endDate, +6 more.

update_folderA
Idempotent

Rename a folder or suite and/or re-parent it. Set parentId to null to move it to root level, or omit it to keep the current parent. Returns the updated id, name, type, parentId, path, depth, casesCount and childFolderCount. A move carries everything nested inside along with it, so child paths change too; the new parent must be a folder in the same project, since suites cannot be parents and a folder cannot move into itself or into one of its own descendants. It never changes type and never creates or removes anything: use create_folder for a new folder or suite, delete_folder to archive one with all its contents, and move_test_case to relocate a single test case rather than its whole suite. Get folderId from list_folders.

Inputs: folderId (required), name, parentId.

update_releaseA
Idempotent

Update release metadata. Only provided fields are updated; omitted fields remain unchanged. Use get_release first to see current values.

Inputs: releaseId (required), name, status, endDate, +3 more.

update_test_caseA
Idempotent

Update an existing test case. Only provided fields are updated; omitted fields remain unchanged. Returns the full updated case object including shareUrl. TIP: Use get_test_case first to see current values.

Inputs: caseId (required), tags, steps, title, +5 more.

update_test_collectionA
Idempotent

Update test collection metadata. Only provided fields are updated; omitted fields remain unchanged. Use get_test_collection first to see current values.

Inputs: collectionId (required), name, status, priority, +3 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 55 tools

    Disambiguation4/5

    Tools are grouped around distinct resources—cases, folders, collections, executions, launches, releases, external links, and analytics—and the descriptions explicitly call out near-misses like test collections vs executions and launch statistics vs launch trends. A few pairs such as add_cases_to_collection vs add_cases_to_execution still need careful reading, but every tool has a distinct purpose.

    Naming Consistency5/5

    Naming is consistently verb-first snake_case with standard CRUD verbs: get/list/create/update/delete/add/remove/link/link. Even compound tools like bulk_update_cases, run_health_check, and report_case_result follow the same readable pattern with no style mixing.

    Tool Count2/5

    55 tools is far beyond the 3–15 well-scoped range and clearly falls into the too-many category, even though the underlying domain is broad. The count will overwhelm agents during tool selection and makes the server hard to use effectively.

    Completeness4/5

    Major lifecycle coverage is strong: cases, folders, suites, collections, executions, releases, launches, external links, and reports all have meaningful create/read/update/delete or equivalent workflows. Minor reverse-operation gaps exist—such as no unlink for autotest-to-case and no way to remove a single loose case from an execution group—but agents can generally work around them.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      F
      maintenance
      Enables management of TestRail projects, test cases, runs, and results directly through MCP-supported clients. It provides a comprehensive set of tools to interact with the TestRail API for seamless test cycle management within AI environments.
      42
      6,218 npm
      42
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      This is an unofficial, community-built MCP server for qTest Manager. Not affiliated with or endorsed by Tricentis. Browse projects, modules, and test cases Create/delete test design modules Create and manage test execution cycles Add test cases into execution suites
      9
      84 npm
      1
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      An MCP server for TestRail that prepares everything needed to generate test cases from Jira tickets, Confluence pages, or free-form specs and pushes them back to TestRail.
      31
      25 PyPI
      2
      MIT