# Qase MCP for AI Agents AI Agent Connect

> Qase MCP brings your test management workspace into your AI workflow. It lets you list projects, track test runs, inspect specific cases, and monitor defects directly from your chat. You can check test case steps while coding or get summaries of milestone progress without leaving your IDE.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_DmxFjwi8voxH7zM7sJq9mvaS2UF2jcPQlNrC5P0K/ai-agent-connect
- **Tags:** test-management, defect-tracking, qa-automation, test-reporting, milestone-tracking

## Description

Qase is your test management hub, and this Connector connects it directly to your AI agent. Instead of switching tabs to find a test step or check a defect status, you can just ask your agent to pull that data. It's about getting the QA details you need exactly where you're already working. When you use this through the Vinkius catalog, you stop hunting for information in a dashboard and start getting it in your chat. You can grab project overviews, dig into specific test suites, or pull the latest defects linked to a failed run. It makes the bridge between writing code and verifying it much shorter. You can see if a test case is blocked, check the severity of a bug, or see how many milestones are finished, all while staying focused on the task at hand.

## Tools

### list_plans
Shows all test plans in a project. Use it to see how tests are organized.

### list_projects
Lists all projects in your Qase workspace. Use it to get an overview of your testing landscape.

### list_cases
Lists test cases in a project. Use it to find specific tests quickly.

### get_project
Retrieves details for a specific project. Use it to see project-level metrics.

### get_case
Retrieves details for a specific test case. Use it to see steps and expected results.

### list_suites
Lists test suites in a project. Use it to navigate your test hierarchy.

### list_runs
Lists all test runs in a project. Use it to see the history of your executions.

### get_run
Retrieves details for a specific test run. Use it to see the results of a specific execution.

### list_milestones
Lists all milestones in a project. Use it to track high-level progress.

### list_defects
Lists all defects linked to test case failures. Use it to see what's breaking.

## Prompt Examples

**Prompt:** 
```
List all Qase projects and show me their overall health.
```

**Response:** 
```
I retrieved 3 active projects in your Qase instance. 

| Project Name | Code | Test Cases | Open Defects |
| :--- | :--- | :--- | :--- |
| Mobile App | MOB | 150 | 3 |
| Web Portal | WEB | 300 | 12 |
| API V2 | API | 50 | 0 |

Should I inspect the defects on the Mobile App project?
```

**Prompt:** 
```
Fetch the details of test case ID 45 in the WEB project.
```

**Response:** 
```
Here are the details for **WEB-45** ('User Login using SSO'):

*   **Pre-conditions**: User must have an active Google SSO account.
*   **Step 1**: Click 'Login with Google' -> *Expected*: Google Auth modal opens.
*   **Step 2**: Enter valid credentials -> *Expected*: Redirect to dashboard.

Would you like me to write a Cypress test for this?
```

**Prompt:** 
```
Are there any recent defects added for the WEB project?
```

**Response:** 
```
Yes, I checked the latest defects for the **WEB** project. There are 2 new defects recorded today:

1. **Defect #11**: 'CSS layout breaks on mobile' (Severity: High)
2. **Defect #12**: 'API timeout during checkout' (Severity: Critical)

Both are currently in 'open' status. Shall I pull the details for #12?
```

## Capabilities

### Pull project overviews
Get counts of cases, runs, and defects instantly.

### Inspect test cases
View specific steps and automation status.

### Monitor test runs
Check passed, failed, and blocked statuses.

### Track defects
List bugs linked to failed tests with severity levels.

### View test plans
See all plans within a specific project.

### Check milestones
See project progress and completion metrics.

## Use Cases

### Writing automation scripts
A QA engineer asks for the steps of a specific test case to write a script, using `get_case` to ensure every step is captured correctly.

### Debugging a failed deployment
A developer asks for all defects linked to a failed test run in the web project to see what's breaking immediately.

### Reporting project status
A PM asks for a summary of milestones and test counts for a new release to provide a quick update without opening a dashboard.

### Planning a new sprint
A lead uses `list_plans` to see how the upcoming sprint is organized and check the current test case counts.

## Benefits

- Get test steps immediately using `get_case` while you're coding in your IDE.
- See project health metrics using `list_projects` without leaving your terminal.
- Identify breaking bugs faster by pulling linked issues with `list_defects`.
- Track progress against deadlines by checking milestones with `list_milestones`.
- Monitor execution history using `list_runs` to see what passed or failed recently.

## How It Works

The bottom line is you get your QA data in your chat instead of a browser tab.

1. Subscribe to the Qase MCP on Vinkius.
2. Provide your Qase API Token for authorization.
3. Ask your agent to list projects or fetch specific test details.

## Frequently Asked Questions

**How does Qase MCP help with QA automation?**
It lets your AI agent pull specific test case steps directly into your workspace. This means you can write automation scripts faster by having the requirements right where you're coding.

**Can I see test results with Qase MCP?**
Yes, you can use it to list all test runs in a project and get specific details for any individual run to see what passed or failed.

**How do I connect Qase to my AI client?**
Just subscribe to the Connector on Vinkius and provide your Qase API Token. Once connected, your agent can access your test cases, runs, and defects.

**Can Qase MCP track my project milestones?**
Yes, it can list all milestones in a project, making it easy to ask your agent for a summary of high-level progress and completion metrics.

**Does Qase MCP show me defect severity?**
It does. When you pull defects linked to test failures, the Connector retrieves the severity levels and issue links so you can prioritize them.

**Can I use Qase MCP to find specific test steps?**
Absolutely. You can ask your agent to fetch details for any specific test case, and it will return the pre-conditions and execution steps.

**How do I securely obtain my Qase Token?**
Log in to Qase.io and click your profile icon to go to **Account settings**. Select **API Tokens** (or sometimes found under Apps for an integration token), and click **Create a new API token**. Add a name, click generate, and copy the string provided. It takes exactly 15 seconds. Paste it here to authenticate. Your token is encrypted at rest and injected securely at runtime.

**Can my AI write test scripts using the case details?**
Absolutely. Inside your IDE (like Cursor), you can ask the agent to 'Fetch case #12 from Qase project PROJ'. The tool retrieves the precise steps, preconditions, and expected results. The agent can then automatically generate Playwright, Cypress, or Selenium scripts based exactly on those Qase definitions.

**How can I check the results of a recent QA cycle?**
Ask your agent to `list_runs` for your project. This will surface your recent executions. If you notice a run with a high failure rate, ask the agent to pull `get_run` with that run's ID to dive into specifics and see which modules failed the automated checks.

**Can it help me track Jira bugs linked to tests?**
Yes. By using the `list_defects` capability, your AI can pull all registered defects in a Qase project. If your Qase is integrated with Jira or GitHub, the returned defect data includes external issue links, helping developers immediately map a failed test to the corresponding engineering ticket.