Code Atlas

Name: Code Atlas
Author: lusiem

โดย lusiemรุ่น 0.5.0i★ 0iรันบนเครื่อง

ชื่อใน registryio.github.lusiem/code-atlas

ติดตั้ง

ภาพรวม

คำอธิบายจากผู้ทำ (ภาษาอังกฤษตามต้นฉบับ)

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

สามเสาของ PopNx MCP

สามเรื่องนี้ไม่รวมเป็นคะแนนเดียว เพราะความเห็น การวัด และความนิยม เป็นคนละเรื่องกัน

เสียงผู้ใช้iยังไม่มีรีวิวรีวิวเปิดพร้อมระบบบัญชีในขั้นถัดไป
ผลตรวจเบื้องต้นของเราiผ่าน 2 จาก 2 ข้อตรวจจากข้อมูลที่เปิดอยู่ ยังไม่ได้สแกนโค้ด
การใช้งานiยังใหม่มาก↓ 51/สัปดาห์ · ★ 0

ใช้ทำอะไรได้

ตัวนี้ยังไม่ได้เรียบเรียงเป็นภาษาไทย ด้านล่างคือข้อเท็จจริงที่เราอ่านจาก registry

การเชื่อมต่อ: รันบนเครื่อง
ช่องทาง (transport): stdio
หมวด: เครื่องมือนักพัฒนา

ติดตั้ง

เลือกโปรแกรม AI ที่คุณใช้ แล้วคัดลอกค่าตั้งไปวาง

ก่อนติดตั้ง

ผลตรวจเบื้องต้น: ผ่าน 2 จาก 2 ข้อ
รันในเครื่องคุณด้วยสิทธิ์ของผู้ใช้คุณ (ไฟล์ อินเทอร์เน็ต แอปต่าง ๆ)
ทะเบียนไม่ได้ระบุ key ที่ต้องใส่

ต้องเตรียมก่อน

npmติดตั้ง Node.js (มีคำสั่ง npx) ในเครื่อง

คุณใช้แอปไหน

ClaudeClaude CodeCursorVS CodeChatGPT

เลือกแอปด้านบน เราจำไว้ให้ ครั้งหน้าปุ่มจะขึ้นว่า “ติดตั้งลง …”

เปิด Claude Desktop → Settings → Developer → Edit Config แล้ววางค่านี้ในไฟล์ claude_desktop_config.json

{
  "mcpServers": {
    "code-atlas": {
      "command": "npx",
      "args": [
        "-y",
        "@lusiem/code-atlas"
      ]
    }
  }
}

พิมพ์คำสั่งนี้ใน Terminal

claude mcp add code-atlas -- npx -y @lusiem/code-atlas

เปิดใน Cursor

หรือคัดลอกค่าตั้งเอง

วางในไฟล์ .cursor/mcp.json ของโปรเจกต์ หรือ ~/.cursor/mcp.json

{
  "mcpServers": {
    "code-atlas": {
      "command": "npx",
      "args": [
        "-y",
        "@lusiem/code-atlas"
      ]
    }
  }
}

เบราว์เซอร์จะถามก่อนเปิดแอป จากนั้นแอปแสดงค่าตั้งให้ตรวจแล้วกดยืนยัน ช่อง key เว้นว่างไว้ให้คุณใส่เอง

เปิดใน VS Code

หรือคัดลอกค่าตั้งเอง

วางในไฟล์ .vscode/mcp.json ของโปรเจกต์

{
  "servers": {
    "code-atlas": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@lusiem/code-atlas"
      ]
    }
  }
}

ตัวนี้รันในเครื่องคุณ แต่ ChatGPT ต่อได้เฉพาะ server บนอินเทอร์เน็ต ลองเลือกแอปอื่น

ตัวเลือกเก็บในคุกกี้บนเครื่องนี้ ไม่ต้องมีบัญชี

ค่าตั้งนี้สร้างจากข้อมูลใน registry ของผู้ทำ ถ้าไม่ตรงกับ README ให้เชื่อ README

ใช้กับโปรแกรมไหนได้

ดูจากแบบการต่อของ server ตัวนี้ และเอกสารของผู้ทำโปรแกรมแต่ละตัว ตรวจเมื่อ 10 พ.ย. 2569

ติดตั้งบนเครื่องได้ใน

