M00N Report MCP
Official@m00nsolutions/mcp-server
MCP를 통한 에이전트형 테스트 관리입니다. 이 서버는 AI 어시스턴트가 관련 내용을 읽기만 하는 대신 실제 작업을 수행하게 합니다. 테스트 케이스를 작성하고, 수동 테스트 실행을 계획하고 채우고, 자동화를 해당 케이스에 연결하고, 릴리스를 만들고, M00N Report에서 프로젝트 상태를 확인할 수 있습니다. M00N Report는 AI 네이티브 테스트 관리 플랫폼입니다.
어떤 설치가 필요한가요?
이 npm 패키지(stdio) | 호스팅형 원격 커넥터 | |
실행 방식 | 로컬 프로세스로 | 로컬 프로세스 없음; 클라이언트가 HTTP로 API와 통신 |
인증 |
| 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는 게시된 버전을 나열합니다. 버전 자리에 숫자가 아닌 자리표시자(placeholder)를 쓴 이유가 있습니다. 구체적인 숫자는 다음 릴리스가 나오면 낡아지고, 낡은 숫자는 현재 수정 사항이 없는 버전에 고정하도록 안내하기 때문입니다.
빠른 시작
1. MCP 키 받기
M00N Report에서 Settings -> MCP Keys를 열고 키를 생성하세요. 키는 m00n_mcp_로 시작되며 그 뒤에 48자의(after) 16진수가 이어집니다. 이는 테스트 reporter들이 쓰는 자격 증명과 다릅니다. 테스트 reporter용 키는 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 |
|
Claude Desktop, macOS |
|
Claude Desktop, Windows |
|
자체 호스팅 인스턴스를 사용하는 경우 M00N_API_URL을 자신의 루트 오리진으로 지정하세요. /api 접미사는 붙이지 마세요. 끝에 있는 슬래시는 자동으로 제거됩니다.
3. 연결 확인
클라이언트를 다시 시작하고 질문하세요:
내 M00N Report 프로젝트 목록을 보여줘
프로젝트 목록이 보이면 서버가 연결되었고 키가 유효하다는 뜻입니다. 오류가 나거나 어시스턴트가 그런 도구가 없다고 하면 연결되지 않은 것이니 문제 해결을 참고하세요.
도구
8개 영역입니다. 인자까지 포함한 전체 목록은 /documentation/mcp/tools에 있으며 코드 옆에서 함께 관리됩니다. 서버는 시작 시 자체 인스턴스에서 도구 목록을 가져오므로, 클라이언트가 보는 목록은 클라이언트가 접속한 시점에 인스턴스가 지원한 것들입니다.
영역 | 포함 내용 |
프로젝트 및 분석 | 프로젝트, 실행 동향과 통계, 테스트별 이력, 자동화된 테스트 검색 |
테스트 케이스 | 생성, 읽기, 수정, 이동, 삭제, 일괄 편집, 그리고 자동화된 테스트를 해당 테스트 케이스에 연결 |
폴더 및 스위트 | 폴더와 스위트의 계층 구조, 폴더별 통계 |
테스트 컬렉션 | 어떤 실행에도 넣을 수 있는 재사용 가능한 이름 있는 케이스 세트 |
수동 실행 | 스위트, 컬렉션 또는 개별 케이스에서 실행을 구성하고 케이스별 결과를 기록 |
릴리스 | 릴리스 생성 및 관리, 그리고 릴리스에 속한 실행을 첨부하거나 분리 |
상태 및 커버리지 | 종합 상태 점검, 양방향 커버리지 누락, 케이스 추천, 기능 스캔, 보고서 내보내기 |
외부 링크 | 케이스에 Jira 또는 Linear 티켓을 첨부하고 제거 |
실행(execution)은 수동 테스트 실행됩니다. 담당자, 환경, 날짜, 각 케이스가 추가된 시점의 스냅샷을 기준으로 기록한 단계별 결과를 포함합니다.
키가 볼 수 있는 도구 수는 인스턴스에서 결정됩니다:
curl -s -H "X-MCP-Key: $M00N_API_KEY" "$M00N_API_URL/api/mcp/tools" | jq .count범위가 제한된 키는 그보다 적게 봅니다. 여기에 일부러 숫자를 적지 않았습니다. 도구 목록은 릴리스에 따라 바뀌고, README에 숫자를 적어 두면 아무도 갱신하지 않기 때문입니다.
프롬프트
클라이언트가 이름으로 제공하는 안내된 다단계 워크플로우입니다. 각 프롬프트는 선택적인 project 인자를 하나 가질 수 있으며, 이 인자는 이름 또는 UUID입니다. 인자를 생략하면 서버는 범위에 프로젝트가 하나뿐일 때 해당 프로젝트를 선택합니다.
프롬프트 | 동작 |
| 코드 변경 없이 통과하는 테스트와 실패하는 테스트를 구분하지 않고 찾아 순위를 매김 |
| 하나의 실패를 이력과 트레이스로 어추하여 원인을 찾음 |
| 릴리스가 출시되어도 안전한지 판단 |
| 테스트 케이스가 없는 어떤 영역을 위한 수동 케이스 초안 작성 |
| 프로젝트 전반에 걸쳐 그 주 요약 |
| 통과한 실행과 실패한 실행 사이에 무엇이 바뀌었는지 확인 |
| 수동 테스트 사이클을 구성부터 케이스별 결과까지 진행 |
리소스
클라이언트가 도구 호출 없이 가져올 수 있는 읽기 전용 뷰: 모든 프로젝트, 전체 프로젝트 상태 요약, 플레이키 테스트 보고서, 현재 실패 중인 테스트, 폴더 구조, 실행 보고서, 테스트 케이스 내용, 릴리스 요약.
구성
환경 변수 | 필수 여부 | 기본값 | 설명 |
| 연결 시 필요 | M00N Report URL. 계정의 루트 오리진, | |
| 연결 시 필요 | MCP 키 ( | |
| 아니요 |
| 각 요청 세부 정보를 stderr에 추가합니다. 각 도구 호출 인자 포함. 시작 기본 오류은 어떤 경우에도 로그에 기록됨. |
| 아니요 |
| 요청 시간 제한, 밀리초 단위 숫자. |
| 아니요 |
| 자체 서명 인증서를 허용합니다. 자체 호스팅 인스턴스만. |
두 불리언 변수는 true, 1 또는 yes이면, 대소문자 구분 없이 켜집니다. 이들을 제외한 모든 값(false와 0 포함)은 꺼진 상태로 둡니다.
첫 두 변수는 둘 다 설정하거나 둘 다 설정하지 않아야 합니다. 하나만 설정하면 실수로 간주하고 거부합니다. 어쨌든 시작되고 마는 절반만 설정된 서버는 시작되지 못한 서버보다 진단하기 어렵기 때문입니다.
기본 URL은 여기서 M00N_API_URL입니다. 테스트 리포터들은 동일한 URL을 M00N_SERVER_URL라고도 합니다. 여섯 개 패키지가 모두 M00N_API_KEY를 읽지만, 리포터들의 키는 MCP 키가 아니라 프로젝트 API 키이므로, 내보낸 하나의 셸 변수로는 이 둘을 동시에 사용할 수 없습니다.
키 없이 실행하기
M00N_API_URL과 M00N_API_KEY를 모두 설정하지 않고 시작하면 서버는 미리 보기 모드로 실행됩니다. 이 모드에서는 번들된 스냅샷으로 도구, 프롬프트, 리소스를 나열하고, 어떤 것을 설정해야 하는지 알려주는 메시지와 함께 모든 호출을 거부합니다. 보낼 곳이 없으므로 아무 곳으로도 아무 것도 전송되지 않습니다.
이 덕분에 누구도 가입하기 전에 컴퓨터 사양 검사기, 클라이언트 또는 디렉터리가 도구 목록을 보여줄 수 있습니다. 이 목록은 서버에 대한 설명이지 실제 작동하는 서버가 모니터 아니므로, 목록은 인스턴스가 아니라 스냅샷에서 나옵니다. 범위가 제한된 키는 일반적으로 스냅샷에 표시되는 도구보다 더 적은 도구를 봅니다.
관리자는 범위가 제한되지 않은 키로 npm run snapshot:refresh를 실행해 스냅샷을 최신 상태로 유지합니다.
자체 호스팅
M00N_API_URL을 자체 인스턴스로 지정하고 해당 인스턴스에서 MCP 키를 발급하세요. 나머지 모든 것은 동일합니다. 테스트 데이터를 네트워크 경계 밖으로 내보낼 수 없는 것이 자체 호스팅의 이유라면 이 동일성이 매우 중요합니다.
자체 서명 인증서를 사용한다면 같은 env 블록에 "M00N_INSECURE_SSL": "true"를 추가하세요. 자세한 내용: /documentation/mcp/self-hosted.
무엇이 전송되는가
HTTPS를 통해 M00N_API_URL로 전송되는 것은 어시스턴트가 수행하는 도구 호출과 그 인자입니다. 서버는 여러분 인스턴스에 대한 프록시일 뿐이며 자체적으로 아무것도 저장하지 않습니다.
모든 도구 호출은 앱에 UI가 있는 MCP 감사 로그에 기록됩니다. 또한 키별 속도 제한이 폭주하는 에이전트를 제한합니다. 키는 그 로그에나 stderr에 결코 기록되지 않습니다. M00N_DEBUG를 켜면 모든 도구 호출의 인자가 stderr로 출력되므로, 그 출력은 데이터 자체와 마찬가지로 주의해서 다루야 합니다.
문제 해결
증상 | 원인 |
클라이언트에 M00N Report 도구가 표시되지 않음 | 구성이 다시 로드되지 않았습니다. 대화에만 다시 시작하지 말고 클라이언트를 완전히 다시 시작하세요. |
도구는 나열되지만 모든 호출이 |
|
| 이것은 테스트 리포터가 사용하는 프로젝트 API 키입니다. MCP 키는 별도입니다: Settings -> MCP Keys. |
| 키가 잘못되었거나, 폐지되었거나, 다른 인스턴스의 키입니다. 또는 |
| 오류가 아니며 서버는 계속 실행됩니다. 키가 모든 요청에 암호화 없이 전송된다는 의미입니다. 인스턴스가 신뢰할 수 있는 사설 네트워크에 있지 않은 한 |
| URL이 리디렉션으로 응답하며, MCP 키가 리디렉션 대상으로 전달될 수 있으므로 리디렉션을 따르지 않습니다. |
| 해당 URL에서 수신 대기 중인 것이 없습니다. 인스턴스가 중단되었거나 포트가 접근 불가 상태입니다. |
| 호스트 이름이 확인되지 않습니다. 오타이거나 네트워크 외부에서 사설 이름에 접근한 경우입니다. |
|
|
| 자체 호스팅 인스턴스에서 자체 서명 인증서를 사용하는 경우입니다. |
| 줄의 나머지는 서버 자체의 응답이며, 일반적으로 어떤 프로젝트가 존재하는지 등 해결 방법을 알려줍니다. 설정을 변경하기 전에 그 내용을 읽어보세요. |
| 키당 분당 1000회의 도구 호출이 슬리딩 윈도우에서 적용됩니다. 메시지에 대시 시간시 포함됩니다. 작업을 하하 에이전트는 이 한도에 거의 도달하지 않으며, 이 오류가 발생하면 대개 루프를 의미합니다. |
도구 수가 예상보다 드묾 | 키의 권한 범위가 제난되어 있거나 인스턴스가 패키지보다 오된 것입니다. 도구 생목은 현지 인스턴스에서 제공됩니다. |
서버는 M00N_DEBUG 설정 여부와 관계없이 stderr로 로그를 기록하며, 대부분의 클라이언트는 이를 MCP 패널에 표시합니다. M00N_DEBUG를 true로 설정하면 각 요청과 그 인자도 함께 출력됩니다.
알려진 제한 사항
도구 목록은 시작 시 한 번만 읽습니다. 키의 범위를 다시 설궈거나 인스턴스를 업그래이 들어도 분라이언트를 다시 시작할 때까지 이전 목록을 유지합니다.
구성된 경우
GET /api/health에 연결할 수 있어야 합니다. 다른 것보다 먼저 확인되며 실패하면 서버가 중지됩니다. 따라서/api/mcp/*만 전달하는 프록시는 모든 도구가 작동하더라도 도구가 전혀 표시되지 않습니다.도구가 0개로 범위가 지정된 키는 시작하지 않습니다. 서버는 빈 목록으로 연결하지 않고 종료됩니다. 이는 구성된 경로입니다; 자격 증명이 전혀 없으면 대신 미니 보기 모드로 시작됩니다.
프롬프트와 리소스는 선택 사항입니다. 해당 목록을 가져오는 데 실패해도 서버는 시작되며, 사유가 stderr에 기록되고 클라이언트는 전체 세션 동안 해당 항목을 볼 수 없습니다.
리디렉션은 따르지 않고 거부됩니다. 키는 사용자 지정 헤더에 포함되어 있고 리다이렉션 수행 도구는 인식하는 인증 헤더만 제거하므로, 리디렉션을 따르면 키가 다음 응답 호스트에 넘어갈 수 있습니다. 리다이렉션은 가리키는 주소와 함께 보고됩니다.
stdio만 지원합니다. HTTP 전송을 이용하려면 호스티드 커넥터를 사용하세요.
지원
라이선스
MIT 라이선스. LICENSE 참고.
Wait, I notice many errors due to hand typing? Actually I spelled some things wrong. Need to correct correctly. Also "0" vs "0" confusion. Let's recompose with carefully corrected Korean. Needs to be fluent and accurate.
Let's go step by step again, ensure no typo's.
First table.
Header: "| Symptom" - actually correct "증상" and "원인".
But wait, the original output I generated had some mangled text because I was typing too fast. I need to produce a clean final answer.
Let's start fresh.
Important: The final answer must be correct Korean with no typos. I'll construct carefully.
Table:
| 증상 | 원인 | | ... | ... |
Row 1: "클라이언트에 M00N Report 도구가 표시되지 않음" - Should be "클라이언트에 M00N Report 도구가 표시되지 않음."
Better: "M00N Report 도구가 클라이언트에 나오지 않음" or "클라이언트에 M00N Report 도구가 표시되지 않음."
Row 2: "도구는 나열되지만 모든 호출이 running unconf" etc. Let's spell: "도구는 나열되지만 모든 호출이 running unconfigured로 응답함"
Cause: "M00N_API_URL도 M00N_API_KEY도 프로세에 도달하지 못해 미리 보기 모드로 시자되었습니다. env 블록이 실래 이 서버에 적요되는지 확인하세요."
Now all rows.
Let's decide the exact Korean strings.
Row 1:
Symptom: "클라이언트에 M00N Report 도구가 표시되지 않음"
Cause: "구성이 다시 로드되지 않았습니다. 대화를 다시 시작하는 것만으로는 부족하고, 클라이언트를 완전히 다시 시작하세요."
Better: "구성이 다시 로드되지 않았기 때문입니다. 대화만 다시 시작하지 말고 클라이언트를 완전히 다시 시작하세요."
Let's use "클라이언트를 완전히 다시 시작하세요."
Row 2:
Symptom: "도구는 나열되지만 모든 호출이 running unconfigured로 응답함"
Cause: "M00N_API_URL도 M00N_API_KEY도 프로세스에 도달하지 못했기 때문에 미리 보기 모드로 시작된 것입니다. env 블록이 실래 이 서버에 적용되는지 확인하세요."
Row 3:
Symptom: same code.
Cause: "그것은 프로젝트 API 키입니다. 테스트 리포터가 사용하는 종류의 키이지요. MCP 키는 별도입니다: Settings -> MCP Keys."
We can write: "이는 프로젝트 API 키입니다. 테스트 리포터가 사용하는 키입니다. MCP 키는 별도이며: Settings -> MCP Keys에서 만듭 수 있습니다."
But "MCP" should be "MCP" exactly. I've been accidentally typing MCP. Need to be careful: "MCP" or "MCP"? It's "MCP" (Model Context Protocol). So "MCP" exactly. In my final I kept "MCP". In the above I wrote "MCP" and "MCP키". Good.
Row 4:
Symptom: code
Cause: "키가 잘못거나, 폐기되었거나, 다른 인스턴스의 것 입니다. 또는 M00N_API_URL에 /api 접미사가 있어 키가 아무래 올바더라도 모든 요청이 401을 하답나다. URL을 먼저 확인하고 새 키를 발 damaged하세요."
Let's rephrase: "키가 잘몼매, 폐지되었매, 다른 인스턴스에서 발행된 매입니다. 또는 M00N_API_URL끁 /api 접미사가 포함되어 키가 올바 reassurance도 모든 요청이 401을 반환합니다. URL을 하저 체크한 후 새 키를 발행하세요."
Better: "키가 잘못되었거나, 폐지되었거나, 다른 인스턴스의 것입니다. 또는 M00N_API_URL에 /api 접미사가 있어 키가 아무서 올바매도 매 청이 401을 반환합니다. URL을 먼저 확핀한 다 그 새 키를 발급하셔요."
Let's use "키가 잘못셨거나, 폐지되엤거나, 다른 인스턴스의 것입니다." Good.
Row 5:
Symptom: "WARNING: M00N_API_URL is https://..." keep.
Cause: "오류가 아니며 서버는 계속 실행됩니다. 모든 요청에서 키가 암호회과 없이 전송된다는 뜻입니다. 인스턴스가 신뢰할 수 있는 사설 네트워크에 있는 것이 아닐 한 파일이 아니라, https를 사용하세요. 루프백 주소는 경고하지 않습니다."
Correct: "오류가 아니며 서버는 계속 실행됩니다. 키가 모든 요청에서 암호화 없이 전송된다는 것을 알고 Let's fix: "오류가 아니며 서버는 계속 실행됩니다. 이는 키가 모든 요청에 암호화되지 않고 전송된다는 뜻입니다. 인스턴스가 신뢰할 수 있는 사설 네트워크에 있지 않은 한 https를 사용하세요. 프백 주소는 경고하지 않습니다."
Row 6:
Symptom: "... redirected to ..."
Cause: "URL이 리데릭션으로 응답하며, 리데릭션을 따르면 MCP키가 그 대상으로 전달될 수 있으므로 리데릭션을 따르지 않습니다. M00N_API_URL을 직접 답하는 주소(보통 https:// 형태)로 설하세요."
"직접 답하는 주소" better: "직접 응하는 주소(보통 https:// 형)"
Row 7:
"해당 URL에 무언 것도 수진 대기하지 않습니다. 인스턴스가 다운되었거나 포트가 차단되었습니다."
Let's nice: "해당 URL에 수신 대기 중인 매 것이 없습니다. 인스턴스가 종료되었거나 포트가 접근 불가합니다."
Actually "Nothing is listening" -> "아무것도 리스닝하고 있지 않습니다" is natural. Use "해당 URL에 리스닝하的是 무것도 없습니다." Good.
Row 8:
"호스트 네임이 해석되지 않습니다. 오타이거나 외부 네트워크에서 사설 네임에 접근한 것입니다."
"해당 호스트네임은 미확인입니다" Better: "호스트 네임이 리설브되지 않습니다" (read as English "resolve" is domain name resolution). In Korean IT usage, "호스트가 결되지 않습니다" often "확인할 수 없습니다". But "resolve" is "해석" or "확인". Actually "호스트 네임을 해소할 수 없습니다." Might be "호스트 네임을 결할 수 없습니다" (DNS resolfor). Common: "호스트을 해석할 수 없습니다" is formal. Let's use "호스트 네임이 확인되지 않습니다." The message "Cannot resolve M00N Report API host" is in English, we keep. For the cause: "호스트 이름을 확인할 수 없습니다. 오타이거나 네트워크 밖에서 사설름에 인급한 경우입니다."
Row 9:
"M00I_TIMEOUT_MS를 높이거나 네트워크 경로를 확인하세요."
Row 10:
"자체 호스팅 인스턴스의 자체 서명 인즈서입니다. M00N_INSECURE_SSL을 true로 설정하세요."
Row 11:
"행의 나머지는 서버 자신의 응답이며, 대%개 어떤 프로젝트가 존재하는 것와 같셄 해결 변법을 명확합니다. 설정을 변기 전에 그 내원을 읽셔오."
Let's phrase: "줄의 나머지는 서버 자체의 응답입니다. 대개 어든 프로젝트가 존재하는지 등 해결 방법을 알 만하고, 설정을 변기 전에 그 내원을 읽어보세요."
Row 12:
"키당 분에 1000번의 도구 호출이 슬리딩 윈도우 방식으로 제한됩니다. 메시지에 대기 시간이 포니다. 작업을 리하는 에이전트는 거의 제한에 도달하지 않으며, 이 오류가 발하면 보통 프가 생겼다는 뜻입니다."
Wait, "1000" in original is "1000" actually: "1000 tool calls per minute per key" - wait, original text: "1000 tool calls per minute per key" Wait it's "1000" or "1000"? Let's check the user's message: "Rate linger exceeded. Retry after Ns." | "1000 tool calls er minute" Actually original: "100 0 tool calls per minute per key" It is one thousand? Actually I think "1000" = "1,000" with comma omitted? It says "1000 tool calls per minute". Let's double check the provided text: Rate limit exceeded. Retry after Ns. | 1000 tool calls per minute per key, on a sliding window. The message carries the wait. An agent working a task rarely comes close; hitting this usually means a loop. In the input, it says "1000"?? Let's scroll up: it says 1000 tool calls per minute per key? Actually in the user content: "| Rate limit exceeded. Retry after Ns. | 1000 tool calls per minute per key, on a sliding window." The number is "1000" with 1 and 0? It could be "1000" no comma. Hmm. In our final we must preserve "1000" as a number? It's not code, it's a number. We should translate "1000 tool calls" to "분 당 1000회의 도구 호출". However, "1000" looks like a weird truncation of "1,000"? But we must not alter the content. It says "1000 tool calls" maybe "1000" actually as in "1000" without comma. As translation, we should keep number as is. In the original the number is "1000"? Let's re-read "1000 tool calls ..." Actually in the provided input, it says "1000" or "1,000"? Check: The user content: "1000 tool calls per minute per key" I see "1000" with three zeros? Let's look at the line:
| Rate limit exceeded. Retry after Ns. | 1000 tool calls per minute per key, on a sliding window. ...
Yes, it's "1000" (one thousand) written as "1000". In my previous text I accidentally wrote "1000" as "1000" okay. I'll use "1000회".
Need to ensure grammar:
"키당 분당 1000회의 도구 호출 한도가 슬라이딩 윈도우 방식으로 적용됩니다." Good.
"A군 working a task rarely comes near" -> "작업을 처리하는 에이전트는 거의 그 한도에 근접하지 않으며, 이 오류에 부딪히면 대개 루프를 뜻합니다."
Row 13:
"도구 수가 예상보다 적음" cause: "키의 권한 범위가 제한되어 있거나 인스턴스가 패키지보다 오래된 것입니다. 도구 목록은 현재 인스턴스에서 가져옵니다."
Better: "도구 목록은 인스턴스에서 오므로, 키가 권한에 따라 범위가 지정되었거나 인스턴스가 패키지보다 오래되었을 수 있습니다." Let's use parity: "키의 권한 범위가 제한되었거나 인스턴스가 패키지보다 오래된 것입니다. 도구 목록은 인스턴스가 제공합니다."
Now the paragraph after table:
"서버는 M00N_DEBUG 여부와 상관없이 stderr에 로그를 남기며, 대부분의 클라이언트는 그 로그를 MCP 패널에 표시합니다. M00N_DEBUG를 true로 설정하면 각 요청과 그 인자를 추가로 출력합니다."
Note: "to add each request and its arguments" = "각 요청및 인자를 추가로 기록" better: "각 요청과 해당 인자를 추가로 로깅합니다." Use "출력합니다."
Now "Known Limitations" title: "알려진 제한 사항".
Bullets:
"도구 목록은 시작 시 한 번만 읽습니다. 키 범위를 다시 지정하거나 인스턴스를 업그레이드해도 클라이언트를 다시 시작하기 전까지는 이전 목록을 유지합니다."
"
GET /apis/health가 구성된 경우 연결 가능해야 합니다." "... 프록시가/api/mcp/*만 전달하면 모든 도구가 동작하더라도 도구가 전혀 표시되지 않습니다.""권한이 없는 키로 시작하지 않습니다." Actually the original "A key scoped to zero tools does not start." -> "도구에 0개로 범위가 한정된 키는 시작하지 않습니다." This is a bit awkward: "도구 0개로 범위가 지정된 키는 시작 실패합니다." Use "도구가 하나도 허용되지 않는 키는 시작하지 않습니다." Good.
"The server exits rather than connecting with an empty list. This is the configured path; with no credentials at all it starts in preview mode first." -> "서버는 빈 목록으로 연결하지 않고 종료합니다. 이것은 구성된 설정입니다. 자격 증명이 전혀 없다면 아예 시작하는 대신 미리 보기 모드로 가장합니다." Wait, "with no credentials at all it starts in preview mode instead." So: "자격 증명이 전혀 없는 경우에는 대신 미리 보기 모드로 시작됩니다." Good.
"Prompts and resources are optional." -> "프롬프트와 리소스는 선택 사항입니다." "If their listings fail, the server is still with the reason on stderr" -> "해당 목록을 가져오지 못해도 서버는 시작하며, 그 이유는 stderr에 기록됩니다. 클라이언트는 세션 동안 그것들을 하나도 보지 못합니다."
"Redirects are refused, not followed." -> "리디렉션은 따르지 않고 거부됩니다." "키는 사용자 지정 헤더 안에 있으며, 리디렉션 추적자는 자신이 알고 있는 인증 헤더만 제거하므로, 리디렉션을 따라가면 키가 다음 응답 호스트로 유출될 수 있습니다. 리디렉션은 가리키던 주소와 함께 보고됩니다."
Need to avoid "리디렉션 추적자" maybe "리디렉션 팔로워". "리디렉션이 가리키는 주소와 함께 보고" etc.
"stdio 전용입니다. HTTP 전송을 원한다면 호스티드 커넥터를 사용하세요."
Support: "## 지원"
"npm 패키지" with URL.
"문서" with URL.
"이슈 신고" with URL.
"커뮤니티 Discord" with URL.
License: "## 라이선스"
"MIT 라이선스. LICENSE를 참고하세요."
Need to ensure URL for "License" is exactly as original: https://github.com/m00nreport/mcp-server/blob/main/LICENSE
One thing: "M00N Report" product name remains "M00N Report" but if it's part of "M00N Report API" keep.
Now, there might be a hidden caveat: In Markdown table, if a cell contains a pipe character, we must escape. But our content has none. Good.
Let's write final answer cleanly with the exact table format.
I'll format with the same separator line. For readability, I'll use a standard markdown table (separator not with spaces? It's fine). I'll preserve original table structure? The instruction: "Preserve exact structure of Markdown tables (same number of rows, columns, and pipe separators)." So we need the same number of rows and columns. We'll keep rows exactly 13 plus header. The separators may be adjusted but the pipes remain. I'll keep the original separator as is (with many hyphens) to be safe.
Let's produce the final content now. Be careful with spelling. Use "클라이언트" etc.
Let's write final output in a single block.
One more nuance: In the original table header, there is "Cause" not "Cause" spelled "Cause" (C-a-u-s-e). We translate.
Also the heading "Known Limitations" should be "## 알려진 제한 사항". Fine.
Let's proofread the Korean:
"해당 URL에서 수신 대기 중인 것이 없습니다." -> good.
"포트가 접근 불가 상태입니다." -> "포트가 막혀 있거나" better.
Let's craft final with careful Korean.
I will now generate| 증상 | 원인 |
| -------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| M00N Report도구가 표시되지 않음 | 구성이 다시 로드되지 않았습니다. 대화를 다시 시작하는 것만으로는 부족하고, 클라이언트를 완전히 다시 시작하세요. |
| 도구는 나열되지만 모든 호출이 running unconfigured로 응답함 | M00N_API_URL도 M00N_API_KEY도 프로세스에 도달하지 못해 미리 보기 모드로 시작된 것입니다. env 블록이 실제로 이 서버에 적용되는지 확인하세요. |
| M00N_API_KEY should start with "m00n_mcp_" | 그것은 테스트 리포터가 사용하는 프로젝트 API 키입니다. MCP 키는 별도입니다: Settings -> 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/*만 전달하는 프록시는 모든 도구가 동작하더라도 도구가 전혀 표시되지 않습니다.도구가 0개로 범위가 지정된 키는 시작하지 않습니다. 서버는 빈 목록으로 연결하는 대신 종료됩니다. 이것은 구성된 설정입니다. 자격 증명이 전혀 없으면 그 대신 미리 보기 모드로 시작합니다.
프롬프트와 리소스는 선택 사항입니다. 목록을 가져오지 못해도 서버는 시작하며, 그 사유가 stderr에 기록되고 클라이언트는 세션 내내 해당 항목을 하나도 보지 못합니다.
리디렉션은 따르지 않고 거부됩니다. 키는 사용자 지정 헤더에 실려 있으며, 리디렉션을 따르는 쪽에서는 인식하는 인증 헤더만 제거하므로, 리디렉션을 따라가면 키가 다음 응답한 호스트로 전달될 수 있습니다. 리디렉션은 그 대상 주소와 함께 보고됩니다.
stdio 전용입니다. HTTP 전송이 필요하면 호스티드 커넥터를 사용하세요.
지원
라이선스
MIT License. LICENSE 참고.
Available Tools
55 toolsadd_cases_to_collectionAIdempotent
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_external_linkAIdempotent
Link any test entity (case/execution/release/launch) to an external ticket in Jira, Linear, GitHub, GitLab, or any other system. Returns the link record: id (the link UUID that remove_external_link takes), provider, externalId, externalUrl, externalTitle, externalStatus, linkType, providerMetadata, createdAt. Idempotent: the same provider plus externalId on the same entity refreshes the stored URL and title and returns that link instead of adding a duplicate. Provider jira REQUIRES the issue to exist in the connected Jira: the key is looked up FIRST and an unknown one fails the whole call with 400 and stores nothing, whatever externalUrl you supply. Once it resolves, title and canonical URL are read from the Jira API, and when the organization has remote links enabled a Remote Link is pushed back onto the Jira issue, so a failure there comes back as remoteLinkWarning while the local link still stands. Call list_external_links to see what an entity is already linked to and to get link ids, and remove_external_link to delete one by its link UUID.
Inputs: entityId (required), provider (required), entityType (required), externalId (required), +3 more.
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_casesAIdempotent
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_executionADestructiveIdempotent
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_folderADestructiveIdempotent
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_releaseADestructiveIdempotent
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_caseADestructiveIdempotent
Soft delete (archive) a test case. The case can be restored via the UI. Also unlinks any connected autotests.
Inputs: caseId (required).
delete_test_collectionADestructiveIdempotent
Archive (soft delete) a test collection. The collection can be restored via the UI. Test executions are preserved.
Inputs: collectionId (required).
export_reportARead-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_historyARead-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_gapsARead-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_executionARead-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_casesARead-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_scanARead-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_folderARead-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_statisticsARead-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_launches_trendsARead-onlyIdempotent
Aggregate a project over a window: pass rate over time, the tests that fail most, the flaky ones, duration trends and the slowest tests. IMPORTANT: there is no single pass rate in this response. trends.passRate is a SERIES, one row per day, each carrying total_runs, passed_runs and pass_rate; to answer a question about the whole window you have to sum the daily totals yourself rather than average the daily rates, which would weight a quiet day the same as a busy one. And it is a rate over LAUNCHES that ended green, not over tests that passed, and the two differ widely; for the test-level figure use summary.testPassRate from get_launches_statistics. In the failing section, total_runs counts ATTEMPT ROWS rather than launches, so failure_rate is failed attempts over attempts and a test retried three times in one launch contributes three. That section ranks over the WHOLE window and says nothing about the present: a test that failed heavily early on and was fixed still tops the list, and no field in the row - there is no lastStatus and no lastSeen - reveals that it is green today. It answers what has failed most, never what is failing now; for that, read the newest launch with get_launch_tests. Flakiness is ranked by flip_count, the number of times a test changed result between consecutive ATTEMPTS, retries included, alongside instability_score which weighs how evenly it splits between pass and fail. Attempts, not launches: a test that fails twice and passes on the third try in every run scores high here while never once turning a launch red, and flip_count can exceed the number of launches in the window. Only passed and failed attempts are counted, so skipped and flaky rows are absent from both figures. For per-launch flipping, read get_test_history and group by runId. days defaults to 30, so a quiet project returns empty series, and the flaky, slowest and tests-by-tag sections are additionally capped at 90 days however much you pass, while the trend series itself honours the full range: so a 365-day call answers two different windows in one payload. Counts and rates in this response come back as STRINGS, total_runs as "45" and failure_rate as "80.00", so coerce them before comparing or summing. Use include[] to compute only the sections you need and topN to size the lists. Reach for get_launches_statistics to page through individual launches, and get_launch_tests when you have one launch.
Inputs: projectId (required), days, tags, topN, +1 more.
get_launch_testsARead-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_projectARead-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_releaseARead-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_caseARead-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_collectionARead-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_historyARead-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.
link_autotest_to_caseAIdempotent
Link an automated test, by title, to a manual test case for coverage tracking. The autotest does not need to exist yet, so pre-linking is allowed. IMPORTANT: the link applies going FORWARD only and no past results are backfilled, so a test with a long history still shows an empty includeRecentExecutions on get_test_case until it next reports. The returned testExists and wasCreated describe whether a test of that title has been seen and whether the link row was new, NOT whether any history was attached. Use get_test_history to read the results that already exist for that title.
Inputs: caseId (required), testTitle (required).
link_launches_to_releaseAIdempotent
Link launches to a release. Unlike Test Collections, which are copied in, launches are linked by reference.
Inputs: launchIds (required), releaseId (required).
list_executionsARead-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_external_linksARead-onlyIdempotent
List external ticket links for a given entity, optionally filtered by provider.
Inputs: entityId (required), entityType (required), provider.
list_foldersARead-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_projectsARead-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_releasesARead-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_casesARead-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_collectionsARead-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_caseAIdempotent
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_collectionADestructiveIdempotent
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_external_linkADestructive
Remove an external ticket link by its link UUID (as returned by add_external_link or list_external_links).
Inputs: linkId (required).
remove_source_from_executionADestructiveIdempotent
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_resultAIdempotent
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_checkARead-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_testsARead-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_statusAIdempotent
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_casesARead-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.
unlink_launch_from_releaseADestructiveIdempotent
Remove an automated launch from a release. The launch itself is not affected.
Inputs: launchId (required), releaseId (required).
update_executionAIdempotent
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_folderAIdempotent
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_releaseAIdempotent
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_caseAIdempotent
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_collectionAIdempotent
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
Scored across 55 tools
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 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.
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.
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
Related MCP Connectors
Free test management over MCP: projects, test cases, plans, runs, environments and tasks.
Official MCP server for Qase — manage test cases, runs, suites, defects via AI tools.
Read and write Mission Control state via MCP — projects, tasks, subtasks, templates, status updates.
Run, debug, and triage tests from your IDE using natural language, no dashboard switching, no manual data transfers. The TestMu AI (formerly LambdaTest) MCP Server is a single remote server exposing four tool suites: HyperExecute — analyze your project, generate YAML configs and test runner commands, then monitor jobs and sessions. Automation — pull a TestID's details plus command, network, and console logs into one chat for instant root-cause analysis. Includes mobile app upload. SmartUI — explain pixel, layout, DOM, and perceptual changes in a visual regression run, with context-aware React/HTML/CSS fixes. Accessibility — audit any public URL or a local React app against WCAG and get ready-to-apply remediation steps. Connects over https://mcp.lambdatest.com/mcp using OAuth 2.1 — no API keys in your config. One-click install in Cursor; works with Claude, GitHub Copilot, Cline, and any MCP client. Tests execute on the TestMu AI cloud: 3,000+ browsers and 10,000+ real devices.
Related MCP Servers
- AlicenseAqualityFmaintenanceEnables 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.426,218 npm42MIT
- AlicenseCqualityDmaintenanceMCP server for TestNeo quality workflows, enabling test generation, execution, and analysis through MCP-compatible IDE clients.4816 npmGPL 3.0
- AlicenseAqualityDmaintenanceThis 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 suites984 npm1MIT
- AlicenseBqualityCmaintenanceAn 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.3125 PyPI2MIT