JProfiler, the #1 Java profiler
for your AI agentfor Claude Codefor Codexfor Cursorfor OpenCodefor your AI agent

Your AI agent can read your code. With JProfiler, it can see it run.

Run this command in PowerShell:

irm https://www.ej-technologies.com/jprofiler/mcp/install.ps1 | iex

Run this command in your terminal:

curl -fsSL https://www.ej-technologies.com/jprofiler/mcp/install.sh | sh

Requires Node.js to be installed. Select your agent and follow the instructions below.

Run this command in Claude Code:

claude mcp add jprofiler -- npx -y @ej-technologies/jprofiler-mcp@latest

In Claude Desktop, go to Settings → Developer → Edit Config to open your configuration file, then add the following:

{
  "mcpServers": {
    "JProfiler": {
      "command": "npx",
      "args": ["-y", "@ej-technologies/jprofiler-mcp@latest"]
    }
  }
}

Open the Cline extension in your IDE and click the MCP Servers icon. Click Configure MCP Servers to open the settings file, then add the following:

{
  "mcpServers": {
    "JProfiler": {
      "command": "npx",
      "args": ["-y", "@ej-technologies/jprofiler-mcp@latest"]
    }
  }
}

Run this command:

codex mcp add JProfiler -- npx -y @ej-technologies/jprofiler-mcp@latest

In Cursor, go to Settings → Tools & MCPs → Add Custom MCP, then add the following configuration:

{
  "mcpServers": {
    "JProfiler": {
      "command": "npx",
      "args": ["-y", "@ej-technologies/jprofiler-mcp@latest"]
    }
  }
}

Add the following to ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "JProfiler": {
      "command": "npx",
      "args": ["-y", "@ej-technologies/jprofiler-mcp@latest"]
    }
  }
}

Configure in your JetBrains IDE:

Go to Tools → Junie → MCP Settings, then add a new server with the content:

{
  "mcpServers": {
    "JProfiler": {
      "command": "npx",
      "args": ["-y", "@ej-technologies/jprofiler-mcp@latest"]
    }
  }
}

Add the following to ~/.junie/mcp/mcp.json:

{
  "mcpServers": {
    "JProfiler": {
      "command": "npx",
      "args": ["-y", "@ej-technologies/jprofiler-mcp@latest"]
    }
  }
}

Add the following to ~/.config/opencode/opencode.json:

{
  "mcp": {
    "JProfiler": {
      "type": "local",
      "command": ["npx", "-y", "@ej-technologies/jprofiler-mcp@latest"]
    }
  }
}

If you already have JProfiler installed, you can configure the integration directly from the UI.

Open JProfiler, go to Session → AI Agent Integrations, select your agent, and JProfiler will configure it automatically.

Agentic Coding White Paper

Profiling in agentic development workflows: runtime capabilities, measured results and best practices.

Tool and Resource Reference

All tools and resources of the JProfiler MCP server, exactly as an agent sees them. Also available as raw Markdown.

AI Data Handling

What data flows to AI providers when agents use JProfiler, and how enterprise data containment applies.

What your agent can do with JProfiler

Without runtime data, an agent can only guess at performance problems from the source code. With JProfiler, it measures where time and memory are actually spent and verifies that a fix worked.

Find the real hotspot

Source code review often points to the wrong method. Sampling CPU data, call trees and back traces show your agent where time is actually spent.

Analyze heap dumps without a GUI

Agents cannot open Eclipse MAT or a profiler UI. JProfiler's heap analysis offers queryable views over HPROF dumps: biggest objects, retained sizes, paths to GC roots and instance counts.

Find JDBC and JPA patterns that source review misses

A query that looks harmless in the code can be a problem when it is executed 580 times per refresh cycle. Call counts and aggregated executions from the database probes make per-entry queries, N+1 patterns and redundant checks visible.

Catch the occasionally slow call

Some calls are fast on average, but slow once in a hundred runs. Outlier detection finds methods whose maximum deviates strongly from their average, and exceptional-run recording keeps the slowest invocations individually expandable, so your agent can analyze a single slow execution instead of a merged average.

Prove algorithmic complexity with curve fits

Is this method O(n²) in the payload size? Your agent gets measured (input size, time) points with a curve fit, instead of arguing about Big-O from the source code.

Let the agent write its own probes

When the built-in probes do not cover the problem, the agent defines script probes: lightweight instrumentation that is computed per method invocation and pushed to the running JVM, without changing code, builds or deployments of your application.

... and much more

Measure LLM and AI call costs

Context-aware metrics for agentic applications: LLM call latencies, token usage and AI probe events help your agent minimize costs and optimize model performance.

Prove that a fix worked

With before-and-after profiling runs and snapshot comparisons, the agent measures, applies a fix and verifies the result.

Diagnose deadlocks and lock contention

Monitor statistics, contention timelines and locking history with stack traces, lock-order inversion graphs, and monitor dumps from live JVMs for deadlock analysis.

