How to use the Gatling MCP server for AI-powered performance testing

Running load tests from your AI coding agent sounds futuristic until you realize it's already possible. The Gatling MCP Server connects your Gatling Enterprise account to Claude Code, Cursor, VS Code, and other MCP-compatible clients. You can deploy tests, query results, and manage infrastructure without leaving your IDE.

This guide covers installation, configuration for each supported client, and how to deploy your first load test using natural language commands.

What Is the Gatling MCP server

The Gatling MCP Server is a local server that runs on your machine and exposes your Gatling Enterprise Edition account to any MCP-compatible AI client. No UI required—you interact entirely through your coding agent.

MCP stands for Model Context Protocol, a standard donated to the Linux Foundation that allows AI coding agents to communicate with external tools and services. Think of it as a shared language between your AI assistant and the software it connects to.

Once the Gatling MCP server is running, your AI agent can query your Gatling Enterprise account and trigger load tests. Results pull directly into your development environment.

Here's what the MCP server provides:

• Local execution: The server runs on your machine, so your credentials stay with you
• Direct connection: Links your Gatling Enterprise account to AI clients like Claude Code, Cursor, or VS Code
• Conversational interface: Ask questions and issue commands in plain English instead of navigating dashboards

Requirements and prerequisites for the Gatling MCP server

Before you start, confirm you have the following:

• Gatling Enterprise Edition account (trial or full)
• API token with appropriate permissions
• MCP-compatible AI client (Claude Code, Cursor, VS Code, or another)
• Node.js
• Git

How the MCP server works

When you type a request into your AI agent like "what test runs do I have from this week?", the MCP server translates it into Gatling Enterprise API calls. It authenticates using your API token, fetches the data, and sends it back to your agent.

The flow breaks down into three steps:

• You ask: Your AI agent receives a natural language command
• Server translates: The MCP server converts your request into Gatling Enterprise API calls
• Results return: The list of matching test runs comes back to your agent, with links to the full reports in the Gatling Enterprise dashboard

Everything happens locally. The MCP server acts as a translator between your AI agent and Gatling Enterprise, surfacing your test runs so you can find and open the one you need.

MCP server vs AI skills

Gatling offers two AI components, and they serve different purposes. The MCP server handles real-time queries and commands like checking infrastructure status, triggering simulations, pulling reports.

AI Skills, on the other hand, are reusable prompt templates that guide your agent through Gatling-specific workflows like writing tests or setting up build tools.

You'll often use both together. The MCP server gives your agent access to your Gatling Enterprise account, while AI Skills teach your agent how to work with Gatling effectively.

MCP server

The MCP server enables querying infrastructure, triggering simulations, and retrieving reports directly from your AI client. It's your live connection to Gatling Enterprise—ask about available load generators, start a test run, or pull historical metrics without opening a browser.

AI skills

AI Skills are prompt templates that teach your agent Gatling-specific patterns. They cover topics like configuration as code (defining test parameters in version-controlled files) and build tool integration (Maven, Gradle, npm, sbt). When your agent encounters a Gatling-related task, these skills provide the context it needs to help you effectively. They guide the AI agent to perform specific Gatling tasks accurately, preventing common LLM mistakes like wrong versions, hallucinating APIs, or incorrect protocol mappings.

Using skills with Claude, Cursor or any compatible coding assistant

Skills work as plain-text instruction files. Your AI assistant picks them up automatically when your request matches the skill's intent, or you can invoke them explicitly.

# Automatic: describe what you want"Convert a JMeter script to Gatling""Bootstrap a new Gatling project in Java with Maven""Build my Gatling project and deploy it to Gatling Enterprise""Generate a package.conf for my simulation""Detect the Gatling project in this directory"

# Explicit: reference the skill directly"Execute the gatling-convert-from-jmeter skill"

Combining skills

Skills are composable. For example, combining gatling-build-tools with gatling-convert-from-jmeter tells the AI to compile the project after each modification, catching errors automatically before you have to run anything manually.

Supported AI coding clients

Any MCP-compatible client works with the Gatling MCP server. The protocol is open, so new clients appear regularly. That said, a few have become particularly popular among developers.

Claude Code

Claude Code offers native MCP support, making it a natural fit for terminal-based workflows. Configuration takes just a few lines in a JSON file, and the integration feels seamless once set up.

Claude Desktop

If you prefer a graphical interface over the terminal, Claude Desktop provides the same MCP capabilities in a desktop application. Same functionality, different presentation.

Cursor

Cursor has emerged as a popular AI-powered IDE with built-in MCP integration. Many developers already use it for code generation, so adding Gatling to the mix feels like a natural extension of existing workflows.

VS Code

VS Code works via MCP extensions available in the marketplace. If you're already comfortable in VS Code, you can add Gatling MCP support without switching to a new environment.

Other MCP-compatible clients

Windsurf and various custom tooling also support MCP. Because the protocol is standardized, with 97 million SDK downloads per month according to Anthropic, any client that implements MCP can connect to the Gatling server.

How to install the Gatling MCP server

