PractiTest MCP for AI. Audit complex test runs from a chat window.

Q: How does the listruns tool work with gettest?

The agent uses listruns to find a specific failed run ID. Then, it passes that ID's context to gettest to pull up the detailed steps and expected results for that test case, showing you exactly where the execution broke.

Q: Can I check compliance using listrequirements?

Yes. You ask about a requirement, and the agent uses listrequirements to show its status, plus how many tests are linked to it and if any defects have been found against it.

Q: What is the difference between listtests and gettest?

listtests gives you a summary of every test case (names, IDs, statuses). gettest digs into one specific ID to show all the granular data: preconditions, steps, expected results, etc.

Q: Does listissues track which test instances are affected?

Yes. When you call listissues, the returned defect records contain links directly back to specific test references, allowing you to narrow down exactly where the bug appeared in the test suite.

Q: What data fields can I expect when using listtests?

The listtests tool returns comprehensive records for each test case. You'll get names, IDs, statuses, custom field metadata, and explicit traceability links baked into the output.

Q: How do I check which users are available using listusers?

The listusers tool provides an immediate roster of all accounts in your PractiTest project. It returns user names, corresponding emails, their defined roles, and current account statuses.

Q: Can I use getset to understand the scope versus just a single test case?

Yes, getset gives you an execution summary for groups of tests. It shows the set's status, how many instances are included, and overall run statistics, which is broader than any single test case.

Q: What is the purpose of listcustomfields?

The listcustomfields tool shows every custom field available in your project. It lists the field names, their data types, which entities they apply to, and any possible values defined.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

PractiTest brings end-to-end QA management right into your AI client. You can list test cases, track execution runs, audit requirements compliance, and map software defects—all by asking natural questions in chat.

It connects every piece of the testing puzzle: from initial requirements to final failed step.

What your AI can do

List tests

Returns a list of every test case in the project, showing IDs, statuses, and traceability links. Uses JSON:API format.

Get test

Pulls all details for one test case: name, steps, preconditions, expected results, and linked requirements.

List sets

Lists all defined test sets in the project, including names, status, planned dates, and assigned testers.

+ 7 more capabilities included

Trace a failed execution step

The agent retrieves detailed historical data for specific test runs, showing statuses (PASSED/FAILED) and pinpointing exactly where the failure occurred.

Audit system compliance against requirements

You query all defined business requirements to see their current status and how many tests are linked to them in the project.

Identify open defects tied to test clusters

The agent searches for reported issues, giving you the issue name, severity, and which specific test instances they relate to.

View full test case details

You pull up a single test case to review its preconditions, expected results, steps, and associated custom metadata.

Map user accounts and roles

The agent lists all users in the PractiTest account, showing their name, email, and assigned role.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

PractiTest: 10 Tools for Quality Assurance

Use these tools to manage your entire testing lifecycle—from listing basic test cases to auditing complex defect histories and requirements compliance.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using PractiTest on Vinkius

List Tests

Returns a list of every test case in the project, showing IDs, statuses, and traceability links. Uses JSON:API format.

Get Test

Pulls all details for one test case: name, steps, preconditions, expected results...

List Sets

Lists all defined test sets in the project, including names, status, planned dates...

Get Set

Retrieves the name, status, instance count, and execution summary for a specific...

List Instances

Lists individual copies of test cases within a set, showing IDs and last run...

List Runs

Provides a list of every test run execution, returning IDs, statuses (PASSED/FAILED), durations, and timestamps.

List Requirements

Lists all business requirements, showing their current status and how many test cases reference each one.

List Issues

Retrieves all defects (issues) in the project, including status, severity, and which...

List Custom Fields

Shows all custom data fields available in the project, including their types and...

List Users

Lists all user accounts associated with your PractiTest organization, including...

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The PractiTest integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "practitest": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the PractiTest tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"practitest": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with PractiTest, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,000+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by PractiTest. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Juggling QA reports shouldn't feel like a full-time job.

Right now, tracking down why a feature broke is brutal. You start in the test runner dashboard (where you find the run ID), click over to the bug tracker (to see if someone else found it), then pivot to the requirements document (to check which business need was broken). You copy-paste IDs and manually cross-reference status columns across three different applications just to answer, 'Why did this fail?'

With PractiTest MCP Server, you just ask your agent. Say, 'Tell me about the Payment flow failure from yesterday.' It automatically runs `list_runs`, finds the failing ID, uses `get_test` for context, and calls `list_issues` to pull up all related bugs—all without you opening a single new tab.

PractiTest MCP Server: Get full defect mapping from chat.

Before this, finding out if a reported bug was linked to a core business requirement meant running manual reports that might miss links or take hours. You'd have to check the issue tracker, then cross-reference against the requirements matrix, hoping nothing fell through the cracks.

