QASE MCP Server

MCP server implementation for Qase API

This is a TypeScript-based MCP server that provides integration with the Qase test management platform. It implements core MCP concepts by providing tools for interacting with various Qase entities.

Features

Tools

The server provides tools for interacting with the Qase API, allowing you to manage the following entities:

Projects

• list_projects - Get all projects
• get_project - Get project by code
• create_project - Create new project
• delete_project - Delete project by code

Test Cases

• get_cases - Get all test cases in a project
• get_case - Get a specific test case
• create_case - Create a new test case
• update_case - Update an existing test case

Test Runs

• get_runs - Get all test runs in a project
• get_run - Get a specific test run

Test Results

• get_results - Get all test run results for a project
• get_result - Get test run result by code and hash
• create_result - Create test run result
• create_result_bulk - Create multiple test run results in bulk
• update_result - Update an existing test run result

Test Plans

• get_plans - Get all test plans in a project
• get_plan - Get a specific test plan
• create_plan - Create a new test plan
• update_plan - Update an existing test plan
• delete_plan - Delete a test plan

Test Suites

• get_suites - Get all test suites in a project
• get_suite - Get a specific test suite
• create_suite - Create a new test suite
• update_suite - Update an existing test suite
• delete_suite - Delete a test suite

Shared Steps

• get_shared_steps - Get all shared steps in a project
• get_shared_step - Get a specific shared step
• create_shared_step - Create a new shared step
• update_shared_step - Update an existing shared step
• delete_shared_step - Delete a shared step

Development

Install dependencies:

npm install

Build the server:

npm run build

For development with auto-rebuild:

npm run watch

Docker

1. Copy .env.example to .env and add your Qase API token.
2. Generate HTTPS certificates (example with mkcert):

   brew install mkcert nss   # macOS example
   mkcert -install
   mkdir -p certs
   mkcert -cert-file certs/localhost.pem \
          -key-file certs/localhost-key.pem \
          localhost 127.0.0.1 ::1

   The cert files stay outside of git thanks to the certs/ entry in .gitignore.
3. Start the container (builds the image on first run):

   npm run docker:start

   The server exposes HTTPS on https://localhost:3333 (mapped from port 3000 in the container).
4. Stop the container with:

   npm run docker:stop

5. For background mode, use:

   npm run docker:start:detached

Installation

Claude Desktop

To use with Claude Desktop, add the server config:

• On MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• On Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "mcp-qase": {
      "command": "/path/to/mcp-qase/build/index.js",
      "env": {
        "QASE_API_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}

Claude Code

1. Local Node Method (Recommended): Edit ~/.claude/claude_desktop_config.json and add:

   {
     "mcpServers": {
       "qase": {
         "command": "node",
         "args": ["/absolute/path/to/mcp-qase/build/index.js"],
         "env": {
           "QASE_API_TOKEN": "your-api-token-here"
         }
       }
     }
   }

2. Alternative - Docker Method: With the Docker container running:

   {
     "mcpServers": {
       "qase": {
         "command": "docker",
         "args": ["exec", "-i", "mcp-qase-mcp-qase-1", "node", "./build/index.js"]
       }
     }
   }

After editing the config, restart Claude Code to pick up the new server. The MCP tools will then be available for interacting with your Qase projects.

Codex CLI

Once npm run docker:start is running, Codex can connect in either of two ways:

1. Via the HTTPS endpoint (keeps the Dockerized proxy in play):

   codex mcp add mcp-qase -- npx mcp-proxy --endpoint https://localhost:3333

   If your Node trust store does not include the mkcert CA, append --ca "$(mkcert -CAROOT)/rootCA.pem" to the command above.
2. Directly exec into the container (bypasses HTTPS and attaches to the raw MCP server):

   codex mcp add mcp-qase -- docker exec -i mcp-qase-mcp-qase-1 node ./build/index.js

   Replace mcp-qase-mcp-qase-1 with the container name reported by docker compose ps if your project directory name changes.

Cursor

To use with Cursor, register the command as follows:

env QASE_API_TOKEN=<YOUR_TOKEN> /path/to/mcp-qase/build/index.js

Debugging

Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the MCP Inspector:

npx -y @modelcontextprotocol/inspector -e QASE_API_TOKEN=<YOUR_TOKEN> ./build/index.js