Claude Goose LM Studio Msty Studio Cherry Studio Cursor VS Code + GitHub Copilot Visual Studio Windsurf (Devin Desktop)Zed Kiro Cline Continue JetBrains AI Assistant Claude Code Codex CLI Gemini CLI OpenCode nodecode Warp LibreChat Raycast

ดูโปรแกรมทั้งหมดพร้อมข้อดีข้อเสีย →

ทำอะไรได้บ้าง

รันในเครื่องคุณ รายการเครื่องมือจะขึ้นในแอป AI หลังติดตั้ง

ผลตรวจเบื้องต้นi

เราตรวจจากข้อมูลที่ใครก็เปิดดูได้ ยังไม่ได้อ่านโค้ด ข้อที่ไม่เกี่ยวกับตัวนี้ไม่นับในตัวหาร · ตรวจเมื่อ 10 พ.ย. 2569

✓ ผ่าน
ตัวตนผู้ทำตรงกับ repo
ชื่อใน registry ยืนยันด้วยบัญชี GitHub lusiem ซึ่งเป็นเจ้าของ repo
✓ ผ่าน
ยังมีคนดูแล
มีการแก้โค้ดล่าสุด 3 เดือนที่ผ่านมา
… ยังไม่ตรวจ
มีสัญญาอนุญาต (license)
ยังไม่ได้อ่านข้อมูล repo จาก GitHub
– ไม่เกี่ยว
endpoint ตอบ
ตัวนี้รันบนเครื่องคุณ ไม่มี endpoint บนอินเทอร์เน็ต
– ไม่เกี่ยว
ล็อกอินแบบ OAuth
ตัวนี้รันบนเครื่อง ใช้ค่าที่ตั้งในเครื่องแทน
… ยังไม่ตรวจ
คำอธิบายเครื่องมือไม่มีคำสั่งแอบแฝง
รันในเครื่องคุณ เราอ่านรายการเครื่องมือได้เฉพาะตัวที่มี endpoint บนอินเทอร์เน็ต

เทียบกับตัวอื่นในหมวด เครื่องมือนักพัฒนาi

ดาวมากกว่า 0% ของอีก 5725 ตัวในหมวดนี้
ส่งรุ่นใหม่เข้า registry ล่าสุดกว่า 24% ของอีก 5725 ตัวในหมวดนี้
ผลตรวจเบื้องต้นดีกว่าหรือเท่ากับ 100% ของอีก 5725 ตัวในหมวดนี้

เทียบกับทุก server ที่ยังใช้งานในหมวดนี้ทั้งทะเบียน ดาวนับเฉพาะเมื่อผู้ลงทะเบียนเป็นเจ้าของ repo

คำถามที่พบบ่อย

Code Atlas ปลอดภัยไหม?

จากการตรวจเบื้องต้นของเรา ผ่าน 2 จาก 2 ข้อที่ตรวจได้ เรายังไม่ได้อ่านโค้ด ก่อนใส่กุญแจหรือ token ให้ดูว่า server ขอสิทธิ์อะไร และเลือกกุญแจที่ทำได้เท่าที่จำเป็น

ต้องใช้กุญแจหรือรหัสอะไรบ้าง?

registry ไม่ได้ระบุว่าต้องใช้กุญแจ แต่บางตัวจะขอให้ล็อกอินตอนใช้ครั้งแรก

ตัวนี้รันบนเครื่องหรือบนคลาวด์?

รันบนเครื่องของคุณ โปรแกรม AI จะเปิด server ขึ้นมาเองเมื่อใช้ ข้อมูลไม่ต้องผ่านเซิร์ฟเวอร์ของผู้ทำ (ยกเว้นตัวที่ไปเรียกบริการออนไลน์ต่อ)

ยังมีคนดูแลอยู่ไหม?

repo บน GitHub มีการแก้โค้ดล่าสุด 3 เดือนที่ผ่านมา และส่งรุ่นล่าสุด (0.5.0) เข้า registry 4 เดือนที่ผ่านมา

ใช้กับโปรแกรมไหนได้บ้าง?

โปรแกรมที่รองรับ MCP เช่น Claude Desktop, Claude Code, Cursor และ VS Code ตัวนี้ต้องมี Node.js ในเครื่องด้วย

มีตัวไหนใช้แทนได้บ้าง?

ในหมวดเดียวกันมี REA, Netdata, Front-End Checklist

ตัวที่ใช้แทนได้

