Click on "Install 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., "@LoadRunner Cloud MCP Server get summary for test run 16287"
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.
This project provides a Model Context Provider (MCP) server for integrating with LoadRunner Cloud (LRC) APIs. It enables automated, programmatic access to LRC resources and test data, making it easy to build performance engineering workflows, dashboards, and AI integrations.
The LRC-MCP Server exposes a set of tools for interacting with LoadRunner Cloud, including:
Retrieving projects, load tests, scripts, and test runs
Fetching transaction details, summaries, and HTTP responses for test runs
Automating performance data collection and reporting
The server is compatible with any MCP client, such as Claude Desktop or Cursor, and can be extended to support additional LRC APIs as needed.
Related MCP server: JMeter MCP Server (TypeScript Edition)
Node.js (v18+ required, v20+ recommended)
npm (comes with Node.js)
Clone this repository and navigate to the project directory.
Install dependencies:
npm installCopy the example environment file and edit it with your real credentials:
cp .env.example .env
# Then edit .env and fill in your LRC_TENANT_ID, LRC_CLIENT_ID, and LRC_CLIENT_SECRETThe .env.example file provides a template for the required environment variables. You must create a .env file (as above) and supply your actual credentials for the server to function.
Start the MCP server:
node mcpServer.jsYou can also run with Server-Sent Events (SSE) support:
node mcpServer.js --sseThe following tools are available for interacting with LoadRunner Cloud:
get_projects: Retrieve all projects in a tenant.
test_runs_getActiveTestRuns: Get active test runs from LoadRunner Cloud.
test_runs_getTestRunTransactions: List all transaction information in a test run.
test_runs_getTestRunSummary: Get summary for a test run.
test_runs_getHttpResponses: Get HTTP responses for a test run.
projects_getLoadTests: Retrieve load tests for a project.
projects_getLoadTestScripts: Retrieve scripts for a load test in a project.
projects_getLoadTestRuns: Retrieve runs for a load test in a project.
You can call these tools from any MCP-compatible client. Example (JavaScript):
// Get all projects
await get_projects();
// Get load tests for a project
await projects_getLoadTests({ projectId: '10' });
// Get scripts for a load test in a project
await projects_getLoadTestScripts({ projectId: '10', loadTestId: '2159' });
// Get runs for a load test in a project
await projects_getLoadTestRuns({ projectId: '10', loadTestId: '2159' });
// Get HTTP responses for a test run
await test_runs_getHttpResponses({ runId: '16287' });To get the full path to node:
On Unix/Linux/macOS, run:
which nodeOn Windows PowerShell, run:
Get-Command node | Select-Object SourceTo check the node version, run:
node --versionTo get the absolute path to mcpServer.js, run:
On Unix/Linux/macOS:
realpath mcpServer.jsOn Windows PowerShell (from the project directory):
Resolve-Path mcpServer.jsYou can connect your MCP server to any MCP client. Below are instructions for Claude Desktop and Cursor.
Note the full path to node and the mcpServer.js from the previous step.
Open Claude Desktop → Settings → Developers → Edit Config and add a new MCP server:
{
"mcpServers": {
"<server_name>": {
"command": "<absolute/path/to/node>",
"args": ["<absolute/path/to/mcpServer.js>"]
}
}
}Restart Claude Desktop to activate this change. Make sure the new MCP is turned on and has a green circle next to it.
Warning: If you don't supply an absolute path to a node version that is v18+, Claude (and other MCP clients) may fall back to another node version on the system of a previous version. In this case, the fetch API won't be present and tool calls will not work. If that happens, you can a) install a newer version of node and point to it in the command, or b) import node-fetch into each tool as fetch, making sure to also add the node-fetch dependency to your package.json.
Note the full path to node and the mcpServer.js as above.
In Cursor, go to Settings → AI Tools → MCP Servers (or similar MCP integration section).
Add a new MCP server configuration:
{
"command": "<absolute/path/to/node>",
"args": ["<absolute/path/to/mcpServer.js>"]
}Save and enable the server. Ensure it is running and available for tool calls in Cursor.
For production deployments, you can use Docker:
docker build -t lrc-mcp-server .Model Context Provider (MCP) is a protocol for exposing programmatic tools to AI and automation clients. This server implements the MCP protocol for LoadRunner Cloud APIs.
For more information, see the source code and tool documentation.
Get active test runs from LoadRunner Cloud.
| Name | Required | Description | Default |
|---|---|---|---|
| status | No | The status of the test runs (RUNNING, INITIALIZING, CHECKING_STATUS, STOPPING, DELAYED). | |
| projectIds | No | The project IDs to filter the test runs (empty means all). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read operation, the description doesn't specify whether this returns all active runs or is paginated, what format the output takes, or any authentication or rate limit requirements. For a retrieval tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It's appropriately sized and front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 optional parameters, no output schema, no annotations), the description is minimally adequate but incomplete. It states what the tool does but lacks behavioral context (output format, pagination), usage differentiation from siblings, and doesn't compensate for the absence of annotations. A retrieval tool with multiple similar siblings needs more guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters (status and projectIds). The description doesn't add any additional parameter semantics beyond what's in the schema, such as explaining what 'active' means in relation to the status parameter or providing examples. The baseline of 3 is appropriate when the schema does all the parameter documentation work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('active test runs from LoadRunner Cloud'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'test_runs_getRecentTestRuns' or 'test_runs_getTestRunResults', which appear to be related test run retrieval operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools that appear to retrieve test runs (e.g., 'test_runs_getRecentTestRuns', 'test_runs_getTestRunResults'), there's no indication of what makes 'active' test runs different or when this specific tool should be preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve all projects in a tenant.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states 'Retrieve all projects' but doesn't disclose behavioral traits such as pagination, rate limits, authentication needs, or what 'all' entails (e.g., archived projects). This leaves significant gaps for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It's front-loaded with the essential action and resource, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 0 parameters, no output schema, and no annotations, the description is minimally adequate. It covers the basic purpose but lacks details on behavior, output format, or usage context, which are needed for full completeness in a retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it implies a scope ('in a tenant') that aligns with the lack of parameters, justifying a score above baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieve') and resource ('all projects in a tenant'), making the purpose understandable. However, it doesn't distinguish this from potential sibling tools that might also retrieve projects with different scopes or filters, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for usage, or exclusions, leaving the agent with minimal direction beyond the basic purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve runs for a load test in a project from LoadRunner Cloud.
| Name | Required | Description | Default |
|---|---|---|---|
| projectId | Yes | The ID of the project. | |
| loadTestId | Yes | The ID of the load test. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('Retrieve runs') without detailing aspects like whether it's read-only, pagination behavior, rate limits, authentication needs, or what 'runs' entail (e.g., status, metadata). This is inadequate for a tool with potential complexity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple retrieval tool, though it could be slightly more informative without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'runs' include (e.g., data structure, fields) or behavioral traits like error handling. For a retrieval tool in a context with multiple sibling tools, more detail is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting both parameters ('projectId' and 'loadTestId') with their types and purposes. The description adds no additional semantic context beyond what the schema provides, such as format examples or relationships between parameters, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieve runs') and resource ('for a load test in a project from LoadRunner Cloud'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'test_runs_getRecentTestRuns' or 'test_runs_getTestRunResults', which also retrieve test run data, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as how it differs from 'test_runs_getRecentTestRuns' or 'test_runs_getTestRunResults'. There's no mention of prerequisites, context, or exclusions, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve load tests for a project from LoadRunner Cloud.
| Name | Required | Description | Default |
|---|---|---|---|
| projectId | Yes | The ID of the project. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the action is 'Retrieve', implying a read-only operation, but does not disclose behavioral traits such as authentication requirements, rate limits, pagination, or what happens if the project ID is invalid. This is inadequate for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and efficiently conveys the essential information, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of retrieving data with no annotations and no output schema, the description is incomplete. It lacks details on return values (e.g., what load tests include), error handling, or prerequisites, which are crucial for an agent to use the tool effectively in context with siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'projectId' documented as 'The ID of the project.' The description does not add any meaning beyond this, such as format examples or constraints, so it meets the baseline score of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieve') and target resource ('load tests for a project'), making the purpose understandable. However, it does not differentiate from sibling tools like 'projects_getLoadTestRuns' or 'projects_getLoadTestScripts', which appear to retrieve related but different resources, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'projects_getLoadTestRuns' and 'projects_getLoadTestScripts', there is no indication of what distinguishes this tool (e.g., retrieving load tests vs. runs or scripts), leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve scripts for a load test in a project from LoadRunner Cloud.
| Name | Required | Description | Default |
|---|---|---|---|
| projectId | Yes | The ID of the project. | |
| loadTestId | Yes | The ID of the load test. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden but provides minimal behavioral insight. It implies a read-only operation ('Retrieve'), but doesn't disclose permissions, rate limits, pagination, error handling, or output format. This is inadequate for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It avoids redundancy and wastes no words, though it could be slightly more structured (e.g., by hinting at output).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a read-oriented tool, the description is incomplete. It lacks details on what 'scripts' entail (e.g., file types, content), how results are returned, or any behavioral traits, leaving significant gaps for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents both parameters (projectId and loadTestId). The description adds no additional meaning beyond what's in the schema, such as format examples or relationships between parameters, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieve') and the resource ('scripts for a load test in a project'), specifying the source ('from LoadRunner Cloud'). It distinguishes from siblings like 'projects_getLoadTests' (which likely lists tests) or 'test_runs_getTestRunTransactions' (which focuses on transactions), but doesn't explicitly contrast them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid project and load test), exclusions, or comparisons to siblings like 'projects_getLoadTestRuns' or 'test_runs_getHttpResponses', leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get HTTP responses for a test run from LoadRunner Cloud.
| Name | Required | Description | Default |
|---|---|---|---|
| runId | Yes | The ID of the test run. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves HTTP responses but doesn't describe what the responses include (e.g., status codes, headers, body), how they are formatted, pagination, rate limits, or authentication needs. This leaves significant gaps for a tool that likely returns complex data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero waste. It is appropriately sized and front-loaded, directly stating the tool's purpose without unnecessary elaboration, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of retrieving HTTP responses (which could involve detailed data like status codes, headers, and body), the lack of annotations and output schema, and the description's minimal detail, this is incomplete. The agent would struggle to understand the full behavior and output without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'runId' documented as 'The ID of the test run.' The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage without extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get HTTP responses') and resource ('for a test run from LoadRunner Cloud'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'test_runs_getTestRunResults' or 'test_runs_getTestRunTransactions', which might also retrieve test run data but for different aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid runId), exclusions, or comparisons to sibling tools like 'test_runs_getTestRunResults', leaving the agent to infer usage context from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent test runs details for the last month from LoadRunner Cloud. Optionally filter by projectIds.
| Name | Required | Description | Default |
|---|---|---|---|
| projectIds | No | Optional project IDs to filter the usage. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the time scope ('last month') and optional filtering, but it doesn't disclose key behavioral traits such as whether this is a read-only operation, potential rate limits, authentication needs, or what the return format looks like (e.g., list structure, pagination). For a tool with no annotations, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and includes the optional parameter detail. There is no wasted text, and it's appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a simple input schema with full coverage, the description is adequate but has clear gaps. It covers the basic purpose and parameter hint, but lacks details on behavior, return values, and differentiation from siblings. For a read operation with minimal complexity, it's minimally viable but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the single parameter 'projectIds' with its type and optional nature. The description adds marginal value by reiterating the optional filtering, but it doesn't provide additional semantics like format examples or constraints beyond what the schema states. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'recent test runs details for the last month from LoadRunner Cloud', making the purpose specific. However, it doesn't explicitly differentiate from sibling tools like 'get_active_test_runs' or 'projects_getLoadTestRuns', which likely serve similar purposes, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by mentioning 'Optionally filter by projectIds', which suggests when to use the optional parameter, but it doesn't provide explicit guidance on when to choose this tool over alternatives like 'get_active_test_runs' or 'projects_getLoadTestRuns'. No exclusions or detailed context are provided, leaving usage somewhat vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get test run results from LoadRunner Cloud.
| Name | Required | Description | Default |
|---|---|---|---|
| runId | Yes | The ID of the test run. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action ('Get test run results') without detailing aspects like whether this is a read-only operation, if it requires authentication, rate limits, error handling, or the format of returned data. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of retrieving test run results, the lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'results' entail (e.g., performance metrics, logs), how data is structured, or any prerequisites, leaving the agent under-informed for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with 'runId' clearly documented as 'The ID of the test run.' The description adds no additional parameter semantics beyond this, so it meets the baseline of 3 where the schema does the heavy lifting without extra value from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'test run results from LoadRunner Cloud', which specifies what the tool does. However, it doesn't distinguish this tool from sibling tools like 'test_runs_getRecentTestRuns' or 'test_runs_getTestRunTransactions', which might also retrieve test run-related data, leaving some ambiguity about its unique scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'test_runs_getRecentTestRuns' and 'test_runs_getTestRunTransactions', there's no indication of whether this tool is for specific results, all results, or how it differs, leaving the agent to guess based on context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all transaction information in a test run.
| Name | Required | Description | Default |
|---|---|---|---|
| runId | Yes | The ID of the test run. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists transaction information but does not describe key traits such as whether it's read-only, if it requires authentication, potential rate limits, or the format of returned data (e.g., pagination, error handling). For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'List all transaction information in a test run.' It is front-loaded with the core action and resource, with no unnecessary words or redundancy. This makes it easy to parse and understand quickly, earning a high score for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a tool that lists data (implying read operations) and the absence of annotations and output schema, the description is incomplete. It does not explain what 'transaction information' entails, how results are structured, or any behavioral aspects like safety or performance. For a tool with no structured support, more detail is needed to ensure the agent can use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'runId' parameter clearly documented as 'The ID of the test run.' The description does not add any additional meaning beyond this, such as format examples or constraints. Given the high schema coverage, a baseline score of 3 is appropriate, as the schema adequately handles parameter documentation without extra value from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List all transaction information in a test run.' It specifies the verb ('List') and resource ('transaction information in a test run'), making the function understandable. However, it does not explicitly differentiate from sibling tools like 'test_runs_getHttpResponses' or 'test_runs_getTestRunResults,' which may also retrieve related test run data, leaving some ambiguity about uniqueness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It lacks context such as prerequisites (e.g., needing a valid runId), exclusions, or comparisons to sibling tools like 'test_runs_getRecentTestRuns' or 'test_runs_getHttpResponses,' which could serve similar purposes. This absence limits the agent's ability to choose the correct tool in different scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
get_active_test_runsget_projectsprojects_getLoadTestRunsprojects_getLoadTestsprojects_getLoadTestScriptstest_runs_getHttpResponsestest_runs_getRecentTestRunstest_runs_getTestRunResultstest_runs_getTestRunTransactionsMost tools have distinct purposes targeting different resources (projects, test runs, scripts, responses, results, transactions), but 'get_active_test_runs' and 'test_runs_getRecentTestRuns' could cause confusion as both retrieve test runs with temporal filters. Descriptions clarify one gets active runs and the other recent runs, but the overlap exists.
Naming is inconsistent with mixed conventions: some use snake_case (e.g., 'get_active_test_runs'), others use camelCase (e.g., 'projects_getLoadTestRuns'), and verb styles vary (e.g., 'get' vs 'retrieve'). This lack of a predictable pattern makes the set harder to navigate.
With 9 tools, the count is well-scoped for a LoadRunner Cloud server, covering key operations like retrieving projects, tests, runs, scripts, responses, results, and transactions. Each tool appears to serve a specific function without bloat.
The tools provide good read-only coverage for monitoring and retrieving data (projects, tests, runs, scripts, responses, results, transactions), but there are notable gaps in CRUD operations. For a load testing domain, missing tools for creating, updating, or deleting tests/runs limit agent capabilities for full lifecycle management.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Drive OctoPerf load testing from any AI agent: import, edit, validate, run scenarios, read metrics.
Load & browser performance testing — drive MaxoPerf from your AI agent with your API key.
AI-callable tools for API mocking, testing, monitoring, security, and automation.
Direct access to Cypress tests results and accessibility reports in your AI workflow.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/pbandreddy/loadrunner-cloud-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