Profile JVMs in Docker and Kubernetes

Containerized JVMs are selected directly, without manual agent setup. Heap dumps and CPU data from inside containers work out of the box.

Analyze JFR recordings from production

Low-overhead JFR snapshots from live systems are analyzed with the full power of JProfiler, ideal for post-mortem investigations.

Take heap, thread and monitor dumps on demand

Point-in-time actions on live JVMs, including virtual thread hierarchies. MBean snapshots and recording control are available as live actions too.

Find allocation hot spots

Allocation recordings with stack traces show where memory pressure comes from, and heap dumps carry per-object allocation sites.

Analyze GC pauses

Individual garbage collections with causes, pause times, phases and heap usage before and after each collection, plus the full GC configuration.

Capture transient states with triggers

Heap spikes and other transient states are recorded automatically: triggers take thread dumps, heap dumps and MBean snapshots when a condition fires.

Agentic development in our blog

JProfiler Makes Heap Dumps Useful to AI Agents

2026-11-04

Making the JProfiler MCP Server Robust for Weaker Models

2026-07-28

How I Doubled jclasslib's Performance with JProfiler MCP

2026-04-24

JProfiler 16.1: AI Agents Can Now Profile Your Java Applications

2026-04-09

Profiling AI: LangChain4j and Spring AI

2026-03-04

JProfiler 16: Profiling Agentic Java Applications

2026-02-27

A filtered list of all AI agent posts can be viewed directly in the blog.

Why is the PDF export slow?

JProfilerquery(performance.hotspots)

FontMapper.mapGlyph   41.2% (self 38.9%)
└─ HashMap.put        32.7%

Find the real hotspot

The Solr container keeps running out of memory

JProfilercreate_heap_dump() → query(heap.biggestObjects)

QueryResponseCache   retained 151 MB
                     62% of the heap

Analyze heap dumps without a GUI

Feed refresh is sluggish. Is the database the problem?

JProfilerquery(performance.hotspots, subsystem = "jdbc")

findExisting(guidHash)   580 calls
for 200 unique entries · 141 ms total

Find JDBC and JPA patterns that source review misses

Why is /api/search occasionally slow?

JProfilerquery(performance.outliers)

SearchService.query   avg 3.1 ms
                      max 243 ms

Catch the occasionally slow call

Is this parser method really quadratic?

JProfilerquery(complexity.methods)

ClassFile.read   t ≈ 4.2 µs · n²
                 R² = 0.98

Prove algorithmic complexity with curve fits

How long does order processing take per order type?

JProfilerprepare_profiling(scriptProbes = […])

script:"Order processing"   recorded
3 payload hot spots available

Let the agent write its own probes

Which LLM calls cost the most tokens?

JProfilerquery(performance.hotspots, subsystem = "ai", metric = "tokens")

summarize (gpt-4o)   12.4k tokens
                     38 calls

Measure LLM and AI call costs

Did my fix actually help?

JProfilerload_snapshot("after.jps", "before.jps")

guidHash   580 → 400 calls
           −47% total time

Prove that a fix worked

Tests hang every few runs. Is there a lock problem?

JProfilerquery(monitor.graph)

orderService.lock → inventory.lock
↔ reverse order taken in restock()

Diagnose deadlocks and lock contention

Profile the JVM in the webshop container

JProfilerlist_jvms("webshop")

2 JVMs found in container "webshop"
ready to attach

Profile JVMs in Docker and Kubernetes

Analyze this JFR recording from last night's outage

JProfilerload_snapshot("order-service.jfr")

JFR snapshot loaded
14 datasets available

Analyze JFR recordings from production

The app hangs under load — what are the threads doing?

JProfilerattached_action("threadDump")

347 threads · 41 virtual
38 parked at OrderQueue.take()

Take heap, thread and monitor dumps on demand

Where does all the memory churn come from?

JProfilerquery(allocation.hotspots)

byte[]   1.2 GB · 68%
└─ JsonParser.read

Find allocation hot spots

Why does the app stutter every few minutes?

JProfilerquery(gc.collections)

G1 young pause   212 ms
cause: humongous allocation

Analyze GC pauses

Capture a heap dump when memory exceeds 85%

JProfilerprepare_profiling(triggers = […])

trigger armed:
heap threshold 85% → heap dump

Capture transient states with triggers

JProfiler, the #1 Java profilerfor your AI agentfor Claude Codefor Codexfor Cursorfor OpenCodefor your AI agent

Agentic Coding White Paper

Tool and Resource Reference

AI Data Handling

What your agent can do with JProfiler

Find the real hotspot

Analyze heap dumps without a GUI

Find JDBC and JPA patterns that source review misses

Catch the occasionally slow call

Prove algorithmic complexity with curve fits

Let the agent write its own probes

... and much more

Agentic development in our blog

JProfiler, the #1 Java profiler
for your AI agentfor Claude Codefor Codexfor Cursorfor OpenCodefor your AI agent