server หมวดเดียวกันจากผู้ทำคนอื่น เรียงตามดาว

อ่านการ์ด:↓ ดาวน์โหลดต่อสัปดาห์i★ ดาว GitHubiสามเสา: รีวิว · ผลตรวจ · การใช้งานiอัปเดต = วันที่ส่งรุ่นล่าสุดเข้า registryi

REA

Reverse engineer anything from your terminal or agent with one CLI and MCP server.

โดย morlutoใช้กันมาก↓ 388.7K/สัปดาห์★ 448.2Kอัปเดต 16 วันที่ผ่านมา

รันบนเครื่อง

ติดตั้ง

Netdata

Real-time infrastructure monitoring with metrics, logs, alerts, and ML-based anomaly detection.

โดย netdataใช้กันมาก★ 81.3Kอัปเดต 6 วันที่ผ่านมา

รันบนคลาวด์

ติดตั้ง

Front-End Checklist

Review frontend code and live pages against 386 quality-gated web development rules.

โดย thedaviddiasใช้กันมาก★ 74.7Kอัปเดต 37 วันที่ผ่านมา

รันบนคลาวด์

ติดตั้ง

README จากผู้ทำ

เปิดอ่าน README

ส่วนนี้คัดจาก repo ของผู้ทำตามต้นฉบับ PopNx MCP ไม่ได้ตรวจหรือรับรองเนื้อหา ตัด HTML รูปภาพ และสคริปต์ออกแล้ว ลิงก์จะพาออกนอกเว็บ

code-atlas

Multi-language code intelligence MCP server — gives Claude Code (and any MCP client) a structured view of your codebase instead of raw text: symbol search, file outlines, AST pattern queries, cross-file references, call/type hierarchies, import graphs, change-impact analysis with affected-test detection, web-framework route maps (Express/NestJS/Fastify/FastAPI/Flask/Django), Mermaid diagrams, precise LSP-backed answers, local-embedding semantic search, and game-engine asset understanding (Godot, Unity, Unreal). 25 languages indexed.

Instead of grepping and reading whole files, the model asks questions like *"map this repo"*, *"outline this file"*, *"who calls parseConfig?"*, *"how does the request handler reach the DB layer?"*, *"what changes whenever this file changes?"* — and gets compact, token-efficient answers backed by a persistent tree-sitter index.

Every answer is budgeted: tools take a max_tokens cap, and a clamped response returns a cursor you can pass back to continue rather than re-asking with a bigger budget.

Status: released (npm @lusiem/code-atlas, MCP registry io.github.lusiem/code-atlas). 25 languages, 32 tools, LSP-exact answers with a structural floor, engine adapters, and an agent-workflow layer (repo_map, context_pack, verify_changes) built for token economy. Validated at 19k files / 6.3M LOC.

How it works

your repo ──scan (gitignore-aware)──> tree-sitter parse ──> SQLite index (symbols, imports,

occurrences, call/type edges, FTS5) │ Claude Code ◄──────────── MCP tools over stdio ────────────────────┘

Persistent index at /.code-atlas/index.db (self-gitignored), incrementally refreshed by content hash.
Live — a gitignore-aware file watcher reindexes saves within a debounce beat and re-resolves only the affected files (--no-watch or "watch": false to disable).
Zero config — point it at a repo root and it works. Optional code-atlas.json for include/exclude tweaks.
Everything local — your code never leaves your machine.

Install & use with Claude Code

claude mcp add code-atlas -- npx -y @lusiem/code-atlas serve

Or from a clone:

git clone https://github.com/lusiem/code-atlas && cd code-atlas

npm install && npm run build claude mcp add code-atlas -- node /path/to/code-atlas/dist/index.js serve

The server indexes the current working directory; pass --root to override.

CLI

node dist/index.js index [--root <path>]              # one-shot index build (debugging / warm-up)

node dist/index.js serve [--root ] [--no-watch] [--no-lsp] [--no-embeddings] [--no-download]

MCP server on stdio

Tools

Full reference with example outputs: docs/tools.md.

