Skip to content
Agentmart
Submit a tool

Code Atlas

Code intelligence MCP: symbols, call graphs, change impact + affected tests, routes, search.

Connector by lusiem · GitHub account verified by the MCP Registry

IndexedMITLocal (stdio)
Write a review

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/lusiem-code-atlas

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Code intelligence MCP: symbols, call graphs, change impact + affected tests, routes, search.

Reviews

Write a review

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Tools
15 read · 2 write · 0 delete · 15 not yet classified
Secrets
None asked for
Install scripts
Not scanned yet
Runs as
Node.js package

Tools by what they do 32

Read from the source code; the running server may list different tools.

Read 15 · Look things up without changing anything.

  • find_asset_references
  • find_dead_code
  • find_references
  • find_route
  • find_similar_code
  • get_dependencies
  • get_file_outline
  • get_scene_structure
  • get_symbol_info
  • index_status
  • list_routes
  • search_content
Show 3 more tools
  • search_reflection
  • search_symbols
  • semantic_search

Write 2 · Create, change, send or run things.

  • call_hierarchy
  • type_hierarchy

Not yet classified 15 · We could not tell from the name and description.

  • ast_query
  • batch_symbols
  • change_coupling
  • change_impact
  • context_pack
  • generate_diagram
  • go_to_definition
  • hotspots
  • project_overview
  • reindex
  • repo_map
  • symbol_history
Show 3 more tools
  • tests_for_symbol
  • trace_path
  • verify_changes

Files it touches

  • Any path the agent passes to its tools