Now, just ask: 'Are there any open defects related to multi-currency transactions?' The agent calls `list_issues` and filters by test reference, giving you immediate visibility. It's not just data; it’s an instant audit trail.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Listen up. This server plugs PractiTest right into your AI client, so you don't have to jump through hoops across five different dashboards just to check on QA. It lets your agent orchestrate the entire testing lifecycle via natural conversation, mapping everything from initial business requirements down to specific failed steps.

Tracking Scope and Structure
When you need a high-level view of the project, you can start by listing all defined test sets using list_sets. This gives you names, current status flags, planned dates, and who's assigned to test them. To see every single test case in the system, run list_tests; this returns a JSON:API format list showing IDs, statuses, and any traceability links attached to those tests.

If you want to drill down on specific groups of tests, use get_set. You'll get the name, status, instance count, and execution summary for that exact test set. For an even finer grain view of a single set, list_instances shows every individual copy of a test case—the IDs and their last run statuses.

If you want to know what custom data fields are floating around in your project, check out list_custom_fields; it'll show the field name, type, and possible values.

Monitoring Execution and Failures
Need to track how well everything’s running? You can pull up a list of every test run execution using list_runs. This gives you IDs, status markers (PASSED or FAILED), duration times, and timestamps for every attempt. To trace exactly why something failed—a key capability for finding the root cause—the agent uses historical data from those runs to pinpoint precisely which step threw a failure flag.

To get all the nitty-gritty details on one test case, you run get_test. This pulls up everything: its name, specific steps it includes, what preconditions must be met before running, the expected results, and any linked requirements. You can also use list_examples to pull all details for a single test case.

Auditing Compliance and Defects
For compliance checks, you don't have to manually count anything. Running list_requirements gives you every business requirement, showing its current status and exactly how many test cases are pointing back to it in the project. This lets you audit system compliance at a glance.

When things go wrong, your agent handles defect triage. Using list_issues, you retrieve all reported defects, giving you the issue name, severity level, and which specific test instances they’re linked to. If you've got questions about who works here, run list_users to get names, emails, and assigned roles for every user in your PractiTest account.

The full capability set lets you:

Audit the entire project against its business requirements using list_requirements.
Identify open defects by listing issues with list_issues, showing severity and linked test instances.
View complete test case details, including steps, expected results, and preconditions, via get_test.
Map out all users and their roles using list_users.

It's this deep connection that lets your agent manage the entire QA scope—it doesn't just list things; it connects requirements to tests, tracks runs, and pins down defects. You don't need a dozen tabs open.

Built · Hosted · Managed by Vinkius PractiTest MCP Server - QA Test Management

Server ID 019d75f8-e65c-7348-abe3-3c42c58e4a07

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

Here's how it actually works

The bottom line is that your AI client becomes an expert QA analyst, pulling together scattered information from your whole test management platform instantly.

Subscribe to this server and supply your PractiTest Personal API Token and Project ID.

Launch your AI client (Claude, Cursor, etc.) and tell the agent what you need—for example: 'Why did the Payment flow fail last night?'

The agent uses the relevant tools (list_runs, get_test) to gather all data and gives you a clean, summarized answer in chat.

Who is this actually for?

This is for the QA Automation Engineer who's done enough manual dashboard jumping to last a lifetime. It’s for Product Owners needing instant proof of compliance, and Developers who want to debug failure logs without opening the test runner GUI.

QA Automation Engineer

You run complex queries combining list_runs results with get_test details to find a regression source. You use this to verify integration outputs instantly.

Product Owner

You track live requirement statuses by cross-referencing what the business needs (list_requirements) against the current execution state in chat.

Software Developer

You dive into reported issues using list_issues to get exact test failure details, letting you start debugging code before touching a line of test script.

What Changes When You Connect

Stop jumping between tabs. You can ask the agent to run list_issues and immediately see if a defect is tied to a specific requirement or test set, all in one response.

When debugging a failure, you don't need to open the runner UI. Ask for list_runs, pinpoint the Run ID, and use get_test to pull up the exact steps that failed.

Compliance checks are instant. Instead of manually cross-referencing documents, ask for list_requirements. The agent shows you which requirements lack test coverage or have open defects linked via list_issues.

Understand your testing scope quickly. By calling list_tests and then checking the details with get_test, you get a full picture of every single test case, its purpose, and its dependencies.

See who did what. Use list_users to manage access or check team assignments via list_sets without leaving your primary workflow.

See it in action

01 01

The sudden regression:

A developer reports a failure in the payment flow. Instead of manually checking logs, they ask the agent: 'List runs for Payment Flow and check associated issues.' The agent uses list_runs to find the failed run ID, then calls list_issues to pull up 'Payment Fallback Failed' (Issue #129), giving the developer the exact context needed to start fixing.

02 02

Auditing for regulatory compliance:

A Product Owner needs proof that the GDPR requirement is fully tested. They ask: 'Show all requirements linked to GDPR.' The agent uses list_requirements and then checks the associated test links, giving them a clear list of coverage gaps or unaddressed statuses.

03 03

Understanding dependencies:

A tester is reviewing a large feature set. They ask: 'What are all the tests in Set X?' The agent calls list_sets to get the group, then uses list_instances and get_test repeatedly to build a complete map of every single test case included.

04 04

Onboarding new team members:

A manager needs an overview of current users and roles. They ask: 'Who is on the QA team?' The agent runs list_users, providing a clean roster with roles, saving time spent navigating internal directories.

The honest tradeoffs

Debugging blind

Anti-pattern

A developer sees that a test failed and just copies the failure message into Google. They waste 30 minutes cross-referencing manually to figure out why it failed or what requirement was violated.

The Fix

Instead, ask your agent: 'Check list_issues for defects tied to this specific test run ID.' This links the raw failure data directly to a tracked defect and its source requirements.

Assuming scope

Anti-pattern

A PM asks, 'Did we cover all our payment features?' They don't know if they need to check individual tests or entire sets.

The Fix

Ask the agent to run list_sets first. This groups the work logically, allowing you to then target specific areas with get_set details.

Over-relying on dashboards

Anti-pattern

The QA team spends hours in the UI filtering by date and status across multiple views just to compile a summary report.

The Fix

Ask your agent for list_runs filtered by 'FAILED' last week. It compiles the raw data into chat, ready for immediate analysis.

When It Fits, When It Doesn't

Use this server if your primary pain point is traceability: needing to link a specific bug (from list_issues) back through a failed run (list_runs) to the original business requirement (list_requirements). It’s essential for highly regulated industries where proof of compliance matters.

Don't use it if you only need simple CRUD operations on unrelated data, like reading user emails or checking out inventory. For those tasks, stick with dedicated tools. If your goal is simply to create a task list, use a ticketing system; don’t try to pull that from list_tests.

This tool excels when you have multiple data silos (Requirements, Test Cases, Runs, Issues) and need one conversational interface to connect them all.

Questions you might have

How does the list_runs tool work with get_test? +

The agent uses list_runs to find a specific failed run ID. Then, it passes that ID's context to get_test to pull up the detailed steps and expected results for that test case, showing you exactly where the execution broke.

Can I check compliance using list_requirements? +

Yes. You ask about a requirement, and the agent uses list_requirements to show its status, plus how many tests are linked to it and if any defects have been found against it.

What is the difference between list_tests and get_test? +

list_tests gives you a summary of every test case (names, IDs, statuses). get_test digs into one specific ID to show all the granular data: preconditions, steps, expected results, etc.

Does list_issues track which test instances are affected? +

Yes. When you call list_issues, the returned defect records contain links directly back to specific test references, allowing you to narrow down exactly where the bug appeared in the test suite.

What data fields can I expect when using list_tests? +

The list_tests tool returns comprehensive records for each test case. You'll get names, IDs, statuses, custom field metadata, and explicit traceability links baked into the output.

How do I check which users are available using list_users? +

The list_users tool provides an immediate roster of all accounts in your PractiTest project. It returns user names, corresponding emails, their defined roles, and current account statuses.

Can I use get_set to understand the scope versus just a single test case? +

Yes, get_set gives you an execution summary for groups of tests. It shows the set's status, how many instances are included, and overall run statistics, which is broader than any single test case.

What is the purpose of list_custom_fields? +

The list_custom_fields tool shows every custom field available in your project. It lists the field names, their data types, which entities they apply to, and any possible values defined.

Can the AI provide the exact step where a test case failed? +

Yes. If an execution failed, the agent uses list_runs for the instance. Since an instance maps directly to test steps, the AI inherently decodes the exact execution traces to show you the failing parameters.

Is PractiTest's requirement and issue tracing accessible to the AI? +

Yes. Tools like list_requirements and list_issues expose full traceability trees. You can ask exactly how many QA instances are mapped to Requirement 5.

Do I need to copy the project ID separately? +

Yes. In PractiTest, APIs execute cleanly isolated within specific Project instances. You must provide the numeric Project ID alongside your Personal Token so the underlying pt-engine binds queries strictly to that project.

Connect to your AI in seconds.

List tests

Get test

List sets

PractiTest: 10 Tools for Quality Assurance

Make your AI actually useful.

List Tests

Get Test

List Sets

Get Set

List Instances

List Runs

List Requirements

List Issues

List Custom Fields

List Users

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Juggling QA reports shouldn't feel like a full-time job.

PractiTest MCP Server: Get full defect mapping from chat.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

The sudden regression:

Auditing for regulatory compliance:

Understanding dependencies:

Onboarding new team members:

The honest tradeoffs

Debugging blind

Assuming scope

Over-relying on dashboards

When It Fits, When It Doesn't

Questions you might have