Tool	What it answers
`repo_map`	What is this repo and where do I start? Annotated directory tree with import fan-in/fan-out (layering at a glance), entry points, importance-ranked key symbols with the reason each ranks, and the third-party dependency inventory — one budgeted call instead of a grep sweep. `path_prefix`/`depth` to zoom.
`project_overview`	The cheap version: languages, sizes, layout, index freshness.
`search_symbols`	Where is X defined? FTS + fuzzy over names and doc comments, filterable by kind/language/path.
`search_content`	Where does this text appear? String literals, error messages, env vars, config keys, TODOs — and the only tool that sees non-code files (md/json/yaml/toml/sql/Dockerfile/CI). The index proposes candidates, the disk verifies them, so a hit is never stale.
`semantic_search`	"Where is retry backoff implemented?" — natural-language search, hybrid keyword+embedding ranking, fully local.
`get_file_outline`	What's in this file? Hierarchical signatures without reading source — over budget it sheds nesting depth rather than tail lines, so every top-level symbol survives. Pass a directory for a package's public API surface in one call.
`get_symbol_info`	Everything about one symbol (by id, position, or name) incl. docs and source.
`context_pack`	One-call, token-budgeted briefing on a symbol: source, outline, callers/callees, types, route, related tests — instead of six lookups. Sections that don't fit the budget are named.
`batch_symbols`	Up to 50 `#id`s resolved to compact one-liners in a single call.
`ast_query`	Raw tree-sitter S-expression queries — structural search regex can't do.
`find_references`	Who uses this symbol? Exact (LSP) when available, else resolved usages first, name-matches as candidates.
`go_to_definition`	Definition of the identifier at a position. LSP-exact with index fallback.
`call_hierarchy`	Who calls this / what does it call, as a tree. `[lsp 1.00]` edges when a language server is running.
`type_hierarchy`	Supertypes and subtypes over extends/implements edges.
`get_dependencies`	File import graph, both directions (imports / imported-by).
`trace_path`	Shortest call chain between two symbols.
`change_impact`	Blast radius of a change: transitive callers + import reachability, affected test files first. Target a symbol, a file list, or nothing — no args analyzes the uncommitted git diff (hunk-level: only symbols you actually touched seed the traversal). Affected route handlers are tagged `[ROUTE GET /users/:id]`.
`verify_changes`	Post-edit structural check against git HEAD: imports that stopped resolving, removed exports other files still reference, signature changes with live callers. `change_impact` predicts; this confirms.
`tests_for_symbol`	Which tests exercise this symbol? Reverse graph walk to test files, naming the test case; import-chain-only hits reported as a weaker signal.
`find_similar_code`	"Does a helper for this already exist?" — near-duplicate search over the local embedding vectors, with a text-similarity fallback while coverage builds.
`find_dead_code`	Zero-reference symbols after entry-point/route/lifecycle exclusions, confidence-hedged (`possibly dead` when a same-name usage exists anywhere); unused exports listed separately.
`hotspots`	Churn × size risk ranking, answered from the cached commit history.
`change_coupling`	Which files historically change together with this one — the coupling a structural index cannot see (config, fixtures, docs, string-keyed dispatch). Directional confidence, and files with no import edge are flagged.
`symbol_history`	Why does this look like this, and who do I ask? `git log -L` over the symbol's line span: sha, date, author, subject.
`list_routes`	Web-framework routes across the workspace — Express, Fastify, NestJS, FastAPI, Flask, Django, plus file-based routing for Next.js, SvelteKit, Nuxt, and Remix — each linked to its handler symbol.
`find_route`	"Which code serves `GET /api/users/7`?" — matches a concrete URL against indexed route patterns (`:id`, `{id}`, are wildcards) and returns the handler.
`generate_diagram`	Mermaid diagrams of the above graphs: import graph (file or directory level), call graph around a symbol, type hierarchy, call path — paste straight into GitHub markdown or docs.
`get_scene_structure`	Godot scene node tree with attached scripts, instanced sub-scenes, and signal connections (handlers resolved to symbols).
`find_asset_references`	Which scenes/prefabs/Blueprints use this script, asset, or handler? Reverse lookup across Godot res:// paths, Unity GUIDs (via .meta), and Unreal modules + /Game/ Blueprint paths.
`search_reflection`	All `UPROPERTY(Replicated)`, `[SerializeField]`, `@export` vars, signals — engine reflection markers across the workspace.
`index_status` / `reindex`	Index health and manual refresh.

