# PractiTest MCP

> PractiTest manages your entire QA lifecycle—from project definition to final run results—using AI Agents. This MCP Server lets your client fetch project details, list requirements, create new test instances and runs, and track quality assurance metrics in real-time via natural conversation. It makes tracking complex software validation processes as simple as asking a question.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** qa-testing, test-management, bug-tracking, quality-assurance, test-automation

## Description

This server gives your AI client full read/write access to everything in your PractiTest workspace. Forget logging into dashboards and clicking through tabs just to gather data; you'll manage the whole quality assurance process right from chat.

**Project Scope & Metadata Management:**

To figure out what projects exist, you can use `list_projects` to get a list of every PractiTest project your API token has access to. If you need all the core details for one specific job, call `get_project` with just the project ID. For requirements, you'll first see everything by calling `list_requirements` within a certain project scope. Then, if you need deep background on a single rule, use `get_requirement` to pull up detailed info about that requirement.

**Test Definition and Audit:**

You can list all defined test cases in a project using `list_tests`. If your agent needs the full rundown on just one specific test case, it pulls that data with `get_test`. To audit what's happening on the ground, you can call `list_instances` to get a list of all current and past test instances within a project. You'll also use `list_tests` when auditing individual tests.

**Creating New Assets & Running Checks:**

Need to start something? The server handles asset creation for you. To generate a brand-new, structured test case inside a given PractiTest project, your agent uses `create_test`. If you need to kick off an entirely new round of checks, it'll call `create_run`, initiating and creating that whole test run in the specified project. You can also programmatically set up fresh testing environments by using `create_instance` for a specific test instance within a given PractiTest project.

**Tracking Live Results:**

To see what's been done, you call `list_runs`, which gives an overview and list of recently executed test runs for the project. If you need to pull granular status on live testing cycles, your agent uses `list_instances` again. This lets you track all the quality assurance metrics in real time just by asking a question.

## Tools

### create_instance
Creates a new test instance within a specific PractiTest project.

### create_run
Initiates and creates an entirely new test run in the specified PractiTest project.

### create_test
Generates a brand-new, structured test case inside a given PractiTest project.

### get_project
Fetches all core details for one specific PractiTest project ID.

### get_requirement
Retrieves detailed information about a single requirement within a project.

### get_test
Gets the full details for one specific test case in PractiTest.

### list_instances
Retrieves a list of all current and past test instances within a project.

### list_projects
Lists every single PractiTest project the API token has access to.

### list_requirements
Lists all defined requirements within a specific PractiTest project scope.

### list_runs
Provides an overview and list of recently executed test runs for a project.

### list_tests
Lists all defined test cases within the scope of a PractiTest project.

## Prompt Examples

**Prompt:** 
```
List all projects available in PractiTest.
```

**Response:** 
```
Here is the list of projects I found in your PractiTest account...
```

**Prompt:** 
```
Create a new test named 'Login Verification' in project ID 123.
```

**Response:** 
```
The test 'Login Verification' has been successfully created in project ID 123.
```

**Prompt:** 
```
Fetch the details of test run ID 456 in project 123.
```

**Response:** 
```
I've retrieved the details for test run ID 456. Here is the current status...
```

## Capabilities

### View Project Metadata
List or get detailed information for any project within PractiTest.

### Manage Test Requirements
Fetch the specific details of a requirement, ensuring QA coverage against defined specifications.

### Track Live Test Runs
List and retrieve granular data on test runs, providing an immediate status of recent validation cycles.

### Create New Testing Assets
Programmatically create new tests, instances, or entire project runs using structured input.

### Audit Instances and Tests
List all existing test instances or individual tests within a specific project scope for auditing.

## Use Cases

### Validating a new feature branch
A developer needs to validate Feature X. They ask their agent: 'What requirements apply to Feature X?' The agent calls `get_requirement` and then uses that ID to list all relevant tests via `list_tests`. Finally, it checks the status by calling `list_runs`, giving the dev a complete pass/fail report without leaving Slack.