Installation takes about five minutes. You'll clone a repository, generate an API token, and add the server to your client's configuration file.

1. Clone the Gatling AI extensions repository

Open your terminal and run:

git clone https://github.com/gatling/gatling-ai-extensions


This repository contains both the MCP server and the AI Skills collection. Once cloned, you'll have everything you need locally.

2. Generate your Gatling Enterprise API token

Log into your Gatling Enterprise account and navigate to your API token settings. Create a new token with permissions for the resources you want your AI agent to access—typically simulations, reports, and infrastructure.

Tip: Store your API token securely. You'll reference it in your client configuration, but avoid committing it to version control or sharing it in plain text.

3. Add the MCP server to your client configuration

Each AI client stores MCP server configurations in a JSON file. You'll add an entry that points to the Gatling MCP server and includes your API token. The exact location of this file varies by client, which we'll cover in the next section.

How to configure the MCP server for each client

Configuration varies slightly by client, though the pattern stays consistent: point to the server, provide your token, and you're ready to go.

Claude Code configuration

Installing the plugin gives you both the skills and the MCP server in one step.

First, configure the marketplace:

/plugin marketplace add gatling/gatling-ai-extensions

Then, install the plugin:

/plugin install gatling@gatling-ai-extensions

Or browse for the plugin via /plugin > Discover. Finally, reload Claude.

Then, add the following to your mcp.json file:

{
  "servers": {
    "gatling": {
      "command": "node",
      "args": ["path/to/gatling-ai-extensions/mcp-server/index.js"],
      "env": { 
        "GATLING_API_TOKEN": "your-api-token-here" 
      }
    }
  }
}

‍


Replace path/to/gatling-ai-extensions with the actual path where you cloned the repository, and substitute your real API token.

Cursor configuration

Cursor stores MCP settings in its own configuration directory. The structure mirrors Claude Code. You specify the command, arguments, and environment variables. Check Cursor's documentation for the exact file path on your operating system.

VS Code configuration

First, install an MCP extension from the VS Code marketplace. Then add the Gatling server to your settings.json file. The extension documentation provides the exact format, which typically follows the same pattern as other clients.

Add the following to your VS Code settings.json or .vscode/mcp.json:

Using NPX:

{
  "servers": {
    "gatling": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@gatling.io/gatling-mcp-server"],
      "env": {
        "GATLING_ENTERPRISE_API_TOKEN": "<your-api-token>"
      }
    }
  }
}

‍

What your AI agent can access

Once connected, your AI agent can query a wide range of Gatling Enterprise resources. Here's what becomes available.

The MCP server exposes the following tools:

Teams and organizations

View team members, roles, and organization structure. Useful when you're trying to understand who has access to specific tests or environments.

Packages and simulations

List available test managed and private packages and simulation configurations. Your agent can help you find the right test to run or check what's already been set up.

Load generators and private locations

Query public and private load generator locations and check their availability. Before launching a large-scale test, you can verify that the infrastructure you want is ready.

Reports and test results

Retrieve historical test reports, metrics, and performance trends. This is often the most valuable capability, getting insights without leaving your IDE or switching to a dashboard.

How to deploy your first load test

With the MCP server running, deploying a load test becomes conversational. Here's how to walk through your first deployment.

1. Open your project in your AI coding client

Make sure your Gatling project is loaded and the MCP server is active. When you first interact with your agent about Gatling, it will confirm the connection is working.

2. Write or generate a Gatling test script

Use your AI agent to help write a basic simulation, or work with an existing script. The agent can suggest improvements based on Gatling's DSL patterns and best practices—especially if you've enabled the AI Skills.

3. Ask your agent to deploy the test to Gatling Enterprise

Try a prompt like: "Deploy my simulation to Gatling Enterprise using the default load generators." The MCP server handles authentication and API calls behind the scenes, so you don't have to construct requests manually.

4. Monitor results in real time (Coming soon)

Your agent can fetch live metrics as the test runs. Ask for key performance testing metrics like throughput, response times, or error rates, all without switching windows or opening a separate dashboard.

{{cta}}

Using Gatling AI skills for production workflows

AI Skills extend what the MCP server can do by providing structured guidance for common tasks. They're especially helpful when you're setting up tests for the first time or integrating Gatling into existing pipelines.

Configuration as Code Skill

Configuration as Code means defining your test parameters—load profiles, thresholds, environments—in version-controlled files rather than a UI. This skill helps your agent generate those definitions automatically, so your test configurations live alongside your application code and go through the same review process.

Build tools skill

This skill covers Maven, Gradle, npm, and sbt integration. Your agent can scaffold build configurations so your Gatling tests run as part of your existing build process. Instead of manually writing plugin configurations, you describe what you want and the skill guides your agent through the setup.

Start deploying load tests from your AI coding agent today

The Gatling MCP server brings load testing into your AI-assisted workflow. Write tests, deploy them, and analyze results, all from your coding agent. No context switching, no manual API calls, no dashboard hopping.

Request a demo to explore how Gatling Enterprise fits into your performance testing strategy.

{{card}}