Cross-file answers are LSP-first with a structural floor: when a language server is available (found on PATH or auto-acquired into a per-user cache), references/definitions/hover/call hierarchies are exact and tagged lsp; everywhere else, heuristic import/name resolution answers with a confidence score per edge. Servers: typescript-language-server + pyright (npm), gopls (go install), rust-analyzer + clangd (pinned, SHA-256-verified release binaries), Eclipse JDT LS for Java (needs a Java 21+ runtime — detected via PATH/JAVA_HOME), kotlin-language-server (needs any JRE), and csharp-ls for C# (needs the .NET SDK; installed as a dotnet tool — deliberately not Microsoft's Roslyn LSP, whose license is VS-only). GDScript attaches to the Godot editor's built-in language server (TCP 127.0.0.1:6005, override with CODE_ATLAS_GODOT_LSP_PORT) whenever the editor has the project open — close the editor and answers fall back to structural, reopen it and the next query reattaches. Missing runtimes degrade that language to structural, reported honestly in index_status. A first-time acquisition (download + boot) never blocks a query: tools wait up to 8 s, then answer structurally while the server finishes starting. Disable with --no-lsp; disable auto-download with --no-download.

Semantic search embeds every function/class (signature + doc + body) with a code-tuned local model — jinaai/jina-embeddings-v2-base-code, quantized ONNX — and fuses cosine similarity with BM25 keyword rank. Everything stays on your machine. The ONNX runtime (~220 MB) and model (~150 MB) are not part of this package: they download to the per-user cache the first time you call semantic_search, never at install, and structural tools never wait on them. Until coverage completes, results are keyword-weighted and say so. Embedding a 60k-symbol repo takes ~15 minutes of background time, once; after that only edited symbols re-embed. "embeddings": {"model": "fast"} swaps in a 4× faster general-purpose model; --no-embeddings turns the layer off.

Languages

Indexing today (25): TypeScript, TSX, JavaScript, Python, C, C++, Rust, Go, Java, Kotlin, C#, GDScript, PHP, Ruby, Lua, Solidity, Zig, Nix, Swift, Scala, Dart, Terraform/HCL, Pascal/Delphi, Vue, Svelte.

Vue and Svelte single-file components index the blocks (all of them, included) at their true file line numbers; component imports resolve, so .vue/.svelte dependency graphs work in get_dependencies and change_impact. Terraform maps blocks to symbols (resource "aws_s3_bucket" "logs" is searchable by either label) and resolves local module sources as imports. Languages beyond the LSP-covered core answer structurally with confidence-scored edges — same contract as everywhere else.

Test-file awareness: every indexed file is classified by per-language path conventions (*.test.ts, test_*.py, *_test.go, src/test/, *_spec.rb, foundry .t.sol, …) — this powers change_impact's affected-test reporting. Inline test blocks (Rust #[cfg(test)], Zig test) are not path-classifiable and stay invisible by design.

Game engines: engine assets index alongside code — Godot .tscn/.tres scenes (node trees, script attachments, signal connections, autoloads; res:// resolved per project.godot, monorepos of many projects included), Unity .unity/.prefab/.asset + .meta GUID maps (MonoBehaviour → C# class links, serialized references), and Unreal .uproject/.uplugin/Build.cs module graphs plus indexed reflection macros: UCLASS/USTRUCT/UFUNCTION/UPROPERTY specifiers attach to the symbol they annotate (searchable, shown in get_symbol_info), and dllexport macros (class MYGAME_API AMyActor) no longer break C++ class extraction.

Unreal Blueprints (`.uasset`/`.umap`): binary editor packages are parsed natively (package summary, name/import/export tables, asset-registry tags, and bounded tagged-property r

ตัดมาแค่ช่วงต้น อ่านต่อใน repo

Code Atlas

ภาพรวม

สามเสาของ PopNx MCP

ใช้ทำอะไรได้

ติดตั้ง

ก่อนติดตั้ง

ใช้กับโปรแกรมไหนได้

ทำอะไรได้บ้าง

ผลตรวจเบื้องต้นi

ตัวตนผู้ทำตรงกับ repo

ยังมีคนดูแล

มีสัญญาอนุญาต (license)

endpoint ตอบ

ล็อกอินแบบ OAuth

คำอธิบายเครื่องมือไม่มีคำสั่งแอบแฝง

เทียบกับตัวอื่นในหมวด เครื่องมือนักพัฒนาi

คำถามที่พบบ่อย

ตัวที่ใช้แทนได้

REA

Netdata

Front-End Checklist

README จากผู้ทำ

code-atlas

How it works

Install & use with Claude Code

CLI

MCP server on stdio

Tools

Languages