octoperf
OctoPerf MCP Drive the OctoPerf load-testing platform from any AI agent.
Community: Submitted by a user or imported; check the owner before granting accessOnlineNo sign-inGlobalFreeCan modify data
What it can do
- Delete Unused Http Servers: [Design] DELETES every HTTP server of an OctoPerf design project that no Virtual User references. SAFE — only unreferenced servers are removed; servers in use by at least o
- Update Project: [Project] Update an OctoPerf design project's editable metadata: name, description and tags. Partial — any parameter left null keeps its existing value. Workspace membership is not cha
- Create Counter Variable: [Design] Create a Counter variable in an OctoPerf design project. Each read returns the next value in [start, end] stepped by `increment`. Useful for generating unique IDs acr
What data it sees
Do you need an account
No: the server works without sign-in
OctoPerf MCP
Drive the OctoPerf load-testing platform from any AI agent.
Import virtual users (HAR, Postman, Playwright, JMX, URLs…), edit and validate them, auto-correlate dynamic parameters, run load scenarios, schedule them, and read back metrics, reports & insights — all over natural language.
Hosted remote server — Streamable HTTP + OAuth 2.1 (PKCE + DCR). No API key, no install. Just point your client at the URL and log in through your browser.
- URL:
https://api.octoperf.com/mcp - Auth: OAuth 2.1 (browser login on
api.octoperf.com) - Tools: ~100 — discovery, VU import/edit, validation, scenario runs, metrics & reports
- Docs: https://api.octoperf.com/doc/mcp/
Works with any MCP client (Claude, Cursor, ChatGPT, Codex, Gemini CLI, Copilot…).
Server tool list (60)
Raw names from tools/list. Only developers need these.
| delete_unused_http_servers | [Design] DELETES every HTTP server of an OctoPerf design project that no Virtual User references. SAFE — only unreferenced servers are removed; servers in use by at least one VU action are kept untouched. Returns the baseUrl of each deleted server so the user can audit the cleanup. |
| update_project | [Project] Update an OctoPerf design project's editable metadata: name, description and tags. Partial — any parameter left null keeps its existing value. Workspace membership is not changed by this tool (a dedicated move endpoint handles that). Returns the updated project's id, workspaceId, name, description and a `url` deep-link to the project page in the OctoPerf web UI. |
| create_counter_variable | [Design] Create a Counter variable in an OctoPerf design project. Each read returns the next value in [start, end] stepped by `increment`. Useful for generating unique IDs across iterations or VUs. Returns the created variable's metadata. |
| stop_bench_result | [Runtime] Stop an OctoPerf bench result that is still running (state in CREATED / PENDING / SCALING / PREPARING / INITIALIZING / RUNNING). DESTRUCTIVE — terminates the load test immediately on the load generators and transitions the state to ABORTED. Already-finished runs (FINISHED / ABORTED / ERROR) are no-ops. Use only after the user has confirmed the abort. Returns the BenchResult listing with the post-stop state. |
| update_http_server | [Design] MODIFIES an HTTP server's configuration in an OctoPerf design project. DESTRUCTIVE — the change applies to every HTTP request action of every Virtual User that references this server. Any field left null is kept unchanged. `ipSpoofing` is intentionally not exposed here; manage it via the OctoPerf GUI. Returns the updated server with authorizations stripped. |
| list_variables | [Design] List the variables (parameterization inputs for Virtual Users) defined in an OctoPerf design project. Returns each variable's id, name, type (ConstantVariable / CounterVariable / RandomVariable / CSVVariable / SecretVariable / ListVariable), description, value summary, usage syntaxes (dollar-brace placeholders) and a `url` deep-link to the variable edit page. SecretVariable values are surfaced encrypted (as the backend returns them). |
| download_bench_result_file | [Analysis] Mint a presigned URL to download one file attached to an OctoPerf benchResult (trace.zip, screenshots, HAR archives, …). Returns a GET URL the LLM or the user can fetch directly, valid for ~5 minutes. The single-use token is consumed on the first GET, so fetch it once. |
| delete_variable | [Design] DELETES a variable from an OctoPerf design project. DESTRUCTIVE — any Virtual User action that references this variable (via `${variableName}`) will be left dangling. Returns the deleted variableId for confirmation. |
| list_http_server_usages | [Design] List the Virtual Users whose HTTP request actions reference a given HTTP server. Read-only. Use before `delete_http_server` or `update_http_server` to surface the blast radius of a change. Returns each impacted VU's id, name, description, tags, timestamps, and a `url` deep-link to its design page. |
| disable_scheduled_job | [Scheduler] Disable a ScheduledJob without deleting it — pauses fire-time execution. The job stays in the project's scheduler, can be re-armed later via `enable_scheduled_job`. Use this to safely stop a recurring cron without losing the configuration. Returns the updated ScheduledJobListing with `enabled=false` and `nextRun` cleared. |
| list_public_docker_providers | [Docker] List the public OctoPerf Cloud Docker providers shared across all workspaces. Use these when `list_docker_providers_by_workspace` returns an empty list. Returns each provider's id, name, type (always PUBLIC), available regions, and enabled flag. The `url` deep-link is empty because public providers are not bound to a specific workspace. Pick one to feed into `validate_virtual_user` (providerId + region). |
| import_webdriver_virtual_user | [Design] Create a WebDriver (browser-driven) Virtual User from a list of URLs. Each entry is a {method, url} pair — `url` is a plain string, e.g. "https://example.com/path". Each URL becomes a navigation step. Returns the VU's id, name, description, tags, timestamps and a `url` deep-link to the Virtual User page in the OctoPerf web UI. |
| get_bench_result | [Runtime] Get an OctoPerf BenchResult in full — id, userId, batchId, scenarioId, designProjectId, resultProjectId, mode (STANDARD / JIRA / MAVEN), regions, sampling interval, `state` (DockerBatchState — CREATED / PENDING / SCALING / PREPARING / INITIALIZING / RUNNING / FINISHED / ABORTED / ERROR; FINISHED/ABORTED/ERROR are terminal) and timestamps. This is the canonical 'result status' lookup. For progress [0.0, 1.0] of a running test prefer `get_bench_status`. For aggregated metrics fetch the report with `get_bench_report` and dispatch to the matching `get_report_*_values` tool. |
| update_bench_report | [Analysis] Update an OctoPerf BenchReport's editable metadata: name, description and tags. Partial — any parameter left null keeps its existing value. The `items` list (polymorphic widgets), `configs` set and `benchResultIds` are NOT changed by this tool; use `patch_bench_report` to restructure the report. Returns the updated report's id, name, description, benchResultIds, tags, lastModified and a `url` deep-link to the analysis page. |
| sanity_check_virtual_user | [Design] Run the OctoPerf design sanity check on a Virtual User. Returns the list of issues found, each with a `type` and a `message`. An empty list means the VU passed all checks. |
| list_docker_providers_by_workspace | [Docker] List the Docker providers a workspace can use to run OctoPerf load generators. Returns each provider's id, name, type (PUBLIC / PRIVATE), available regions, enabled flag, and a `url` deep-link to the provider page in the OctoPerf web UI. Pick one to feed into `validate_virtual_user` (providerId + region). |
| fetch_validation_http_body | [Design] Fetch ONE of the four HTTP entities involved in a failed OctoPerf Virtual User validation run — UNTRUNCATED (full headers + body + timing). Use when the summary returned by `get_validation_failure_detail` is truncated past 8 KB and you need the complete payload. Pick `kind` ∈ {RECORDED_REQUEST, RECORDED_RESPONSE, VALIDATION_REQUEST, VALIDATION_RESPONSE}. Only the matching field (`request` for *_REQUEST, `response` for *_RESPONSE) is populated in the result; the other is empty. |
| get_task_result | [Tasks] Poll the lifecycle of an async OctoPerf task by id. Returns status=PENDING while the task is still running (poll again after 2-3 seconds), status=SUCCESS once it has settled successfully, or status=FAILED with the backend stack trace in `message` if it has failed. Use this after any tool that submits an async task (e.g. `apply_correlations_to_virtual_user`). |
| get_validation_failure_detail | [Design] Fetch the four HTTP entities involved in one failed validation run of an OctoPerf Virtual User action: the recorded request/response (the baseline captured at VU creation) and the validation request/response (what was sent and received during the latest check). Use the actionId and timestamp returned by `get_virtual_user_validation_index`. Response bodies are truncated past 8 KB — call `fetch_validation_http_body` to get the full untruncated entity. Also returns `virtualUserUrl`, a deep-link opening the Virtual User page on the failed action in the OctoPerf web UI. |
| add_correlation_framework_to_project | [Design] Add the rules of a correlation framework preset (SAML, OAuth, .NET, Java, Token, AzureAD, or a custom one) to an OctoPerf design project's rule library. Bulk-creates every rule of the framework into the project, skipping rules that are already present (structural dedupe ignoring id/userId, mirrors the OctoPerf UI behaviour). Returns the rules that were actually created. The rules are not yet wired into any Virtual User — call `apply_correlations_to_virtual_user` next on each affected VU to materialise extractors and injections in its action tree. |
| import_postman_virtual_user | [Design] Mint a presigned URL to import a Postman collection (v2.1 JSON) into an OctoPerf project as a new Virtual User. Returns the URL to POST the collection to directly (bypassing the MCP server for the bytes), valid for ~5 minutes. The single-use token is consumed on the first POST. The direct POST returns a raw VirtualUser JSON object with no UI deep-link — chain into `describe_virtual_user` with the returned `id` to obtain the compact listing and the `url` to the Virtual User page in the OctoPerf web UI. |
| update_virtual_user | [Design] Update an OctoPerf Virtual User's editable metadata: name, description and tags. Partial — any parameter left null keeps its existing value. The action tree (children) is NOT changed by this tool; use `patch_virtual_user` to edit the tree. Returns the updated VU's id, name, description, tags, timestamps and a `url` deep-link to the Virtual User page in the OctoPerf web UI. |
| create_project | [Project] Create a new OctoPerf DESIGN project in a workspace. Projects group Virtual Users, scenarios, variables, correlation rules and files together. Returns the created project's id, workspaceId, name, description and a `url` deep-link to the project page in the OctoPerf web UI. |
| get_scenario_matching_plans | [Runtime] PRE-FLIGHT check: list the subscriptions / plans on the account that can actually host the given scenario. A plan appearing in the result fits the scenario's caps (concurrent users, real-browser users, profile count, duration) and the scenario is launchable as-is. For each plan returns plan name, remaining test count, expiration date, concurrency caps (JMeter + real-browser), max duration, and `parallelRunsSupported` — how many simultaneous instances of THIS scenario the plan could host (typically 1; only relevant when `maxTestsPerRun > 1`). Empty list = no plan covers the scenario; the user must trim the load profile (drop UserProfiles, lower plateau VUs), buy capacity, or renew — call `list_active_subscriptions` to see which cap is binding. Call this BEFORE `run_scenario` to avoid burning credits on a run the plan can't sustain — `run_scenario` will error out at startup if it can't be sized, but the cause is opaque without this preflight. |
| get_report_errors | [Analysis] Download every `BenchError` captured for an `ErrorsReportItem` widget — one entry per failed sample, each with benchResultId, regionId, injectorId, virtualUserId, actionId, timestamp (epoch-ms), errorMessage, connectTime / latency / elapsedTime and the list of `BenchAssertionResult` evaluated on the sample. Scoped by the item's filters (regionId / virtualUserId / actionId / …) and benchResultId; `fromMs`/`toMs` are optional epoch-millis bounds, omit to scan the whole test. Reject non-Errors items. Heavy on a high-error run — paginate the LLM's analysis if the list is long. |
| get_report_top_values | [Analysis] Fetch the values of a `TopReportItem` widget — the top-N actions by some criterion (slowest, most error-prone, highest throughput, …) over a time window. Returns a `TopResult` with `top` (action id → score) and `curves` (action id → time-series leading to the score). `fromMs`/`toMs` are optional epoch-millis bounds; omit to scan the whole test. Reject non-Top items. |
| read_bench_result_file_lines | [Analysis] Read a contiguous range of lines from a file attached to an OctoPerf benchResult — `jmeter.log`, `jmeter-server.log`, JTL traces, attachments, … Works for both real bench runs and Virtual User validation runs. Line numbers are 0-based, `fromLine` is inclusive and `toLine` is exclusive. Defaults read the first 100 lines. Gzipped files are transparently uncompressed server-side. Binary artefacts (zip, png screenshots) return garbage — only call on text files (filenames ending in `.log`, `.jtl`, `.txt`, `.csv`, `.har`, `.json`, or their `.gz` variants). |
| list_workspaces | [Workspace] List OctoPerf workspaces the current user is a member of. Returns each workspace's id, name, description, and a `url` deep-link to the workspace page in the OctoPerf web UI. |
| delete_correlation_rule | [Design] DELETES a correlation rule from an OctoPerf design project. DESTRUCTIVE — Virtual User actions that were correlated via this rule will keep their already-extracted variables, but new runs of `apply_correlations_to_virtual_user` will no longer reinject the value. Returns the deleted correlationRuleId for confirmation. |
| upload_project_file | [Design] Mint a presigned URL to upload a file (typically a CSV used for Virtual User parameterization) to an OctoPerf design project. Returns the URL to POST the file to directly (bypassing the MCP server for the bytes), valid for ~5 minutes. The single-use token is consumed on the first POST. Overwrites any existing file with the same name. |
| create_csv_variable | [Design] Create a CSV variable in an OctoPerf design project. Pulls values row by row from a CSV file previously uploaded via `upload_project_file`. Each column listed in `names` becomes its own variable referenced as ${columnName} at runtime — the wrapper `name` is just a label and is NOT used in the substitution. Returns the created variable's metadata. |
| create_scenario_ramp_up_down | [Runtime] Create a new OctoPerf Scenario with a RAMP-UP-then-RAMP-DOWN load shape: every UserProfile ramps from 0 to `users` over `rampUpSec`, holds at `users` for `holdForSec`, then ramps back down to 0 over `rampDownSec`. Useful for soak tests with a controlled wind-down. Same VU / provider / round-robin semantics as `create_scenario_ramp_up`. Returns the new scenario id and a `url` deep-link. |
| describe_virtual_user | [Design] Project an existing OctoPerf Virtual User into its compact listing form: id, name, description, tags, timestamps and a `url` deep-link to the Virtual User page in the OctoPerf web UI. Use it after a presigned import (e.g. `import_har_virtual_user`, `upload_jmx_virtual_user`) returned a raw VU id and you need the UI link without re-listing the whole project, or whenever you have a VU id but want the lightweight projection rather than the heavy action tree returned by `get_virtual_user`. |
| run_scenario | [Runtime] STARTS a new OctoPerf load test by running the given scenario. This consumes subscription credits and spins up load generators. Returns the benchReportId, the benchResultIds that can be polled with get_bench_status, and a `url` deep-link to the live bench report page in the OctoPerf web UI. Pre-flight with `get_scenario_matching_plans` first: an empty result means no plan can host the scenario; a non-empty result confirms the run will start as configured. |
| get_report_textual_monitors | [Analysis] Fetch every `TextualCounterValue` captured under a `TextualMonitorReportItem` widget — string-valued samples emitted by custom monitors (versions of upstream services, feature flag state at fire time, free-form tags, etc.). Returns one entry per sample with monitorConnectionId, counter name, value, and timestamp. Reject other item types. |
| delete_scheduled_job | [Scheduler] DESTRUCTIVE — permanently delete a ScheduledJob. Past runs the job already fired stay in the bench history; only the schedule entry is dropped. For a reversible pause prefer `disable_scheduled_job`. Use only after the user has confirmed. |
| create_constant_variable | [Design] Create a Constant variable in an OctoPerf design project. The same `value` is returned every time the variable is read at runtime. Useful for environment-specific tokens, hosts, URLs and any other static parameterization input. Returns the created variable's metadata. |
| fetch_bench_error_http | [Analysis] Download the HTTP request AND response that produced one specific `BenchError` — given the `benchResultId`, the `actionId` of the failing sampler, and the error's `timestamp` (epoch-ms). Use after `get_report_errors` returned the per-sample error list so the LLM can drill into the actual payload that failed (full headers, body, status code, timings). Returns `(request, response)` together in a single call. The `actionId` is base64-url-encoded on the wire; pass it verbatim as it appears on the `BenchError` — the tool handles the encoding. |
| create_trend_report_by_tags | [Analysis] Create a TREND bench report seeded from a reference benchResult plus a TrendReportTagsSelector — the backend pulls other benchResults from the same project that carry ALL the given tags and plots them on the trend axis. Mirrors the OctoPerf UI's trend creation flow (POST default-report then PUT with a TrendReportConfig). Returns the new report's id, name, description, benchResultIds (just the reference at create-time; the rest is materialised by the backend on each read), tags, lastModified and a `url` deep-link to the analysis page. |
| schedule_scenario_once | [Scheduler] Schedule an OctoPerf Scenario to run ONCE at a specific date/time. Creates a ScheduledJob with a SimpleScheduledTrigger and an ExecuteScenario task. The scheduled run will consume credits at fire time (same cost as a manual `run_scenario`). `runAt` is an ISO-8601 datetime (e.g. `2026-06-15T03:00:00Z`); UTC unless an offset is supplied. The job is `enabled=true` by default — pass `enabled=false` to register a paused job. Returns the new ScheduledJob id, scenarioId, name, triggerDescription (the ISO datetime), enabled flag, nextRun, and a `url` deep-link to the project scheduler page. |
| delete_http_server | [Design] DELETES an HTTP server from an OctoPerf design project. DESTRUCTIVE — every HTTP request action of any Virtual User that references this server will be left dangling. The tool first calls the usage endpoint to fetch the IDs of the impacted Virtual Users, then issues the DELETE, and returns the impacted VU IDs. |
| list_virtual_users | [Design] List the Virtual Users that belong to an OctoPerf design project. Returns each VU's id, name, description, tags, timestamps, and a `url` deep-link to the Virtual User page in the OctoPerf web UI. |
| create_secret_variable | [Design] Create a Secret variable in an OctoPerf design project. The plaintext `value` is sent over the authenticated HTTPS channel and persisted ENCRYPTED at rest; `list_variables` returns the ciphertext only, never the plaintext. Use for passwords, API tokens or other sensitive parameterization inputs. Returns the created variable's listing. |
| get_report_line_chart_values | [Analysis] Fetch the time-series points of a `LineChartReportItem` or `PercentilesChartReportItem` widget — one series per metric/dimension configured on the item. Returns `List<List<GraphPoint>>` (one inner list per series, each `GraphPoint` is `(x=epoch-ms, y=value)`). Time-series can be hundreds of points; prefer `get_report_table_values` for action-level summaries when you don't need the temporal shape. `fromMs`/`toMs` are optional epoch-millis bounds; omit to scan the whole test. Reject other chart types (use `get_report_stacked_chart_values` or `get_report_area_range_values`). |
| download_project_file | [Design] Mint a presigned URL to download a file (typically a CSV used for Virtual User parameterization) from an OctoPerf design project. Returns a GET URL the LLM or the user can fetch directly (bypassing the MCP server for the bytes), valid for ~5 minutes. The single-use token is consumed on the first GET, so fetch it once. |
| delete_project_file | [Design] DELETES a file from an OctoPerf design project. DESTRUCTIVE — any Virtual User action that reads from this file (CSV iterators, file body sources) will be left dangling. Returns the deleted filename for confirmation. |
| create_scenario_stairs | [Runtime] Create a new OctoPerf Scenario with an ASCENDING STAIRS load shape: every UserProfile ramps from 0 to `users` in `stepCount` discrete steps over `rampUpSec` total (each step adds `users/stepCount` users and waits `rampUpSec/stepCount` before the next), then plateaus at `users` for `holdForSec`. Useful for capacity-finding tests where you want to observe the SUT's behaviour at each step. Same VU / provider / round-robin semantics as `create_scenario_ramp_up`. Returns the new scenario id and a `url` deep-link. |
| schedule_scenario_cron | [Scheduler] Schedule an OctoPerf Scenario to run on a recurring CRON expression. Creates a ScheduledJob with a CronScheduledTrigger and an ExecuteScenario task. **Every fire consumes credits — a daily cron drains the subscription daily until disabled or deleted.** `expression` is a **Unix-style 5-field cron expression** (minute hour day-of-month month day-of-week — NO seconds field, NOT Quartz format) evaluated in **UTC** by the server. Examples: `0 22 * * *` = every day at 22:00 UTC (= midnight Paris in CEST / 23:00 in CET); `0 9 * * 1-5` = every weekday at 09:00 UTC; `30 14 1 * *` = 1st of every month at 14:30 UTC. Convert the user's local time to UTC explicitly, accounting for DST when relevant. The job is `enabled=true` by default — pass `enabled=false` to register a paused job. Returns the new ScheduledJob id, scenarioId, name, triggerDescription (the cron expression), enabled flag, nextRun (when known), and a `url` deep-link to the project scheduler page. |
| patch_virtual_user | [Design] Apply an RFC 6902 JSON Patch to an OctoPerf Virtual User's full entity (metadata + recursive `children` action tree). The patch is a JSON string holding an array of operations `[{"op":"add|remove|replace|move|copy|test", "path":"/json/pointer", "value":<json>}, ...]`. Paths use RFC 6901 JSON Pointer (`/children/0/url`, `/name`, …). Polymorphic nodes (actions, extractors, assertions, …) must keep their `@type` discriminator; consult `octoperf://schema/vu` for the per-subtype required fields (also served as JSON at `/mcp/public/schema/vu.json` on this server's origin for clients that can't read MCP resources). The server fetches the current VU, applies the patch on its JSON representation, re-deserializes via Jackson (round-trip validation — invalid schema is rejected) and persists. Returns the updated VirtualUser. Use `get_virtual_user` first to read the current tree and compute precise paths. |
| delete_virtual_user | [Design] Delete an OctoPerf Virtual User by id. DESTRUCTIVE — drops the entire action tree, all attached extractors, assertions and recorded responses. Validation history is preserved separately by benchResultId but the VU itself is gone. Use only after the user has confirmed the deletion. |
| get_report_summary_values | [Analysis] Fetch the aggregated metric values of a `SummaryReportItem` or `BarChartReportItem` widget — both are `MultiMetricReportItem` shapes (a list of `ReportItemMetric`, each with a `MetricId` + filters + benchResultId). Returns `List<Double>` aligned with the item's `metrics` order (zip by index against `item.metrics[i].id` to label). `fromMs`/`toMs` are optional epoch-millis bounds; omit to scan the whole test. Reject other item types — use `get_report_table_values` for tables, `get_report_top_values` for top-N, etc. |
| get_virtual_user_validation | [Runtime] Get the latest functional validation for an OctoPerf Virtual User. Returns the benchResultId, its state, and a `finished` flag (true once the bench reaches FINISHED, ABORTED or ERROR). Empty if no validation has ever been run for this VU. |
| get_report_threshold_alarms | [Analysis] Fetch every `ThresholdAlarm` raised against a `ThresholdAlarmReportItem` widget — one entry per breach with id, monitorConnectionId, severity (INFO / WARN / ERROR / FATAL), thresholdName, thresholdValue, observed value, and timestamp. Use when a `ThresholdAlarmReportItem` fired during a run (typically surfaced in `get_report_insights` under the `THRESHOLD_ALARM` id) and you want to enumerate the actual breaches. `fromMs`/`toMs` are optional epoch-millis bounds; omit to scan the whole test. |
| create_trend_report_by_name | [Analysis] Create a TREND bench report seeded from a reference benchResult plus a TrendReportNameSelector — the backend pulls other benchResults from the same project whose scenario name matches the `search` string under the chosen `searchType` (EQUALS / EQUALS_IGNORECASE / CONTAINS / CONTAINS_IGNORECASE / STARTS_WITH / ENDS_WITH). Returns the new report's id, name, description, benchResultIds, tags, lastModified and a `url` deep-link to the analysis page. |
| patch_scenario | [Runtime] Apply an RFC 6902 JSON Patch to an OctoPerf Scenario's full entity (metadata + the `userProfiles` list with their polymorphic load shapes and engine settings). The patch is a JSON string holding an array of operations `[{"op":"add|remove|replace|move|copy|test", "path":"/json/pointer", "value":<json>}, ...]`. Paths use RFC 6901 JSON Pointer (`/userProfiles/0/load/users`, `/name`, …). Polymorphic nodes (UserProfileLoad, UserProfileEngine, …) must keep their `@type` discriminator; consult `octoperf://schema/scenario` for the per-subtype required fields (also served as JSON at `/mcp/public/schema/scenario.json` on this server's origin for clients that can't read MCP resources). The server fetches the current scenario, applies the patch on its JSON representation, re-deserializes via Jackson (round-trip validation — invalid schema is rejected) and persists. Returns the updated Scenario. Use `get_scenario` first to read the current shape and compute precise paths. |
| get_bench_report | [Analysis] Download an OctoPerf bench report in full — id, projectId, name, description, benchResultIds, tags, timestamps, the polymorphic `items` list (every widget of the report: SummaryReportItem, StatisticTableReportItem, StatisticTreeReportItem, TopReportItem, LineChartReportItem, PercentilesChartReportItem, BarChartReportItem, PieChartReportItem, StackedChartReportItem, AreaRangeChartReportItem, ErrorsReportItem, TextReportItem, SynopsisReportItem, SLAThresholdReportItem, InsightsReportItem, …) and the `configs` set (per-benchResult colour/threshold settings). Each item carries its `@type` discriminator + the metric ids / filters / dimensions / thresholds the LLM needs to interpret the widget. For a one-line overview prefer `list_bench_reports_by_project`. Required upstream of every `get_report_*_values` tool — pick the itemId from the returned items list. |
| list_project_files | [Design] List the files attached to an OctoPerf design project (typically CSV files used for Virtual User parameterization). Returns each file's name, size in bytes, last-modified timestamp, and a `url` deep-link to the project's Files page in the OctoPerf web UI. |
| create_trend_report_by_creation_date | [Analysis] Create a TREND bench report seeded from a reference benchResult plus a TrendReportCreationDateSelector — the backend pulls other benchResults from the same project created within the given date range. Pass at least one of `fromMs` / `toMs` (epoch milliseconds, UTC). Open-ended ranges are supported: omit `fromMs` for "up to toMs", omit `toMs` for "from fromMs onwards". Returns the new report's id, name, description, benchResultIds, tags, lastModified and a `url` deep-link to the analysis page. |
| backup_virtual_user | [Design] Create a safety backup of an OctoPerf Virtual User before a hard-to-reverse change (auto-correlation, large action-tree edits). Duplicates the VU in the same project — the full action tree is copied, recorded request/response bodies are not — and tags the copy `backup` (plus an optional `label` tag) so it is easy to find and restore. Non-destructive: the original VU is untouched. OctoPerf has no built-in VU versioning, so run this BEFORE applying correlation rules or editing the tree. Returns the backup copy's id, name, tags, timestamps and a `url` deep-link to it in the OctoPerf web UI. |
| create_scenario_ramp_up | [Runtime] Create a new OctoPerf Scenario with a RAMP-UP load shape: every UserProfile linearly ramps from 0 to `users` virtual users over `rampUpSec`, then stays at `users` for `holdForSec`. `rampUpSec=0` collapses to an instant constant load. Each Virtual User in `virtualUserIds` becomes one UserProfile bound to the same `providerId` and one of the `locations` (round-robin VU[i] -> locations[i % locations.size()]). Engine defaulted from each VU's `type` (JMETER → JmeterUserProfileEngine, WEB_DRIVER → SeleniumUserProfileEngine, PLAYWRIGHT → PlaywrightUserProfileEngine). For richer load shapes use `create_scenario_ramp_up_down` (ramp + plateau + ramp-down) or `create_scenario_stairs` (ascending stairs). Returns the new scenario id and a `url` deep-link. |