### Quickly assessing project scope
A PM needs an overview of all QA projects for quarterly reporting. Instead of checking multiple dashboards, they ask their agent to run `list_projects`. The agent returns a list, allowing the PM to then call `get_project` on the top three candidates.

### Reproducing a failed test
A QA Engineer finds an intermittent bug. They ask the agent to check past runs for that project. The agent calls `list_runs`, identifies the problematic run ID, and then uses `get_test` on that specific test case to pull logs and context for debugging.

### Onboarding a new feature set
A team is starting work on a massive module. They use the agent to first call `list_requirements`, ensuring every piece of documentation is accounted for. Then, they systematically call `create_test` for each requirement before even writing code.

## Benefits

- Stop manually gathering test metrics. Use `list_runs` to pull live QA data directly into your agent's context, eliminating spreadsheet exports and copy-pasting IDs.
- Automate the audit trail by using `get_requirement`. Your agent can fetch a specific requirement's details and cross-reference it with existing tests (`get_test`) instantly.
- Build test suites on demand. Instead of logging into the platform to create new checks, use `create_test` or `create_instance` via simple commands.
- See all your projects in one place. The `list_projects` tool lets you quickly see what QA work exists across your entire portfolio without navigating complex navigation menus.
- Track execution status live. By calling `list_instances`, you get an immediate, current view of the test environment's state—critical for debugging.

## How It Works

The bottom line is: you give the agent access via an API token, and it handles all the complex calls to PractiTest for you.

1. Subscribe to the PractiTest integration on Vinkius.
2. Provide your API Token credentials to link the server to your account.
3. Your AI client can then query, analyze, and manage specific QA data sets using tools like `list_projects` or `get_requirement`.

## Frequently Asked Questions

**How do I get a list of all PractiTest projects using the PractiTest MCP Server?**
You use the `list_projects` tool. This function returns every project ID that your API token has access to, giving you a starting point for any deep dive.

**Can I create a new test case with PractiTest MCP Server?**
Yes, you use the `create_test` tool. You provide the necessary data (as JSON) and the agent handles generating and saving the test inside your target project.

**What is the difference between list_runs and list_instances?**
The `list_runs` tool shows you a list of completed or ongoing *execution cycles*. The `list_instances` tool lists individual, specific test environments that were used during those runs.

**Does PractiTest MCP Server help me track requirements?**
Yes. You use the `get_requirement` and `list_requirements` tools to fetch detailed specs, ensuring your tests are always mapped back to the original business needs.

**What credentials are required when using tools like `get_project` or `list_projects`?**
You must provide a valid PractiTest API Token. This token authorizes your agent and determines the scope of data it can read or modify across your projects.

**When calling `create_test`, what format should I use for the input data?**
The tool requires the test data as a JSON string. You must structure all parameters—like test name, project ID, and steps—into valid JSON to ensure the creation process works.

**Using `list_tests`, how do I filter or specify which tests are included in the list?**
The `list_tests` function provides all available test objects for a given project. While it lists everything, you'll need to use your agent prompt to filter the results based on status or author.

**If I encounter an error while using any PractiTest tool, what should I check first?**
First, verify that the project ID provided in the request is correct and active. If the ID is valid, the API response code will specify whether the issue is authentication-related or a data mismatch.

**Can the AI Agent execute tests inside PractiTest?**
While the agent cannot run automated testing scripts directly in PractiTest, it can create Test Runs, log results into Instances, and manage the administrative side of QA efficiently.

**Are custom fields supported when creating new tests?**
Yes! The AI agent formats API requests dynamically. If your workspace requires custom fields, simply instruct the agent on which attributes to include during the test creation.

**Is there a limit on how many tests the agent can list at once?**
The agent adheres to PractiTest API pagination limits. By default, it returns a single page of results, but you can explicitly ask the AI to query a different page number or limit.