QA Automation MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@QA Automation MCP Server Crawl https://example.com/login and test the login form submission"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
QA Automation MCP Server
An AI-powered QA automation tool built on the Model Context Protocol (MCP). It crawls web pages, generates Playwright-based pytest tests using an LLM, runs them, and automatically heals failing tests — all driven by natural language instructions.
How It Works
User Instruction
│
▼
crawl_page(url)
│ Headless Chromium extracts all interactive elements
▼
write_test(crawl_data, instruction, output_dir)
│ Groq LLM generates a pytest + Playwright test file
▼
run_test(crawl_data, output_dir)
│ Pytest executes the generated test
│
├── PASS → HTML report + text summary
│
└── FAIL (locator/timeout error)
│
▼
Auto-Healer
│ Groq rewrites the broken locators
▼
Re-run test
│
└── HTML report + text summary (marked "healed")Related MCP server: Quality MCP
Features
Page Crawling — Extracts inputs, buttons, and links with CSS selectors, XPaths, and metadata
AI Test Generation — Converts a plain-English instruction + crawl data into a complete pytest test file
Automated Execution — Runs tests programmatically with
pytestand captures all outputAuto-Healing — Detects locator/timeout failures and sends the broken test back to the LLM for repair, then re-runs automatically
Rich Reporting — Generates an HTML report with screenshots and a text summary; opens in browser automatically
Headless or Headed — Browser is headless by default; pass
show_browser=trueto watch it run
Architecture
MCP-server/
├── main.py # MCP server entry point and request dispatcher
├── pyproject.toml # Project metadata and dependencies
├── .env # API keys (not committed)
└── src/
├── tools.py # MCP tool definitions (schemas exposed to the client)
├── handlers.py # Request handlers that wire tools to logic
├── crawler.py # Playwright-based page crawling
├── writer.py # LLM-powered test code generation
├── runner.py # Pytest execution and result parsing
├── healer.py # Auto-healing logic for failing tests
└── reporter.py # HTML and text report generationMCP Tools
The server exposes three tools to any MCP-compatible client.
crawl_page
Crawls a URL and returns structured data about all interactive elements on the page.
Parameter | Type | Description |
| string | The page URL to crawl |
Returns: JSON with title, inputs, buttons, and links, each containing locator strategies (CSS selector, XPath) and metadata.
write_test
Generates a pytest + Playwright test file from crawl data and a plain-English instruction.
Parameter | Type | Description |
| string | JSON output from |
| string | What to test, e.g. "submit the login form" |
| string | Root directory where test files will be saved |
| boolean | Show the browser during execution (default: false) |
Returns: Path to the generated test file at {output_dir}/generated_tests/test_*.py.
run_test
Executes the generated test and returns a report. Automatically attempts to heal locator/timeout failures.
Parameter | Type | Description |
| string | JSON from |
| string | Project root directory |
| string | Path to test file (optional; defaults to last generated) |
Returns: Text summary + path to the HTML report at {output_dir}/test_results/report_*.html.
Prerequisites
Python 3.12+
uv (recommended) or pip
Playwright browsers installed
Installation
1. Clone the repository
git clone <repo-url>
cd MCP-server2. Install dependencies
uv syncOr with pip:
pip install -e .3. Install Playwright browsers
uv run playwright install chromium4. Create a .env file
GROQ_API_KEY=your_groq_api_key_hereRunning the Server
The server communicates over stdio, which is the standard transport for MCP clients like Claude Code.
uv run python main.pyConnecting to Claude Code
Add the server to your Claude Code MCP configuration (.claude/settings.json or ~/.claude/settings.json):
{
"mcpServers": {
"qa-automation": {
"command": "uv",
"args": ["run", "python", "main.py"],
"cwd": "/absolute/path/to/MCP-server"
}
}
}Once connected, you can drive the entire QA workflow through natural language in Claude Code:
"Crawl https://example.com, then write a test that fills in the search box and clicks Submit, and run it."
Generated Output
Each test run produces the following structure inside output_dir:
{output_dir}/
├── generated_tests/
│ └── test_<slug>.py # Generated pytest test file
├── test_results/
│ └── report_YYYYMMDD_HHMMSS.html # HTML report with screenshot
└── result.png # Screenshot from the last test runThe HTML report is opened automatically in your default browser after each run.
Auto-Healing
When a test fails due to a locator or timeout error, the healer:
Parses the pytest output to identify the broken locator
Sends the original test code, the error, and the fresh crawl data to the LLM
Receives a rewritten version with corrected selectors (
get_by_role,get_by_text, or CSS)Saves the patched file and re-runs the test
Marks the final report with
healed: true
Only one healing attempt is made per run. Logic errors (wrong assertions, incorrect flow) are not healed automatically.
Dependencies
Package | Purpose |
| MCP server framework |
| Browser automation |
| Test execution |
| Playwright fixtures for pytest |
| LLM API for test generation/healing |
|
|
| Async HTTP client |
| Data validation |
LLM Configuration
Provider: Groq
Model:
llama-3.3-70b-versatileTemperature:
0.3for test generation,0.1for healing (tighter, more deterministic)
To switch models or providers, update src/writer.py and src/healer.py.
Limitations
Auto-healing only addresses locator and timeout errors, not test logic errors
Only one healing attempt per test run
Authentication and multi-step login flows are not handled automatically
Hardcoded to Groq's
llama-3.3-70b-versatilemodel
License
MIT
Available Tools
3 toolscrawl_pageA
Crawl a webpage and extract all interactive elements like inputs, buttons and links with their locators. Always call this first before writing a test.
Inputs: url (required).
run_testA
Run the generated pytest Playwright test. Automatically heals the test if it fails due to a locator error. Always call write_test first.
Inputs: crawl_data (required), output_dir (required), test_file.
write_testA
Generate a pytest Playwright test based on crawl data and a user instruction. Always call crawl_page first to get the crawl_data. Returns the path to the generated test file — pass it as test_file when calling run_test.
Inputs: crawl_data (required), instruction (required), output_dir (required), show_browser.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
Each tool has a distinct and clear purpose: crawl_page extracts elements, write_test generates tests, run_test executes them. No overlap.
All tools follow a consistent verb_noun pattern in snake_case: crawl_page, write_test, run_test. Predictable and clean.
Three tools perfectly cover the core workflow of a QA automation server: crawl, write, run. Not excessive, not insufficient.
The essential workflow is complete, but missing test management tools (e.g., delete, list) or debugging utilities. Minor gap.
Related MCP Connectors
AI QA tester — real browsers scan sites for bugs, SEO, perf, and accessibility issues via chat.
Browser-based QA for AI-built software. Test pages with real browsers via agents.
Run AI QA test runs on your web app and read the bugs they find, with steps to reproduce.
AI QA that runs your app in a browser on every pull request: projects, test targets, test cases.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAutonomous QA platform powered by Claude + Playwright that allows AI to write, run, and fix tests for any project.MIT
- AlicenseNot gradedqualityDmaintenanceAutomates repository analysis, test planning, and generation of end-to-end tests with Playwright, acting as an intelligent quality assistant.18 npmMIT
- AlicenseNot gradedqualityDmaintenanceEnables automated QA testing by running a pipeline of AI agents that generate test scenarios, architect test layers, write Playwright tests, and review code, all grounded in feature requirements and API contracts.ISC
- AlicenseAqualityBmaintenanceEnables AI assistants to create, run, autocorrect, and monitor Playwright tests for your app with a local dashboard, credential vault, and public status page.16MIT