The BlazeMeter Service Virtualization MCP Server connects AI tools directly to BlazeMeter's Service Virtualization platform. This gives AI agents, assistants, and chatbots the ability to manage complete workflows from creation of transactions to deploying it to the virtual service. All through natural language interactions.

• Service Management: Create and manage services.
• Transaction Management: Create, validate, manage HTTP and Messaging transactions.
• Action Management: Create, read, list, and manage transaction actions (Http calls and Webhooks).
• Asset Management: Upload assets (certificates and keystores).
• Sandbox Management: Attach HTTP transaction and test it.
• Location Management: List available locations.
• Configuration Management: Create and manage configurations for virtual services.
• Virtual Service Management: Create, modify, deploy, stop a virtual service, track its status.
• Messaging Virtual Service Management: Create, deploy, and manage messaging virtual services across IBM MQ, ActiveMQ, and Kafka brokers.
• Recording Management: Capture live broker traffic into recordings and replay them via messaging virtual services.
• Virtual Service Templates Management: Create, modify, create from the virtual service, apply to a virtual service.
• Test Data Management: Create, update, and read TDM datasets for virtual services to drive data-driven transaction matching.

• BlazeMeter API credentials (API Key ID and Secret)
• Compatible MCP host (VS Code, Claude Desktop, Cursor, Windsurf, etc.)
• Docker (only for Docker-based deployment)

Follow the BlazeMeter API Keys guide to obtain your API keys as JSON.

The BlazeMeter MCP Server provides comprehensive access to BlazeMeter's API through the following tools:

What it does: Get information about BlazeMeter account and default settings.

What it does: Manage your BlazeMeter accounts and check permissions.

What it does: Navigate and manage testing workspaces.

What it does: Creates and manages services.

What it does: Creates, validates, and manages http transactions.

What it does: Creates, validates, and manages messaging transactions.

What it does: Creates, reads, and lists actions for a transaction.

What it does: Creates, lists, manages assets.

What it does: Creates, lists, manages configurations.

What it does: Lists available locations.

What it does: Validates HTTP transactions without deploying a virtual service.

What it does: Reads virtual service action tracking details.

What it does: Create, manage, deploy, stop, update your virtual service.

What it does: Create, manage, deploy, stop messaging virtual services. Supports IBM MQ (JMS and Native), ActiveMQ Classic, ActiveMQ Artemis, and Kafka brokers.

Supported protocols and required broker config fields:

What it does: Creates and manages recordings of live broker traffic. Recordings can be attached to messaging virtual services for replay.

What it does: Create, manage virtual service templates.

What it does: Creates and manages TDM (Test Data Manager) datasets that drive data-driven transaction matching. Dataset fields are referenced in transaction DSLs using ${fieldName} syntax.

The MCP server supports enabling or disabling specific tools at startup using the environment variable MCP_ENABLED_TOOLS. If the environment variable is not set or is an empty string, all available tools are automatically enabled.

To enable only certain tools, set the environment variable to a comma-separated list of tool names.

Example: MCP_ENABLED_TOOLS="blazemeter_user,blazemeter_account,virtual_services_virtual_service"

The server emits one trace span per MCP tool call using OpenTelemetry. Tracing is off by default and activates automatically when you set an OTLP endpoint.

Enable tracing — environment variable:

export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
sv-mcp --mcp

Enable tracing — CLI argument (binary / uvx):

sv-mcp --mcp --otel-endpoint http://localhost:4318

The --otel-endpoint flag overrides OTEL_EXPORTER_OTLP_ENDPOINT when both are set.

Passing authentication headers:

# env var (comma-separated key=value pairs)
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer your-token"

# CLI flag (repeatable)
sv-mcp --mcp \
  --otel-endpoint http://your-collector:4318 \
  --otel-headers "Authorization=Bearer your-token" \
  --otel-headers "X-Dataset=sv-mcp"

Disable tracing entirely:

# env var
export OTEL_SDK_DISABLED=true

# CLI flag
sv-mcp --mcp --no-telemetry

Each span includes:

• gen_ai.tool.name — MCP tool name (e.g. virtual_services_http_transaction)
• mcp.tool.action — action dispatched (e.g. create_and_test)
• mcp.client.name / mcp.client.version — MCP client identity from the initialize handshake (when provided)
• error.type — set on failure (auth_failed, not_found, rate_limited, server_error, timeout, tool_error, api_error)

W3C Trace Context propagation: if your MCP client passes traceparent/tracestate in _meta, spans are linked to the parent trace automatically.

SDK availability by deployment:

Docker:

docker run --rm -i \
  -e API_KEY_ID=your_key_id \
  -e API_KEY_SECRET=your_key_secret \
  -e OTEL_EXPORTER_OTLP_ENDPOINT=http://your-collector:4318 \
  sv-mcp

pip:

pip install sv-mcp

uvx:

uvx --from "git+https://github.com/Blazemeter/sv-mcp.git" sv-mcp \
  --otel-endpoint http://your-collector:4318

The server never crashes if the endpoint is unreachable or the SDK is not installed.

uvx installs and runs the package in an isolated environment — no manual setup required.

{
  "mcpServers": {
    "blazemeter-sv": {
      "command": "uvx",
      "args": [
        "--from", "git+https://github.com/Blazemeter/sv-mcp.git",
        "sv-mcp"
      ],
      "env": {
        "API_KEY_PATH": "/path/to/api-key.json"
      }
    }
  }
}

To pin a specific version or branch, change the --from value:

• Tag: git+https://github.com/Blazemeter/sv-mcp.git@v1.0.4
• Branch: git+https://github.com/Blazemeter/sv-mcp.git@main

1. Run main.py with --mcp flag
2. Configure your MCP client with the following settings:

{
  "mcpServers": {
    "virtual services mcp": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "path to your python interpreter /.../venv/bin/python",
      "args": [
        "path to project main.py /.../sv_mcp/main.py",
        "--mcp"
      ],
      "env": {
        "API_KEY_PATH": "path to api key file /.../api-key.json"
      }
    }
  }
}

{
  "id": "your_api_key_id",
  "secret": "your_api_key_secret"
}

Build dokcer image using the following command: docker build . -t vs-mcp:latest

{
  "mcpServers": {
    "Docker BlazeMeter MCP": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "API_KEY_ID=your_api_key_id",
        "-e",
        "API_KEY_SECRET=your_api_key_secret",
        "-e",
        "SOURCE_WORKING_DIRECTORY=/tmp",
        "-e",
        "OTEL_EXPORTER_OTLP_ENDPOINT=http://your-collector:4318",
        "-v",
        "/host/path/to/your/test/files:/tmp",
        "us-docker.pkg.dev/verdant-bulwark-278/sv-mcp/sv-mcp:latest"
      ]
    }
  }
}