Tools (32)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

  • ast_queryAST pattern query

    Run a raw tree-sitter S-expression query over indexed files of one language and return every capture as path:line with the captured text. Powerful for structural searches no regex can express, e.g. `(call_expression function: (identifier) @fn (#eq? @fn "eval"))` or `(for_statement (await_expression) @hit)`. Parses files on demand, normalized the same way the indexer parses them (e.g. C++ dllexport macros blanked so class nodes parse) — use path_prefix to narrow scope on big repos.

  • batch_symbolsBatch symbol lookup

    Compact one-line info for up to 50 symbol ids in a single call — resolve the #ids from call_hierarchy / change_impact / find_dead_code output without one get_symbol_info round trip each. Set include_source for the definition snippets too.

  • call_hierarchyCall hierarchy

    Who calls this symbol (direction=in) or what it calls (direction=out), as a tree up to `depth` levels. Uses the exact language server when available ([lsp 1.00] edges), structural index otherwise (confidence per edge).

  • change_couplingChange coupling

    Which files historically change together with this one? Directional: "when I touch A, B changes 45% of the time" and the reverse, because the asymmetry is the signal. Flags coupled files with NO import edge — config, fixtures, generated code and string-keyed lookups the structural graph cannot see. Co-change is correlation, not causation; commits touching more than 50 files are excluded as refactors.

  • change_impactChange impact

    Blast radius of a change: transitive callers/subtypes of the target plus files reachable through imports, with affected TEST files highlighted. Target a symbol (symbol_id/path+line/name), a set of files (files=[...]), or nothing — no arguments analyzes the uncommitted git diff.

  • context_packContext pack

    One-call, token-budgeted briefing on a symbol: definition source, surrounding file outline, type context, top callers/callees, route (if a handler), and related tests — instead of stitching six separate lookups. Sections that exceed the budget are named so you can ask for them specifically. Optional task string pulls in possibly relevant symbols.

  • find_asset_referencesFind asset references

    Reverse lookup across engine assets: which scenes/prefabs/Blueprints reference this script, scene, asset path, or handler method? Accepts a workspace-relative path, a res:// or /Game/ path, or a bare method/class/event name (Unreal: called functions via call_function, event handlers via handles_event).

  • find_dead_codeFind dead code

    Symbols nothing references: no resolved occurrence and no graph edge points at them, after excluding entry points, route handlers, and engine/framework lifecycle callbacks. Candidates with unresolved same-name usages elsewhere are hedged as "possibly dead" — dynamic dispatch and reflection are invisible to a structural index, as are dependency injection, string-keyed lookups and consumers outside the workspace — treat this as a review list, not a delete list, and verify before deleting. A second section lists exported symbols only ever used inside their own file.

  • find_referencesFind references

    Usages of a symbol. Uses the exact language server when one is available (provenance lsp), falling back to indexed usages: resolved references first (with confidence), then unresolved same-name occurrences as candidates.

  • find_routeFind route

    Which code serves this URL? Matches a concrete request path (e.g. "/api/users/7") against indexed route patterns, parameter segments (:id, {id}, <int:pk>) treated as wildcards. Returns the handler symbol (#id chains into call_hierarchy / change_impact).

  • find_similar_codeFind similar code

    Does a helper for this already exist? Near-duplicate search over the indexed code: target an existing symbol or paste a snippet. Uses local embedding vectors when ready ([cos]), degrading to token-shingle text similarity ([jaccard]) while embedding coverage builds.

  • generate_diagramGenerate Mermaid diagram

    Render index data as a Mermaid diagram (returned in a ```mermaid fence — paste into GitHub markdown, docs, or a Mermaid viewer). kind=imports: workspace import graph, file-level with directory clusters or collapsed to directories (granularity, path_prefix to scope). kind=calls: call graph around one symbol (direction in/out/both, depth). kind=types: inheritance diagram around one type. kind=call_path: shortest call chain from one symbol to another (from_name/from_id -> to_name/to_id). Dotted arrows are low-confidence structural edges (< 0.70) — hints, not facts.

  • get_dependenciesFile dependencies

    What a file imports (direction=out) or which files import it (direction=in). Unresolved specifiers are external packages or system headers.

  • get_file_outlineFile outline

    Hierarchical outline of every definition in a file, with signatures — read the structure of a file without reading its source. Pass a DIRECTORY instead of a file to get its public API surface in one call rather than one call per file. Over budget, nesting depth is shed before any top-level symbol is dropped, so the shape stays honest. Set include_docs to also get first-line doc comments.

  • get_scene_structureScene structure

    Node tree of a game-engine scene file with attached scripts, instanced sub-scenes, and signal connections. Supports Godot .tscn/.tres today (Unity prefabs planned).

Show 17 more tools
  • get_symbol_infoSymbol info

    Full detail for one symbol: signature, doc comment, location, container — and optionally its source. Identify the symbol by id (from search_symbols/get_file_outline), by file+line position, or by exact name.

  • go_to_definitionGo to definition

    Definition site of the identifier at a file position. Uses the exact language server when available, falling back to the structural index (resolved occurrence at that position).

  • hotspotsChurn hotspots

    Risk-ranked files: git commit churn over a window multiplied by current size (score = commits × log2(lines)). High churn on large files marks refactor and review targets.

  • index_statusIndex status

    Indexing progress, per-file errors, and freshness of the code index.

  • list_routesList routes

    Web-framework routes indexed across the workspace (Express, Fastify, NestJS, FastAPI, Flask, Django, plus file-based routing for Next.js, SvelteKit, Nuxt, and Remix), one line per route with its handler symbol. Filter by framework, HTTP method, or a path fragment.

  • project_overviewProject overview

    Cheap orientation router: languages, file/symbol counts, index freshness, top-level layout, entry-point and dependency counts. Call repo_map next for the annotated architecture map.

  • reindexReindex workspace

    Force an incremental re-scan of the workspace (hash-checks every file, reindexes changed ones).

  • repo_mapRepository map

    Annotated architecture map of the workspace — the first call to make in an unfamiliar repo. Directory tree with per-directory file/symbol counts, dominant language, role, size and import fan-in/fan-out (so layering is visible), plus entry points, the highest-fan-in symbols, and the third-party dependency inventory. One budgeted call instead of a grep sweep. Use path_prefix and depth to zoom into a subtree, and sections to ask for just one part. Ranking is structural and heuristic — distinct-file fan-in over resolved imports and call/type edges; reflection, DI and string-keyed dispatch are invi…

  • search_contentSearch file contents

    Literal text search over indexed file contents — string literals, error messages, env var names, TODO comments, config keys: anything that is not a definition name (use search_symbols for those). Covers non-code files (md/json/yaml/toml/sql/Dockerfile/CI) that no other tool indexes. Word and phrase matching; regex=true for patterns.

  • search_reflectionSearch engine reflection markers

    Find engine-reflected declarations: Unreal UCLASS/UPROPERTY/UFUNCTION specifiers (e.g. "BlueprintCallable", "Replicated"), Unity attributes ("[SerializeField]"), and Godot annotations ("@export", "@onready") or signals. Answers from the index: declaration signatures plus Unreal reflection macros captured onto the annotated symbol.

  • search_symbolsSearch symbols

    Search definitions (functions, classes, methods, …) by name across the whole workspace. Matches name prefixes and doc comments; falls back to substring match. Returns one line per symbol with its id (#N) for use with get_symbol_info.

  • semantic_searchSemantic code search

    Natural-language search over the code: describe behavior ("where is retry backoff implemented", "function that validates auth tokens") rather than symbol names. Hybrid keyword+embedding ranking, fully local. First-ever call downloads the embedding model (~150 MB one-time); until embedding coverage completes, results are keyword-weighted and say so.

  • symbol_historySymbol history

    How did this symbol get this way? Line-range git history (git log -L) for the symbol's span: commit, date, author and subject, following the code as it moves within its file. Answers "why is this here" and "who do I ask" without reading the diff.

  • tests_for_symbolTests for symbol

    Which tests exercise this symbol? Walks the call/type graph backwards from the target to test files (strongest evidence, names the test-case symbol), then adds test files that only reach it through imports (weaker signal). Complements change_impact: this answers "what should I run?" for one symbol directly.

  • trace_pathTrace call path

    Shortest call chain from one symbol to another over the indexed call graph — "how does the request handler end up in the DB layer?". Both ends accept a symbol id or an exact name.

  • type_hierarchyType hierarchy

    Supertypes (direction=super: what this type extends/implements) or subtypes (direction=sub: what extends/implements it), as a tree.

  • verify_changesVerify changes

    Post-edit structural check of the uncommitted working tree (or explicit files) against git HEAD: imports that stopped resolving, removed exports that other files still reference, and signature changes with live callers. change_impact predicts blast radius before an edit; this confirms what actually broke after. Waits for the index to catch up with the edits before answering.

Signals

Stars
0
Forks
0
Open issues
0
Weekly downloads
26
Last commit
Jul 28, 2026 (3 months ago)
Last release
Jul 27, 2026 (3 months ago)
Last package publish
Jul 28, 2026 (3 months ago)

From GitHub (fetched Oct 24, 2026) and the package registry.

Details

Registry name
io.github.lusiem/code-atlas
Version
0.5.0
Auth
No auth
Packages
npm @lusiem/code-atlas
License
MIT
Repository
github.com/lusiem/code-atlas
First seen
Oct 24, 2026
Last checked
Oct 24, 2026
Source
Official MCP Registrygithub-graphql
Cite this page

Code Atlas MCP server. Agent Mart. https://agentmart.dev/connectors/lusiem-code-atlas (last updated 2026-10-24)