TDA Thread Dump Analyzer MCP
A Java thread dump analyzer with an MCP server: an agent finds deadlocks and stuck threads without reading huge stack logs
- 552 ★ on the repository
- Last commit
- LGPL-2.1
Extended access
Why this level
- Runs a local Java process that reads the log files you point it to
- Production thread dumps hold thread names, stacks and sometimes request data, which flow into the agent's replies
Install
- Works in
Manual install
claude mcp add tda -- java -Djava.awt.headless=true -jar /absolute/path/to/tda.jar --mcpFirst download tda.jar from the repository's Releases page and substitute the real path. Java 11 or newer is needed.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Runs a local Java process that reads the log files you point it to
- Production thread dumps hold thread names, stacks and sometimes request data, which flow into the agent's replies
This is third-party code. Review the repository files before installing.
What it does
TDA is a Java program for analyzing thread dumps that can run windowless as an MCP server. The command `java -Djava.awt.headless=true -jar tda.jar --mcp` starts it in stdio mode, and an agent works through tools without reading a raw log. A production dump can run to hundreds of megabytes, so the skill in the repository forbids the agent from opening such files and routes every query through TDA. Eight tools form a diagnostic chain. parse_log always comes first and loads the file. Then get_summary lists dumps with time, thread count and deadlock count, and check_deadlocks looks for mutual blocking. The find_long_running tool finds threads that stay in one state with one stack across consecutive dumps. The analyze_virtual_threads tool catches virtual threads whose carrier thread is stuck in application code. Three more tools list threads in native methods, show zombie threads with unresolved SMR addresses and reset state before a new file. The project supports Java dumps from 1.4 to 21 and newer, including virtual threads and experimental JSON dumps. Besides MCP the repository holds a Swing desktop app, a VisualVM plugin and a skill for agents. For agents without MCP the skill ships a Python bridge: `tda_client.py analyze` with a log path.
Who it is for. For Java developers and operations engineers who use Claude Code, Codex, Cursor or Junie to diagnose hangs, CPU spikes and thread pool exhaustion from jstack logs.
Good fit when
- A Java service hung and the log holds several `jstack` or `kill -3` dumps that the agent must read without loading them into context whole
- You suspect a deadlock or database connection pool exhaustion and need the thread list and the wait chain
- On Java 21 you hunt carrier thread pinning in virtual threads, where tasks queue up
- You need to compare dumps taken at intervals and spot threads stuck in the same place
- You are investigating a HotSpot zombie thread leak through unresolved SMR addresses
Not a fit when
- You need a CPU profiler or heap dump analysis: the MCP tools parse threads only
- You have a single dump, and finding stuck threads needs several dumps taken at intervals
- The service is not written in Java, for example Go or Python: TDA reads JVM dump formats
- You need to analyze a live JVM straight from the agent: the MCP tools read saved logs only
Example request
Analyze the thread dump in /var/log/app/incident-dump.log with TDA: are there deadlocks, how many threads are blocked and what is going on with virtual threadsMCP
- Transport
- stdio
- Authentication
- not required
Environment variables
TDA_JAR_PATH- Path to tda.jar for the Python bridge when the file sits outside the standard search paths.
Limitations
- Java 11 or newer and the tda.jar file from the Releases page are required. The Python bridge also needs Python 3.
- All MCP tools work on a log whose path you give. For a live JVM use the desktop app and the jconsole and VisualVM plugins.
- For files of hundreds of megabytes raise Java memory, for example with `-Xmx2g` in the launch arguments.
- Support for Java 21 JSON dumps is experimental.
- The macOS installer is unsigned, so the system warns about an unverified developer on first launch.
How to disable. Remove the tda entry from the MCP client config or run `claude mcp remove tda`. You can delete the tda.jar file from disk, and the skill goes away when you delete the tda-thread-dump-analysis folder from the skills directory.
FAQ
How do I connect TDA to Claude Code as an MCP server?
Download tda.jar from the Releases page and run `claude mcp add tda -- java -Djava.awt.headless=true -jar /absolute/path/to/tda.jar --mcp`. The same entry as JSON works in Junie, Cursor and Windsurf, and for Codex it is written as a table in config.toml.
How do I analyze a Java thread dump with an AI agent?
Connect the MCP server, install the skill with `npx skills add https://github.com/irockel/tda` and ask the agent to analyze the file, for example: "Are there deadlocks in this dump?". The tda-thread-dump-analysis skill walks the agent through the diagnostic chain, from loading the file to checking virtual threads.
What is carrier thread pinning and how do I find it?
It is when a virtual thread holds its carrier thread in application code and other virtual threads wait. The analyze_virtual_threads tool lists such threads, and the skill's docs include a reference on thread states, lock graphs and pinning theory.
How do I run TDA on a very large dump?
Add `-Xmx2g` or more to the launch arguments: `java -Djava.awt.headless=true -Xmx2g -jar tda.jar --mcp`. The agent still must not read the file directly, and every query goes through TDA tools.
How do I use TDA in an agent without MCP support?
The skill ships a tda_client.py bridge. Run `python3 .agents/skills/tda-thread-dump-analysis/scripts/tda_client.py analyze /path/to/dump.log`, and add `--json` for machine output. If tda.jar sits outside standard locations, set the TDA_JAR_PATH variable.
Discussion
No questions or reviews yet.
Related
MCP serversMCP Server for WinDbg
MCP Server for WinDbg Crash Analysis
An MCP server that hands the agent the Windows debuggers: crash dump analysis, remote and kernel debugging in natural language
An MCP server that indexes code with tree-sitter and returns individual functions and classes to the agent instead of whole files
An MCP server that gives an agent screenshots, DOM, logs and IPC of a running Tauri v2 app and lets it click through the interface
An MCP server that builds a code graph once and serves the answer to the agent instead of re-reading files
A local code graph with version history: an MCP server that tells the agent who calls a function and what an edit breaks
A local tool to test and debug MCP servers: chat with tools, inspect calls and run evals across clients
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| TDA Thread Dump Analyzer (this entry) | yes | not required | 552 | |
| claude-code-java | no | 761 | skills for Java projects covering code review, Spring Boot and concurrency, without thread dump parsing | |
| Plinth | no | 456 | skills and agents for Java development, including profiling |
README in short
The README announces a major release with an extended MCP server and SMR support, then lists install routes, from a self-contained JAR to a macOS package. The agent section describes two paths, the skill and direct MCP, a tool table and a recommended system prompt. Next come building the project with Maven and a link to an article on dev.to.