Scantool - File Scanner MCP
It is an MCP server that gives coding agents a structural map of codebases and documents—classes, functions, headings, callers, diffs—so they read only what is relevant.
Preview a repository for orientation: entry points, hot functions, central files, language mix (
preview_directory).Scan files, directories, or raw content into skeletons with line numbers, and focus on a single function/class/heading (
scan_file,scan_directory,scan_file_content,list_directories).Search text or structure names with enclosing context and links to definitions (
search_structures).Get a structural diff between refs, branches, or the working tree: added, changed, renamed, removed functions; optional review hints (
scan_diff).Inspect a package's public API surface and API changes between versions (
surface).Analyze branch overlap: same structures touched, independently introduced names, and a merge-order hint (
overlap).Find actual call sites of a function or files that import a given file (
callers).Follow one structure through commits: history, renames, and evolution (
history).Translate a
path:lineorpath::namefrom one ref to another (resolve).Detect functions that break call patterns their siblings follow, as a review hint (
find_divergence).It also installs a shell CLI (
sct) with the same capabilities, and works on code plus Markdown, SQL, configs, and images.
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., "@Scantool - File Scanner MCP preview_directory . depth=normal"
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.
Scantool: give your coding agent a map of the codebase
Claude Code, Cursor and VS Code agents find a function by reading whole files. Scantool gives them the structure instead: every class, function, caller and heading with its line numbers, in one call, so the agent reads only what it needs. It works on code and on documents, and it needs no index, no API keys and no setup beyond one command.
Under the hood: a tree-sitter parser for 20+ languages, exposed as an MCP
server and as sct, a shell command the agent runs itself.
Measured on real agent episodes (2026-06-10 and 2026-06-11, Haiku subagents, same tasks in both arms):
"Where is the cache invalidated?" scantool 378 tokens / 1 call
grep 9,370 tokens / 4 calls -> 25x less
pytest skipif-caching bug scantool solved in 3 calls
grep gave up after 13,450 tokens
Read tokens per episode, same with focus 13,523
fact coverage in both arms without 54,337 -> 75% lessAcross 22 episodes the scantool agents answered with 88% fact coverage against
73% for a grep-only agent: better-anchored answers, fewer wrong files. Grep
still wins plain literal lookups and top-level overviews, by 1.4x and 1.6x.
Both axes are measured and the losses are reported in
experiments/benchmark/.
What you use it for
Each of these is one command in the agent's shell, or the matching MCP tool.
Where is X handled in this codebase?
sct search . "cache invalidat"Every hit arrives with the function or class it sits in, the line range, and leads to the definitions it calls. The agent does not open the file to find out what the match belongs to. This is the case measured at 378 tokens against 9,370 for grep.
Get oriented in an unfamiliar repo before changing it
sct .Language mix, entry points, the most-called functions and the central files, in 3 to 5k tokens. What it printed on scantool's own source, trimmed:
━━━ ENTRY POINTS ━━━
server.py:main() @1658
cli.py:main() @562
languages/__init__.py:__all__ (13 items)
━━━ core: CORE FILES (by centrality; used by = files that import it, resolved statically) ━━━
languages/models.py: imports 0, used by 33 files
class StructureNode [called by 178]Read one function without guessing line ranges
sct focus src/scantool/capabilities.py capability_of_toolsrc/scantool/capabilities.py::capability_of_tool (270-274)
capabilities.py (1-333)
- module docstring @1 # FILE: capabilities.py
- import statements @30
- Capability @34
@dataclass(frozen=True)
- CAPABILITIES = (Capability(command='', usage=('sct <dir> [--…',), short='o… @45
- capability (command: str) -> Capability @263
- capability_of_tool (tool: str) -> Capability @270
270 | def capability_of_tool(tool: str) -> Capability:
271 | for entry in CAPABILITIES:The node comes verbatim with line numbers, the rest of the file as a one-level outline, so the agent sees where it sits. In the M2c episodes this cut read tokens by 75% at unchanged fact coverage.
What did this branch change, structurally?
sct diff mainPer file: + added, ~ changed (signature, value or body), = renamed
(paired by identical body), - removed, each with the caller count among the
changed functions. Three functions with the same signature change fold into
one row. It replaces reading a full git diff to answer "what changed".
Who calls this function?
sct callers condense_excerpt --dir src/scantoolActual call sites with their enclosing function and path:line, definitions
first. Mentions in comments, docstrings and strings are not calls and never
appear.
sct callers src/scantool/code_map.pyGiven a file, the files that import it, each with the import line: the
number the preview prints as used by N files, computed from the same
statically resolved import graph.
Will these branches collide when merged?
sct overlap main feat/a feat/bStructures two or more branches touch, names two branches introduced independently, and a merge-order hint. Each branch is compared at its own merge-base.
Did the public API change?
sct surface src/scantool --against v0.25.0Every exported name with its signature and where it is defined after re-exports, and the diff of that surface between two refs.
Is a changed function out of step with its siblings?
sct divergence <dir>, and the same section inside sct diff --review,
lists functions that break a call pattern their peers follow: callers of X
also call Y, this one does not. It is a place to look, never a verdict. On a
consistent codebase it prints nothing.
Find a section in a long Markdown, SQL or config file
sct focus docs/notes.md "Quick Start"
sct scan schema.sql --depth quickHeadings, tables, views, keys and cells are nodes with line ranges, addressed the same way as functions. Code-only tools stop at the source files; a project's documentation, schema and configuration are the same kind of structure here.
Make Claude Code use fewer tokens on a large codebase
Install once, and the agent gets search_structures, scan_file with
focus= and scan_diff as MCP tools, plus sct in its shell. The tool
descriptions tell it when to reach for each, and the numbers at the top of
this page are what that saved in measured episodes.
When grep is the better tool
Literal lookups of a known string, and overviews whose answer sits in the top-level files. In the M2 tasks grep won those by 1.4x and 1.6x. Scantool wins when the question is about a concept or a structure, because the answer needs the enclosing context and grep has to open files to get it.
Related MCP server: MCP Codebase Symbols Server
Install
Scantool runs through uv. Install uv first; without it the server fails silently to start.
curl -LsSf https://astral.sh/uv/install.sh | sh # macOS, Linux, WSLThen, in Claude Code:
claude mcp add --scope user scantool -- uvx scantoolRestart Claude Code. Every other client takes the same entry in its own config file:
{
"mcpServers": {
"scantool": {
"command": "uvx",
"args": ["scantool"]
}
}
}Client | Config file |
Claude Desktop (macOS) |
|
Cursor |
|
Windsurf |
|
VS Code (Copilot agent mode) |
|
Cline | MCP Servers panel, or |
Your team |
|
Windows, install from source, the HTTP transport and troubleshooting are in docs/install.md.
Every install has one side effect: when the server starts it also writes
sct into uv's tool bin directory, so the agent has the same reader in its
shell. SCANTOOL_NO_CLI=1 opts out. Details in docs/sct.md.
sct in the shell
Agents read most code through their shell, not through MCP tools. sct is
the same reader as a shell command, under the same interpreter as the server:
sct <dir> [--part ID] [--lines N]
sct scan <path>... [--ref REF] [--budget N] [--depth quick|normal|deep] [--lines N]
sct scan - [...] paths from stdin, one per line
sct scan - --as <path> [...] stdin content scanned as <path>
sct focus <path> <name|heading> [--ref REF] [--body] [--lines N] [--json]
sct focus <path>::<name>[@REF] the address form, one argument
sct focus - --as <path> <name> stdin content, one node
sct search <dir> <pattern> [--ref REF] [--names] [-i] [--type TYPE] [--limit N] [--offset N] [--lines N]
sct search <dir> <pattern> --names --decorator RE one row per structure, decorators on the row
sct diff <refA> [<refB>] [--repo DIR] [--path PATH] [--no-merge-base] [--review]
sct surface <package-dir> [--ref REF] [--against REF] [--part ID]
sct overlap <base> <branch>... [--repo DIR] [--path P] [--kind K] [--part ID]
sct callers <name|file> [--dir DIR] [--ref REF]
sct resolve <path:line | path::name> --from REF --to REF [--repo DIR]
sct divergence <dir> [--max-findings N]
sct history <path::name | path:line> [--ref REF] [--repo DIR]
sct <command> --help the full help; --json on every command but <dir> and divergence, --ascii anywhereOutput is valid input. A focus answer opens with the node's address,
path::Qualified.name (a-b), and that address is one argument that reads it
again. --ref reads at any git ref without a checkout. When a budget cut
something, one trailer names the call that recovers the most. Each command's
full description is in sct <command> --help and in docs/sct.md.
How it works
Scantool parses files on demand with tree-sitter and keeps no index. A parsed file is cached by its git blob id, so the same bytes at a ref, on stdin or in the next process do not parse twice.
Functions are shown as condensed skeletons: control flow, calls and returns
kept, trivial statements folded to …. The most salient functions get full
depth, the rest a two-level outline. Both the tiers and the defaults are the
measured optimum for fact coverage per token
(experiments/condensation/,
experiments/entropy_metrics/); parameters
are escape hatches, not style choices.
Nothing is dropped silently. Every answer opens with a coverage line that counts files seen, structures shown, and what was excluded and why:
<63 files seen, 1501 structures shown, 3 excluded (__pycache__/), 1 unsupported (.typed)>The output format is the API. Agents consume it directly, so format drift is
behaviour drift in the consumer. The default format is frozen by golden tests
(tests/golden/), in tree and JSON form, and a change to it is a deliberate
snapshot update. The contract in full is in
CONTRIBUTING.md.
Compared with
The three largest code-exploration MCP servers take different routes, and each route has a cost scantool does not pay. Checked against their own documentation on 2026-06-11.
Reads the code by | Runs an index or server | API keys | Edits code | |
Scantool | Parsing on demand, structure with line numbers | No | No | No |
Packing the whole repo into one file the agent reads in ranges | No (a pack step) | No | No | |
Language servers, symbol by symbol | A language server per language | No | Yes | |
Embedding index with hybrid search | A vector database | Yes | No |
None of the three extract headings, tables or keys from documents as addressable structure.
The trade-off in this category is measured. An index-based tree-sitter MCP reported 10x fewer tokens and 2.1x fewer tool calls at 83% answer quality against 92% for a raw file-exploration agent, across 31 repositories (arXiv 2603.27277, March 2026, self-reported). Scantool's own numbers above show where it wins and where grep does, on the same footing. Serena's editing is a different job and scantool does not attempt it.
Supported languages
Extension | Language | Extracted elements |
| Python | classes, methods, functions, imports, decorators, docstrings, constants |
| JavaScript | classes, methods, functions, imports, JSDoc comments, constants |
| TypeScript | classes, methods, functions, imports, type annotations, JSDoc, constants |
| Rust | structs, enums, traits, impl blocks, functions, use statements, constants |
| Go | types, structs, interfaces, functions, methods, imports, constants |
| C | functions, structs, enums, includes, constants |
| C++ | classes, functions, namespaces, templates, includes, constants |
| Java | classes, methods, interfaces, enums, annotations, imports |
| PHP | classes, methods, functions, traits, interfaces, namespaces, constants |
| C# | classes, methods, properties, structs, enums, namespaces |
| Ruby | modules, classes, methods, singleton methods, constants |
| Zig | functions, structs, enums, unions, tests, constants |
| Swift | classes, structs, enums, protocols, functions, extensions, constants |
| Bash | functions, file-scope variables and exports, comment blocks, |
| PowerShell | functions and filters with their |
| Make | targets with prerequisites, variables, |
| Dockerfile | build stages, ARG and ENV values; edges to the project files COPY/ADD take and to the copied scripts RUN, ENTRYPOINT and CMD run, stage-to-stage calls, entry point |
| SQL | tables, views, functions, procedures, indexes, columns |
| HTML | document structure, elements, attributes |
| CSS | selectors, properties, media queries |
| SCSS | selectors, mixins, variables, nesting |
| YAML | mappings, sequences, scalars, anchors/aliases, multi-document streams |
| Markdown | headings (h1-h6), code blocks with hierarchy |
| Jupyter | cells, and inside them the Python and Markdown structure |
| Plain Text | sections, paragraphs |
| JSON | object keys (nested fully), arrays with item counts, scalar values |
| TOML | tables, array tables, nested keys, inline tables, arrays with item counts |
| XML | elements named by their |
| CSV | columns with position, sampled type and an example value; row count; the first rows (from a 64 KiB prefix, so a large file costs no parse) |
| Images | format, dimensions, colors, content type |
Broken files fall back to regex extraction, so a file that no longer parses still yields its structure. Adding a language is one file; see CONTRIBUTING.md.
MCP tools
The same capabilities as sct, for clients without a shell. Each tool's
description tells the agent when to use it. Parameters, defaults and example
output are in docs/tools.md.
Tool | What it answers |
| Orientation: entry points, hot functions, central files, call map |
| The file tree with one-line gists per file, churn and health labels |
| One file's skeleton; |
| The same reader on content given directly: a git blob, an API response, stdin |
| Text or name search with the enclosing structure and leads to definitions |
| Folders only |
| Structural diff between refs, or a ref and the working tree; |
| A package's public names, where each is defined, and the diff against a ref |
| Structures several branches touch, and a merge order |
| Actual call sites of a name |
| A |
| Functions breaking a call pattern their siblings follow |
| Commits that changed one structure |
Known limitations
Claude Desktop caps an MCP tool response at 25,000 tokens; Claude Code's cap
is set with MAX_MCP_OUTPUT_TOKENS. budget=, depth= and pattern= keep
answers under it, and the coverage line says what a cap left out.
Subagents in Claude Code that lack MCP tools still have the shell, and sct
is in it. If you want the MCP tool specifically, say so: "use scantool to
scan the codebase".
Peer divergence and the connectivity notes are hints from corpus-wide statistics, not verified defects. They tell the agent where to read.
More
docs/install.md: every client, Windows, from source, HTTP transport, troubleshooting
docs/sct.md: the shell command in full, addresses, refs, the cache
docs/tools.md: MCP tool parameters and example output
CONTRIBUTING.md: architecture, adding a language, the output contract, releasing
experiments/benchmark/: the measurements behind the numbers above
Issues and Discussions
MIT License, see LICENSE. Built on FastMCP, tree-sitter and uv.
Available Tools
13 toolscallersCallersA
Actual call sites of a function or method across a directory, never a mention in prose, a comment, a docstring or a string literal; each with its enclosing function and path:line, the definition(s) first. A qualified name (Class.method) narrows the definitions; which definition a site binds to is not resolved, and the answer says so. Given a file instead of a name, the files that import it with the import line, from the same statically resolved import graph as the preview's used by. Answers: who calls this function; find usages and references of a function or method; which files import this file. In your shell: sct callers <name> or sct callers <name> --dir <dir> (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: name (required), ref, directory, output_format.
find_divergenceFind DivergenceA
Peer divergence across a directory: functions that break a call pattern their siblings follow (peers calling X also call Y, this one does not). A review hint, not a verified bug list; silent on a consistent codebase, and that silence is the answer. Answers: functions that break a pattern their siblings follow; likely missed calls, as a review hint. In your shell: sct --help (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: directory (required), max_findings, respect_gitignore.
historyHistoryA
One structure followed backwards through the commits that touched its file: a signature or body change, a rename (paired by identical body, the earlier name followed), the commit that introduced it; a file move is followed. Commits that touched the file but not the structure are counted, not listed. What git log -L gives for a line range, keyed on the structure. Answers: which commits changed this function or class, and when; git log or git blame for one function; how a function evolved across commits. In your shell: sct history <path::name> or sct history <path:line> --ref REF (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: location (required), ref, repo, output_format.
list_directoriesList DirectoriesC
Skeleton of files or a directory: every structure with path:line, signature or title, a condensed excerpt within the budget. A directory gives the tree with one-line gists. --depth quick is about 300 tokens per file, normal 1500, deep everything with module values whole (files only). Elided content is marked ⟨…⟩ +N; focus reads it. Folders only, no files: the directory hierarchy. Answers: read a file's contents; outline of a file; list the functions and classes in a file; read or show the source of one function, method or class by name. In your shell: sct --help (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: directory (required), max_depth, respect_gitignore.
overlapOverlapA
N branches against one base, each at its own merge-base: structures touched by 2+ branches (marked base(~/+/-) when the base itself changed them since the branches forked), new names introduced independently by 2+ branches, commits two branches share (a stack: overlap between them is expected; the residual beyond their shared commits is what stays), and per branch whether it is already in the base and by which criterion (ancestor / patch-equivalent / tree-equal; patch-equivalence proves it can be deleted, not that its content is in the current tree). Ends with a merge-order hint, not a verdict. The first line names the parts (branches, history, shared, colliding, order) with line counts; --part ID prints one part alone. Answers: do branches conflict or change the same functions; in which order to merge several branches; which commits two pull requests share. In your shell: sct overlap <base> <branch>... (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: base (required), branches (required), kind, part, +3 more.
preview_directoryPreview DirectoryA
No command on a directory = orientation: size and language mix, entry points, hot functions, the call-graph map (~3-5k tokens; for first-time orientation of an unknown codebase, not for targeted questions). Line one lists the answer's parts with their line counts and the form that fetches one part alone. The file tree is the tier below (scan). Answers: an overview of a codebase or repository; where to start in an unfamiliar project; entry points and the most-called functions. In your shell: sct <dir> (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: directory (required), part, depth, max_files, +2 more.
resolveResolveA
Translate path:line or path::name from one ref to another: the enclosing structure with start and end at --from, and where it is at --to (same place, renamed with an identical body, or gone, with the nearest names). Answers: where a line or function is at another commit; map a line number from one commit to another. In your shell: sct resolve <path:line> --from REF or sct resolve <path::name> --from REF --to REF (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: location (required), repo, ref_to, ref_from, +1 more.
scan_diffScan DiffA
Structural diff between refs. One ref = that ref vs the working tree. Two refs = A...B against their merge-base by default (--no-merge-base compares the tips; a note says which). Per file: + added, ~ changed (signature: old → new; or body: N code / M doc lines), = renamed (paired by identical body; children follow a renamed class), - removed; identical signature deltas in 3+ functions fold into one row; new files as skeletons; a + or ~ function says how many other changed functions call it. The coverage line counts files changed without structural rows and names the reason for each. --review appends candidate dead/orphan/drift the changed files introduced; off by default on both doors. ref vs the working tree, or ref vs ref2; review=True appends the review tail. Use instead of git diff for review and 'what changed' questions. Answers: what changed between two commits or branches, per function; review the changes of a pull request or branch; local changes against HEAD, as structures rather than lines. In your shell: sct diff <ref> or sct diff <refA> <refB> (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: directory (required), ref, ref2, budget, +3 more.
scan_directoryScan DirectoryB
Skeleton of files or a directory: every structure with path:line, signature or title, a condensed excerpt within the budget. A directory gives the tree with one-line gists. --depth quick is about 300 tokens per file, normal 1500, deep everything with module values whole (files only). Elided content is marked ⟨…⟩ +N; focus reads it. A directory: the file tree with one-line gists per file, code health and churn labels; ref= reads it at a git ref. Replaces Glob/ls for all file types. Answers: read a file's contents; outline of a file; list the functions and classes in a file; read or show the source of one function, method or class by name. In your shell: sct scan <dir> (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: directory (required), ref, mode, delta, +8 more.
scan_fileScan FileA
Skeleton of files or a directory: every structure with path:line, signature or title, a condensed excerpt within the budget. A directory gives the tree with one-line gists. --depth quick is about 300 tokens per file, normal 1500, deep everything with module values whole (files only). Elided content is marked ⟨…⟩ +N; focus reads it. One file; budget=1500 for exploration, 300 for a quick look; focus='name' (or 'Class.method') reads one node verbatim instead of guessing line ranges, body_only=True without the parent context; ref= reads it at a git ref. May append a self-levelling CONNECTIVITY note (candidate dead/orphan/drift across the corpus, silent when clean). Answers: read a file's contents; outline of a file; list the functions and classes in a file; read or show the source of one function, method or class by name. In your shell: sct scan <path> or sct focus <path> <name> (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: file_path (required), ref, mode, delta, +12 more.
scan_file_contentScan File ContentA
Skeleton of files or a directory: every structure with path:line, signature or title, a condensed excerpt within the budget. A directory gives the tree with one-line gists. --depth quick is about 300 tokens per file, normal 1500, deep everything with module values whole (files only). Elided content is marked ⟨…⟩ +N; focus reads it. Content given directly (remote files, APIs, a git blob, stdin), same budget/depth and focus as scan_file. Answers: read a file's contents; outline of a file; list the functions and classes in a file; read or show the source of one function, method or class by name. In your shell: sct scan - --as <path> or sct focus - --as <path> <name> (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: content (required), filename (required), mode, depth, +10 more.
search_structuresSearch StructuresA
Text across a directory (or one file) with structural context: each hit shows its enclosing structure, plus leads to where matched names are defined; when no lead exists it says so. --names matches structure names instead of text; an empty answer names the paths that match and what the other reading finds (the pattern as text, or as names). The pattern is a Python regex; grep's \| is read as alternation with a note. --type filters which structures are reported; --decorator RE (with --names) keeps structures with a matching decorator and answers one row per structure, decorators on the row. 40 structures per page, --limit/--offset for the rest, and the page is stated. content_pattern finds text with its enclosing function/class/section plus leads to definitions; name_pattern/type_filter/has_decorator find structures; ref= searches at a git ref. Best first call for a targeted question; use instead of Grep. Answers: find where a function or class is defined; find text in code across files. In your shell: sct search <dir> <pattern> (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: directory (required), ref, limit, offset, +7 more.
surfaceSurfaceA
The public surface of a package directory at a ref: every exported name with its signature, how it is exported and where it is defined. Each language applies its own rule: Python's all, lazy tables and re-export chains; Rust's pub and lib.rs re-exports; TypeScript's index exports; Go's exported identifiers; visibility keywords elsewhere; a namespace or module is looked through. --against REF prints the surface diff; the header states the direction (A → B) and names its parts (added, changed, moved, removed) with line counts; --part ID prints one part alone. Answers: the public API of a package or module; exported names and where each is defined; API changes between two versions. In your shell: sct surface <package-dir> or sct surface <package-dir> --against REF (if sct is not on PATH, "/app/.venv/bin/python" -m scantool.cli replaces sct).
Inputs: package_dir (required), ref, part, against, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Several tools overlap heavily: list_directories, scan_file, scan_file_content, and scan_directory all produce structural skeletons with nearly identical descriptions, differing only in input source (file vs. content vs. directory). This makes it ambiguous which tool to select for a given task. Other tools like preview_directory and scan_diff are distinct, but the core scanning set lacks clear boundaries.
Naming mixes verb_noun patterns (preview_directory, scan_file, search_structures) with single verbs (resolve, surface, overlap) and bare nouns (callers, history). While names are readable and snake_case throughout, there is no uniform verb-first convention, and tools like list_directories vs. scan_directory feel arbitrarily differentiated.
With 13 tools, the count is within the ideal 3–15 range and covers a wide range of code analysis tasks (scanning, diffing, searching, history, callers, etc.). However, some tools are redundant (e.g., list_directories and scan_directory), so the count could be trimmed without losing functionality.
The server covers a comprehensive set of operations: previewing, scanning files/directories/content, structural diffs, divergence detection, targeted search, public surface analysis, branch overlap, callers, and history. This appears to cover the domain of code structure exploration well, with only minor gaps like a dedicated tool for raw file metadata or multi-file rename detection.
Maintenance
Related MCP Connectors
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
AI-powered codebase analysis — call graphs, security, dead code, complexity. 150+ tools.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables AI assistants to understand and navigate codebases through structural analysis. Provides code mapping, symbol search, and impact analysis using ast-grep for accurate parsing of Python, JavaScript, TypeScript, and Go projects.452MIT
- AlicenseAqualityDmaintenanceAnalyzes codebases and extracts all symbols (functions, classes, methods, interfaces, etc.) from 10+ programming languages into LLM-optimized markdown format. Enables AI assistants to understand entire project structures efficiently without processing full source code.2MIT
- FlicenseAqualityDmaintenanceAnalyzes source code across multiple languages to extract structural elements like classes, functions, and parameters using tree-sitter. It provides LLM-optimized markdown output that includes nesting levels, line numbers, and signatures to facilitate codebase navigation.1-
- AlicenseNot gradedqualityDmaintenanceEnables precise code extraction from 30+ languages using tree-sitter parsing, allowing AI assistants to retrieve functions, classes, and code snippets with accurate line numbers.23 PyPI8MIT