Click on "Deploy 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., "@mcp-tldr show the project tree"
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.
MCP server that exposes https://github.com/parcadei/llm-tldr code analysis tools to Claude Code (or any MCP client).
Python 3.11+
tldr CLI installed and in your PATH (install instructions)
Related MCP server: solograph
git clone https://github.com/YOUR_USER/mcp-tldr.git
cd mcp-tldr
python3 -m venv .venv
.venv/bin/pip install -e .Add this to your ~/.claude.json under mcpServers:
{
"mcpServers": {
"tldr": {
"type": "stdio",
"command": "/absolute/path/to/mcp-tldr/.venv/bin/python",
"args": ["server.py"],
"cwd": "/absolute/path/to/mcp-tldr"
}
}
}Replace /absolute/path/to/mcp-tldr with the actual path where you cloned the repo.
Alternatively, if tldr is not in your PATH, set the TLDR_BIN environment variable:
{
"tldr": {
"type": "stdio",
"command": "/absolute/path/to/mcp-tldr/.venv/bin/python",
"args": ["server.py"],
"cwd": "/absolute/path/to/mcp-tldr",
"env": {
"TLDR_BIN": "/path/to/tldr"
}
}
}Tool | Description |
| File tree of a project |
| Code structure (classes, functions, imports) |
| LLM-ready context for a function/class |
| Pattern search across files |
| Find all callers of a function |
| Cross-file call graph |
| Natural language code search |
| Detect architectural layers |
| Pre-build cache for faster queries |
| Full file analysis (classes, functions, methods) |
| Control flow graph for a function |
| Data flow graph for a function |
| Program slice (what affects line X) |
| Find unreachable/dead code |
| Parse imports from a file |
| Find all files importing a module |
| Find tests affected by changes |
| Type-check and lint diagnostics |
After setup, restart Claude Code. The tools will be available automatically. Example prompts:
"Use tldr_tree to show the structure of this project"
"Use tldr_context to explain the handleAuth function"
"Use tldr_impact to see what calls processPayment"
Detect architectural layers from call patterns. Shows high-level architecture of the project.
Inputs: path (required).
Build cross-file call graph starting from a function.
Inputs: path (required), symbol (required).
Control flow graph for a function. Shows branches, loops, and execution paths.
Inputs: file (required), function (required), lang.
Find tests affected by changed files. Use before committing to know what to test.
Inputs: git, lang, depth, files, +1 more.
Get LLM-ready context for a function/class. Use INSTEAD of reading large files. Returns only relevant code.
Inputs: symbol (required), project (required).
Find unreachable (dead) code in a project. Useful for cleanup and refactoring.
Inputs: path (required), lang, entry.
Data flow graph for a function. Shows how data moves through variables and expressions.
Inputs: file (required), function (required), lang.
Get type-check and lint diagnostics for a file or project. Use to find errors without running the code.
Inputs: target (required), lang, no_lint, project.
Extract full file analysis (classes, functions, methods, imports). Use to deeply understand a single file.
Inputs: file (required), class_filter, method_filter, function_filter.
Find all callers of a function (reverse call graph). Use to understand what breaks if you change a function.
Inputs: path (required), symbol (required).
Find all files that import a module (reverse import lookup). Use to understand module usage across the project.
Inputs: path (required), module (required), lang.
Parse imports from a source file. Shows all dependencies of a file.
Inputs: file (required), lang.
Search files for a pattern. Faster than grep for structural searches.
Inputs: path (required), pattern (required).
Semantic code search using natural language. Use for conceptual searches like 'authentication logic' or 'payment handling'.
Inputs: path (required), query (required).
Program slice: find all lines that affect a specific line. Use to understand what influences a value or statement.
Inputs: file (required), line (required), function (required), var, +1 more.
Show code structure (classes, functions, imports) for a project. Use instead of reading files to understand structure.
Inputs: path (required), lang.
Show file tree of a project directory. Use instead of ls/find.
Inputs: path (required).
Pre-build call graph cache for faster queries. Run once per project before using other tldr tools.
Inputs: path (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 18 tools
Each tool has a clearly distinct and well-defined purpose, from architecture detection to semantic search. There is no overlap or ambiguity; even related tools like tldr_calls and tldr_impact are differentiated by directionality.
All tools follow a consistent pattern: the prefix 'tldr_' followed by a snake_case name (e.g., tldr_change_impact). The naming convention is uniform and predictable.
With 18 tools, the server covers a broad range of static analysis features without being overwhelming. Each tool serves a specific purpose, and the count is well-suited for a comprehensive code understanding toolset.
The tool set is remarkably thorough, covering file tree, structure, imports, call graphs, control and data flow, diagnostics, search, dead code, and more. There are no obvious gaps for the domain of code analysis and comprehension.
Repository knowledge graph MCP server for codebase understanding and debugging.
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
