@democratize-quality/artillery-performance-mcp-server
Advanced tools
MCP server for performance testing with Artillery.io
A Model Context Protocol (MCP) server for generating, running, and analyzing performance tests using Artillery.io.
⚠️ This software is provided "as is" without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. By using this software, you acknowledge and agree that any performance testing activities are conducted at your own risk and discretion. The author explicitly disclaims all liability for any licensing requirements, direct, indirect, incidental, special, consequential or exemplary damages resulting from the use, misuse, or inability to use this software, whether based on warranty, contract, tort, or any other legal theory.
⚠️ Important: This MCP server is intended for ease of performance test creation and learning Artillery.io on local development machines only. For production use and licensing requirements, please consult with the Artillery team directly.
This server implements the Model Context Protocol to enable LLMs to create and run performance tests. It provides:
./artillery-tests/ directory (no temp files)Before using this package, ensure you have the following installed:
npm install -g artillery
Install the server globally:
npm install -g artillery-performance-mcp-server
Start in STDIO mode:
artillery-performance-mcp-server-stdio
Optional: Specify a working directory for test files:
artillery-performance-mcp-server-stdio /path/to/your/project
This will create all Artillery test files, results, and reports in the specified directory:
/path/to/your/project/
├── test-configs/ # Artillery test configuration files (.yml)
├── test-results/ # Test results (.json)
└── test-reports/ # HTML reports with stakeholder summaries
Open VS Code Settings (Cmd+, on Mac, Ctrl+, on Windows/Linux)
Search for "mcp" and find "Mcp Servers" setting
Click "Edit in settings.json" and add the Artillery MCP server configuration:
{
"mcp.servers": {
"artillery-mcp": {
"command": "artillery-performance-mcp-server-stdio",
"args": []
}
}
}
To specify a custom working directory for test files:
{
"mcp.servers": {
"artillery-mcp": {
"command": "artillery-performance-mcp-server-stdio",
"args": ["/path/to/your/project"]
}
}
}
Restart VS Code to apply the configuration
Verify the server is working by opening GitHub Copilot Chat and typing:
@artillery-mcp Create a simple HTTP performance test for https://jsonplaceholder.typicode.com/posts
Open Cursor Settings and navigate to MCP Servers
Add new MCP server with the following configuration:
{
"mcpServers": {
"artillery-mcp": {
"type": "stdio",
"command": "artillery-performance-mcp-server-stdio",
"args": []
}
}
}
Restart Cursor and verify by using the AI chat with:
Use artillery-mcp tools to create a basic HTTP test for an API endpoint
For other MCP-compatible clients (Claude Desktop, etc.), add to your MCP configuration:
{
"mcpServers": {
"artillery-mcp": {
"command": "artillery-performance-mcp-server-stdio",
"args": []
}
}
}
If you prefer HTTP transport over STDIO, you can run the server in HTTP mode:
# Start HTTP server (default port 3000)
artillery-performance-mcp-server
# Or specify custom port
PORT=4001 artillery-performance-mcp-server
This starts:
http://localhost:3000/mcphttp://localhost:3000/sseConfigure in your MCP client using the HTTP URL. Note: STDIO mode is recommended for better performance and reliability.
For other MCP-compatible clients, refer to their documentation for adding MCP servers. Use the STDIO configuration shown above for the best experience:
artillery-performance-mcp-server["--stdio"]stdioMost clients support both STDIO and HTTP transports. STDIO is recommended for better performance and reliability.
The server provides the following resources:
artillery://templates - List all available test templatesartillery://templates/{filename} - Get a specific test templateartillery://examples/http-get - Example HTTP GET test templateartillery://examples/http-post - Example HTTP POST test templateartillery://examples/complex-flow - Example complex flow test templateThe server provides five comprehensive tools for Artillery performance testing:
Create Artillery performance tests from predefined templates with comprehensive configuration options.
Enhanced for AI Agents: This tool creates Artillery.io performance test configurations from templates. When specifying targets, provide the actual endpoint URL you want to test (e.g., "https://api.example.com" not just "Artillery.io").
Parameters:
templateType: Test template (http-get, http-post, complex-flow)target: Target URL/hostname for testingendpoint: Specific endpoint path (default: "/")duration: Test duration in seconds (default: 30)arrivalRate: Requests per second during normal phase (default: 5)peakRate: Peak requests per second during ramp-up (optional)timeout: Request timeout in seconds (default: 10)scenarioName: Descriptive name for the test scenario (optional)auth: Authentication token for requests (optional)additionalConfig: Extra Artillery configuration options (optional)File Output: Saves test files to ./artillery-tests/ directory with timestamped names.
Execute Artillery performance tests and generate comprehensive reports with stakeholder summaries.
Enhanced for AI Agents: Runs Artillery.io performance tests and generates both JSON results and enhanced HTML reports with stakeholder summaries for analysis. Files are stored locally in the artillery-tests directory.
Parameters:
testFilePath: Path to the Artillery test YAML filegenerateReport: Whether to create enhanced HTML report (default: true)reportType: Report type - 'enhanced' (with stakeholder summary) or 'simple' (basic metrics only, default: 'enhanced')Enhanced Features:
Output: Creates JSON results file and comprehensive HTML report with both technical details and stakeholder-friendly summaries.
Analyze Artillery test results and provide performance insights and improvement recommendations.
Enhanced for AI Agents: Analyzes Artillery.io test results from JSON files and provides detailed performance insights, bottleneck identification, and actionable improvement recommendations.
Parameters:
resultsFilePath: Path to the JSON results file from Artillery testsuggestImprovements: Whether to provide improvement suggestions (default: true)Analysis Includes: Response times, throughput, error rates, performance bottlenecks, and optimization recommendations.
Create custom Artillery tests with full YAML configuration control.
Enhanced for AI Agents: Creates fully customized Artillery.io test configurations when templates don't meet specific requirements. Accepts complete YAML content for advanced test scenarios.
Parameters:
name: Descriptive name for the custom testcontent: Complete Artillery YAML configuration contentUse Case: For complex test scenarios requiring custom phases, multiple targets, or advanced Artillery features.
Quick creation of basic HTTP performance tests for immediate testing needs.
Enhanced for AI Agents: Simplified tool for creating basic HTTP performance tests against single endpoints. Perfect for quick performance checks or simple load testing scenarios.
Parameters:
targetUrl: Complete URL to test (e.g., "https://api.example.com/health")method: HTTP method (default: "GET")duration: Test duration in seconds (default: 30)requestsPerSecond: Request rate (default: 5)scenarioName: Test description (optional)Best For: Quick API endpoint testing, health check load testing, simple performance validation.
The server provides the following prompts:
Generate a basic HTTP performance test.
Parameters:
targetUrl: Target URL for the testendpoint: Specific endpoint to test (default: "/")requestsPerSecond: Request rate (default: 5)testDuration: Test duration in seconds (default: 60)authToken: Authentication token (optional)Generate a complex API flow test.
Parameters:
targetUrl: Target URL for the testflows: Array of API calls in the flow
method: HTTP method (GET, POST, PUT, DELETE)endpoint: Endpoint for the API callpayload: JSON payload (optional)requestsPerSecond: Request rate (default: 5)testDuration: Test duration in seconds (default: 60)authToken: Authentication token (optional)Analyze performance test results.
Parameters:
resultsOutput: Test results outputperformanceTargets: Performance targets (optional)
maxResponseTime: Maximum acceptable response time in msmaxErrorRate: Maximum acceptable error rate percentageCreate a comprehensive load testing plan.
Parameters:
applicationDescription: Description of the application being testedendpoints: Array of endpoints to testuserScenarios: Array of user scenarios (optional)performanceGoals: Array of performance goals (optional)This Artillery MCP server is optimized for AI agent integration. Here's how to use it effectively:
When working with AI agents, be specific about target URLs to avoid confusion:
✅ Correct: "Test performance of https://api.myservice.com/health" ❌ Incorrect: "Test performance of Artillery.io" (AI might interpret this as testing Artillery's website)
For Quick Testing:
Create a simple HTTP performance test for https://jsonplaceholder.typicode.com/posts with 10 requests per second for 30 seconds
For API Flow Testing:
Generate an Artillery test for https://api.example.com that tests the login flow: POST /auth/login, then GET /user/profile, running for 60 seconds at 5 RPS
For Analysis:
Run the test and analyze the results, suggesting performance improvements
./artillery-tests/ directoryReady to test the Artillery MCP server? Use these complete prompts with public endpoints that you can try immediately:
Step 1: Create and Run Test
Use the Artillery MCP server tools to:
1. Create a basic HTTP GET performance test for https://jsonplaceholder.typicode.com/posts
2. Configure it for 10 requests per second for 30 seconds
3. Run the test immediately after creation
4. Generate an enhanced HTML report with stakeholder summary
Step 2: Analyze Results
Analyze the Artillery test results from the JSON file generated in the previous test. Provide detailed performance insights and recommendations for the JSONPlaceholder API performance.
Complete Workflow Prompt:
Create a comprehensive Artillery performance test for https://jsonplaceholder.typicode.com with the following scenarios:
1. GET /posts (retrieve posts)
2. POST /posts (create new post with sample data)
3. GET /posts/1 (retrieve specific post)
4. PUT /posts/1 (update post)
Configure the test for:
- Duration: 10 seconds
- Arrival rate: 5 requests per second
- Include authentication headers if needed
After creating the test:
1. Run the Artillery test with enhanced reporting
2. Analyze the results and provide stakeholder-friendly recommendations
Single Comprehensive Prompt:
Perform a complete performance analysis of the GitHub API health endpoint:
1. Create a simple HTTP GET test for https://api.github.com/zen
2. Configure for 15 requests per second for 15 seconds
3. Run the test with enhanced HTML reporting
4. Analyze the JSON results and provide:
- Performance summary for stakeholders
- Technical recommendations for developers
- Business impact assessment
- Risk level evaluation
Generate both technical and business-friendly insights from the test results.
Advanced Workflow Prompt:
Create and execute a realistic e-commerce API performance test using https://fakestoreapi.com:
Test Scenarios:
1. Browse products: GET /products
2. View product details: GET /products/1
3. Get categories: GET /products/categories
4. Filter by category: GET /products/category/electronics
Configuration:
- Test duration: 10 seconds
- Start with 5 RPS, peak at 15 RPS
- Generate enhanced report with stakeholder summary
After execution:
1. Run the test and generate comprehensive reports
2. Analyze performance from both technical and business perspectives
3. Provide actionable recommendations for production deployment
Basic Performance Test:
@artillery-mcp Create a simple HTTP performance test for https://httpbin.org/get with 8 requests per second for 20 seconds, then run it with enhanced reporting and analyze the results.
API Load Testing:
@artillery-mcp Generate a performance test for https://reqres.in/api/users that tests both GET /api/users and POST /api/users endpoints, run for 30 seconds at 6 RPS, execute the test, and provide stakeholder-friendly analysis.
Health Check Monitoring:
@artillery-mcp Test the performance of https://httpbin.org/status/200 endpoint with 12 requests per second for 15 seconds, generate enhanced HTML report, and analyze for production readiness.
When Tests Fail:
My Artillery test failed with errors. Please:
1. Analyze the error output
2. Suggest configuration changes
3. Create a modified test with better error handling
4. Re-run with conservative settings (2 RPS for 10 seconds)
For Custom Endpoints:
Create a performance test for [YOUR_API_ENDPOINT_HERE]:
- Method: GET/POST (specify your method)
- Requests per second: 5
- Duration: 30 seconds
- Include appropriate headers if needed
- Run with enhanced reporting
- Provide business impact analysis
After using these prompts, you'll get:
artillery-tests/test-name-timestamp.ymlartillery-tests/artillery-results-timestamp.jsonartillery-tests/artillery-report-timestamp.htmlThe Run_Artillery_Test tool now generates comprehensive HTML reports that include both technical analysis and stakeholder-friendly summaries.
Executive Summary Section:
Technical Details Section:
Stakeholder Benefits:
💡 Looking for complete workflow examples? Check out the End-to-End Sample Prompts section above for ready-to-use prompts with public APIs that you can try immediately!
Using the Run_Artillery_Test tool with enhanced reporting:
{
"testFilePath": "./artillery-tests/api-test-20240101-120000.yml",
"generateReport": true,
"reportType": "enhanced"
}
This generates:
{
"testFilePath": "./artillery-tests/api-test-20240101-120000.yml",
"generateReport": true,
"reportType": "simple"
}
Using the Generate_Artillery_Test tool:
{
"templateType": "http-get",
"target": "https://jsonplaceholder.typicode.com",
"endpoint": "/posts",
"duration": 30,
"arrivalRate": 10,
"scenarioName": "Posts API Load Test"
}
Using the Create_Simple_HTTP_Test tool:
{
"targetUrl": "https://api.example.com/health",
"method": "GET",
"duration": 60,
"requestsPerSecond": 15,
"scenarioName": "Health Check Load Test"
}
Using the Run_Artillery_Test tool:
{
"testFilePath": "./artillery-tests/posts-api-load-test-20240101-120000.yml",
"generateReport": true
}
Using the Analyze_Artillery_Test_Results tool:
{
"resultsFilePath": "./artillery-tests/posts-api-load-test-20240101-120000-results.json",
"suggestImprovements": true
}
Using the Create_Custom_Artillery_Test tool:
{
"name": "Complex API Flow Test",
"content": "config:\n target: https://api.example.com\n phases:\n - duration: 60\n arrivalRate: 10\nscenarios:\n - name: Login and Browse\n flow:\n - post:\n url: /auth/login\n json:\n username: testuser\n password: testpass\n - get:\n url: /dashboard"
}
After running tests, your directory structure will look like:
your-project/
├── artillery-tests/
│ ├── api-test-20240101-120000.yml # Generated test file
│ ├── api-test-20240101-120000-results.json # Test results (JSON)
│ └── api-test-20240101-120000-report.html # Test report (HTML)
└── ... (your other files)
./artillery-tests/ directory# Development with auto-restart
npm run dev
# Production build and start
npm run build
npm start
Create_Custom_Artillery_Test with custom YAMLFor complex requirements not covered by the templates, use the Create_Custom_Artillery_Test tool with your complete Artillery configuration.
npm uninstall artillery-performance-mcp-server
MIT
Contributions are welcome! Please feel free to submit a Pull Request.
./artillery-tests/ directoryFAQs
MCP server for performance testing with Artillery.io
We found that @democratize-quality/artillery-performance-mcp-server demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
This episode explores the hard problem of reachability analysis, from static analysis limits to handling dynamic languages and massive dependency trees.
Security News
/Research
Malicious Nx npm versions stole secrets and wallet info using AI CLI tools; Socket’s AI scanner detected the supply chain attack and flagged the malware.
Security News
CISA’s 2025 draft SBOM guidance adds new fields like hashes, licenses, and tool metadata to make software inventories more actionable.