JProfiler
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Comma-separated list of tool name patterns to include | |
| max-depth | No | Maximum call tree expansion depth | |
| subsystems | No | Comma-separated list of subsystems to enable |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {} |
| resources | {
"subscribe": false,
"listChanged": false
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| prepare_profilingA | Prepare a profiling session by retrieving a JVM parameter to be added to a Java process call to record performance data with stack traces for the following subsystems: cpu, jdbc, jpa, mongo_db, cassandra, http_server, http_client, ws, jndi, jms, kafka_consumer, rmi, grpc, ai, process. The result is a JSON object containing a 'jvmParameter' to be added (quoted) to the Java process at startup. Add it verbatim and do not create or modify any files; the configuration is already set up for you. If the result contains 'additionalJvmParameters' (discovery of injected custom probes), add each element as a separate VM argument as well. Keep this MCP server running and run the Java process. It waits for the server to connect before application startup. During recording, attached_action can perform live actions. The recording is saved automatically when the JVM terminates, after the optional maximum duration, or when check_status is called with 'stopRecording: true'. Then call check_status to access the data - do not load the saved snapshot file yourself. Saving disconnects from the JVM. Use attach with its PID for another recording if it is still running. |
| load_snapshotA | Load an existing .jps, .hprof, or .jfr file for analysis. You must call check_status to check the loading progress and - after this returns 'data_ready' - retrieve data with the query tool. To compare two performance snapshots, load both in a single call: set filePath to the run to analyze and baselineFilePath to the baseline; the differences are then reported in the hotspots and call trees of that run. |
| attachA | Attach to a running JVM by PID or to a JVM inside a Docker container. Records performance data for the following subsystems: cpu, jdbc, jpa, mongo_db, cassandra, http_server, http_client, ws, jndi, jms, kafka_consumer, rmi, grpc, ai, process until check_status is called with 'stopRecording: true', or allocation data when "recordingConfig": {"recordAllocations": true} is passed. Pass "recordingConfig": {"recordMonitors": true} to additionally record monitor and lock events. You can use list_jvms to discover JVMs. |
| check_statusA | Check the status of a profiling session and discover which subsystems were recorded. Can be used to stop recording. When the data is ready provides information about the recorded subsystems (e.g. cpu, jdbc, http_client). |
| queryA | Query a performance or heap dataset with a jq expression and return the result. The dataset is materialized lazily and cached per session. Each query is independent, there is no current object: builtins take explicit ids bound from earlier results, e.g. .instances[0].id as $id | {value: preview($id), keptAliveBy: pathToRoot($id).paths[0].path | map(.class)} |
| create_heap_dumpA | Dump the heap of a locally running JVM or of a JVM inside a Docker container and load it for analysis. If allocation data is recorded for the JVM, the heap dump includes per-object allocation data. A recording session delivers a single heap dump, for a later dump attach again. You must call check_status to check the loading progress and - after this returns 'data_ready' - retrieve data with the query tool. You can use list_jvms to discover JVMs. |
| attached_actionA | Perform a point-in-time action on the connected JVM: thread and monitor dumps, heap marking and heap dumps, MBean snapshots, and starting or stopping subsystem recording. Requires a recording session started with attach or prepare_profiling. The action names and parameters are the same as for the actions of recordingConfig.triggers. |
| list_jvmsA | List locally running JVMs or JVMs running in a Docker container with their command line and PID. Use the information to call attach or create_heap_dump. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
| advanced-settings | All session settings usable as direct keys of recordingConfig.advanced of the prepare_profiling and attach tools, with types, defaults and explanations |
| probe-embedded-api | API reference of com.jprofiler.api.probe.embedded for embedded custom probes: the probe base classes PayloadProbe and SplitProbe, the measurement entry points Payload and Split and the telemetry annotations. Read this before writing an embedded probe. |
| method-script-api | Script API of recordingConfig.advanced.splitMethods and complexityMethods: the script contract, the available parameters and the ScriptContext state store. Read this before writing a split or complexity script. |
| heap-script-api | Java script API for the filterScript parameter of heap.instances and heap.sizes and the groupScript parameter of the custom_grouping inspection: script signatures, the heap object model and limitations. Read this before writing a heap script. |
| controller-api | API reference of com.jprofiler.api.controller.Controller: the profiled application drives profiling itself - start/stop recordings, save snapshots, heap dumps, heap marks and bookmarks from application code. Read this when the application knows better than the agent when to record. |
| datasets | All datasets of the query tool and the jq builtins for the query expression, with arguments, row formats and examples. Static reference, check_status reports the session-specific catalog with availability flags. |
| custom-probes | Custom probes of the profiled application: what they are, embedded vs injected, when not to write one, build setup, deployment and recording as custom:<fully qualified probe class name> subsystems. Read this before recording or writing a custom probe. |
| probe-injected-api | API reference of com.jprofiler.api.probe.injected for injected custom probes: the @Probe annotation, the interception declarations, the injected parameter annotations and the telemetry annotations. Read this before writing an injected probe. |
| probe-config | All probe attributes usable in recordingConfig.advanced.probeConfig of the prepare_profiling and attach tools, with types, defaults and explanations |
TDQS
Scored across 8 tools
Most tools target distinct stages of the profiling workflow: discovery, session start, attachment, status, heap dump, snapshot loading, and querying. There is some overlap between check_status and attached_action around controlling recording, and between create_heap_dump and attached_action's heap-dump actions, but the descriptions make the intended boundaries reasonably clear.
The set is mostly snake_case, with verb_noun names such as prepare_profiling, load_snapshot, check_status, create_heap_dump, and list_jvms. However, query and attach are bare verbs, and attached_action is an adjective_noun form rather than an imperative verb, so the convention is readable but not fully consistent.
Eight tools is well scoped for a JVM profiling server: each covers a distinct part of the lifecycle from discovering JVMs to recording, loading snapshots, and querying results. There are no obviously redundant tools or missing slots that would suggest the count is off.
The surface covers the full expected workflow: list_jvms for discovery, prepare_profiling and attach for starting sessions, check_status and attached_action for control, create_heap_dump for heap capture, load_snapshot for existing files, and query for analysis. No major lifecycle operation appears to be missing.