MCP server와 CLI를 통해 AI agent가 코드베이스의 함수 단위 의존성 그래프를 쿼리하여 영향도, 복잡도 및 아키텍처를 분석할 수 있습니다.
다른 이름 optave/ops-codegraph-tool, @optave/codegraph
- 스타
- 100
- Tools
- —
- 다운로드, 30일
- —
- 최신 버전
- —
- 마지막 커밋
- 2026년 11월 13일
- 라이선스
- Apache-2.0
codegraph MCP란?
codegraph은(는) MCP server입니다. MCP server와 CLI를 통해 AI agent가 코드베이스의 함수 단위 의존성 그래프를 쿼리하여 영향도, 복잡도 및 아키텍처를 분석할 수 있습니다.
프로젝트 README에서 생성된 요약
codegraph MCP server 정보
ops-codegraph-tool은 AI agent에게 코드베이스의 구조적 지도를 제공합니다. 이 도구는 프로젝트 내의 모든 함수, 호출자 및 의존성을 추적하는 함수 단위 의존성 그래프를 구축합니다. tree-sitter를 사용하여 파싱하고 SQLite에 데이터를 저장함으로써, AI 클라이언트가 방대한 파일을 읽어 컨텍스트 윈도우를 소모하지 않고도 코드 아키텍처를 이해할 수 있는 지능적인 방법을 제공합니다.
개발자는 CLI 또는 직접 쿼리를 위한 34개의 특화된 도구를 노출하는 MCP server를 통해 이 도구를 사용할 수 있습니다. 네트워크 호출이나 텔레메트리 없이 완전히 로컬에서 작동하므로 코드가 사용자의 머신에 그대로 유지됩니다. 시작하는 데 API 키, 계정 또는 Docker 컨테이너가 필요하지 않으며, npm을 통해 패키지를 설치하고 build 명령어를 실행하기만 하면 됩니다. 이러한 설정을 통해 agent는 코드를 수정하기 전에 특정 함수를 임포트하는 파일이 몇 개인지 확인하는 등 영향도를 선제적으로 파악할 수 있습니다.
활용 사례
- 1함수 영향도 분석리팩터링 중 변경 사항으로 인한 오류를 방지하기 위해 AI agent에게 특정 함수의 모든 호출자를 식별하도록 요청합니다.
- 2아키텍처 경계 강제새로운 코드 커밋이 설정된 아키텍처 규칙이나 레이어 경계를 위반하지 않도록 이 도구를 사용합니다.
- 3코드 복잡도 감사기술 부채를 식별하기 위해 특정 모듈의 인지적 또는 순환 복잡도에 대한 보고서를 요청합니다.
- 4데드 코드 탐지agent가 의존성 그래프 내에서 더 이상 도달할 수 없는 미사용 export 또는 함수를 찾도록 합니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
codegraph MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 codegraph MCP 설치
$ claude mcp add ops-codegraph-tool -- npx -y @optave/codegraphCursor에 codegraph MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"ops-codegraph-tool": {
"command": "npx",
"args": [
"-y",
"@optave/codegraph"
]
}
}
}VS Code에 codegraph MCP 설치
.vscode/mcp.json
{
"servers": {
"ops-codegraph-tool": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@optave/codegraph"
]
}
}
}VS Code CLI에 codegraph MCP 설치
$ code --add-mcp '{"name":"ops-codegraph-tool","type":"stdio","command":"npx","args":["-y","@optave/codegraph"]}'Claude Desktop에 codegraph MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"ops-codegraph-tool": {
"command": "npx",
"args": [
"-y",
"@optave/codegraph"
]
}
}
}Codex에 codegraph MCP 설치
$ codex mcp add ops-codegraph-tool -- npx -y @optave/codegraphCodex config.toml에 codegraph MCP 설치
~/.codex/config.toml
[mcp_servers.ops-codegraph-tool] command = "npx" args = ["-y", "@optave/codegraph"]
Gemini CLI에 codegraph MCP 설치
$ gemini mcp add -s user ops-codegraph-tool npx -- -y @optave/codegraphGemini settings.json에 codegraph MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"ops-codegraph-tool": {
"command": "npx",
"args": [
"-y",
"@optave/codegraph"
]
}
}
}자동 검사
2026년 11월 12일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능통과
- 오픈 소스 라이선스 (OSI)통과
- 최근 1년 내 커밋 또는 릴리스통과
- 패키지 이름이 인기 패키지와 유사하지 않음통과
- 원격 엔드포인트가 HTTPS 사용검사되지 않음
- 파괴적인 도구에 라벨 표시됨검사되지 않음
- 모델에 대한 숨겨진 지침 없음통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음검사되지 않음
README
GitHub에서 보기The Problem
AI agents face an impossible trade-off. They either spend thousands of tokens reading files to understand a codebase's structure — blowing up their context window until quality degrades — or they assume how things work, and the assumptions are often wrong. Either way, things break. The larger the codebase, the worse it gets.
An agent modifies a function without knowing 9 files import it. It misreads what a helper does and builds logic on top of that misunderstanding. It leaves dead code behind after a refactor. The PR gets opened, and your reviewer — human or automated — flags the same structural issues again and again: "this breaks 14 callers," "that function already exists," "this export is now dead." If the reviewer catches it, that's multiple rounds of back-and-forth. If they don't, it can ship to production. Multiply that by every PR, every developer, every repo.
The information to prevent these issues exists — it's in the code itself. But without a structured map, agents lack the context to get it right consistently, reviewers waste cycles on preventable issues, and architecture degrades one unreviewed change at a time.
What Codegraph Does
Codegraph builds a function-level dependency graph of your entire codebase — every function, every caller, every dependency — and keeps it current with sub-second incremental rebuilds.
It parses your code with tree-sitter (native Rust or WASM), stores the graph in SQLite, and exposes it where it matters most:
- MCP server — AI agents query the graph directly through 34 tools — one call instead of dozens of
grep/find/catinvocations - CLI — developers and agents explore, query, and audit code from the terminal
- CI gates —
checkandmanifestocommands enforce quality thresholds with exit codes - Programmatic API — embed codegraph in your own tools via
npm install
Instead of an agent editing code without structural context and letting reviewers catch the fallout, it knows "this function has 14 callers across 9 files" before it touches anything. Dead exports, circular dependencies, and boundary violations surface during development — not during review. The result: PRs that need fewer review rounds.
Free. Open source. Fully local. Zero network calls, zero telemetry. Your code stays on your machine. When you want deeper intelligence, bring your own LLM provider — your code only goes where you choose to send it.
Three commands to a queryable graph:
npm install -g @optave/codegraph
cd your-project
codegraph build
No config files, no Docker, no JVM, no API keys, no accounts. Point your agent at the MCP server and it has structural awareness of your codebase.
Why it matters
| Without codegraph | With codegraph | |
|---|---|---|
| Code review | Reviewers flag broken callers, dead code, and boundary violations round after round | Structural issues are caught during development — PRs pass review with fewer rounds |
| AI agents | Modify parseConfig() without knowing 9 files import it — reviewer catches it |
fn-impact parseConfig shows every caller before the edit — agent fixes it proactively |
| AI agents | Leave dead exports and duplicate helpers behind after refactors | Dead code, cycles, and duplicates surface in real time via hooks and MCP queries |
| AI agents | Produce code that works but doesn't fit the codebase structure | context <name> -T returns source, deps, callers, and tests — the agent writes code that fits |
| CI pipelines | Catch test failures but miss structural degradation | check --staged fails the build when blast radius or complexity thresholds are exceeded |
| Developers | Inherit a codebase and grep for hours to understand what calls what | context handleAuth -T gives the same structured view agents use |
| Architects | Draw boundary rules that erode within weeks | manifesto and boundaries enforce architecture rules on every commit |
Feature comparison
Comparison last verified: August 2026 (full re-verification of every linked repo's live README + GitHub API on 2026-08-09). Full analysis: COMPETITIVE_ANALYSIS.md
| Capability | codegraph (this repo) | code-review-graph | narsil-mcp | codegraph (other)¹ | claude-context | GitNexus |
|---|---|---|---|---|---|---|
| GitHub stars | ||||||
| Languages | 34 | 30+ | 32 | 20+ (34 named)² | 17³ | 14 |
| CLI tool | Yes (44 commands) | Yes | Partial (config/serve only)⁴ | Yes | — (MCP + library only) | Yes |
| API functionality (embeddable library) | Yes | — | — | Yes | Yes | Partial (HTTP API only)⁵ |
| Dataflow + CFG + AST querying | Yes | Call graph only | Yes | — | — | PDG opt-in, TS/JS only |
| Interprocedural dataflow (cross-function) | Yes⁶ | — | Partial (taint-only)⁷ | — | — | Partial (taint-only, opt-in)⁸ |
| Hybrid search (BM25 + semantic) | Yes | Yes | Yes (local ONNX, no key needed) | Keyword only | Yes | Yes |
| Git-aware (diff impact, co-change, branch diff) | All 3 | Partial (co-change unreliable)⁹ | Partial (no co-change/branch-diff) | — | — | Partial (no co-change) |
| Dead code / role classification | Yes | Yes | Yes | — | — | — |
| Code health (complexity metrics) | Yes (cognitive, cyclomatic, Halstead, MI) | — | Partial (cyclomatic + cognitive)¹⁰ | — | — | — |
| Incremental rebuilds | O(changed) | O(changed) | **O(changed)**¹¹ | **O(changed)**¹² | **O(changed)**¹³ | Partial (chunk cache-key)¹⁴ |
| Architecture rules + CI gate | Yes | Partial (risk-gate, no boundary rules) | Partial (layer model, no CI gate) | — | — | — |
| Security scanning (SAST / vuln detection) | Intentionally out of scope¹⁵ | — | Yes | — | — | Partial (opt-in taint, --pdg only) |
Zero config, npm install |
Yes | — (pip) | Yes | Yes | No¹⁶ | Yes |
| Runtime dependencies (direct packages)¹⁷ | 4 | 7 | 0¹⁸ | 10 | 23¹⁹ | 36 |
| Graph export (GraphML / Neo4j / DOT) | Yes | Yes²⁰ | Partial²¹ | — | — | — |
| Open source + commercial use | Yes (Apache-2.0) | Yes (MIT) | Yes (Apache-2.0/MIT) | Yes (MIT) | Yes (MIT) | Non-commercial²² |
¹ Unrelated tool sharing the name; focuses on AI token reduction via pre-indexed context, not structural analysis or CI gates. ² README says "20+ languages"; architecture docs list 34 across native + fallback grammar tiers. ³ Indexes 17 file extensions by default; AST-aware chunking covers ~10 — the rest fall back to plain text splitting. ⁴ narsil-mcp's CLI only manages config, lists tools, and serves the visualization frontend — no query commands; all graph queries require an MCP client. ⁵ GitNexus's local HTTP API (gitnexus serve, port 4747) only serves its own web UI — no importable library package. ⁶ Variable-level vertex model (arg_in/return_out/def_use) stitched across call edges — general-purpose, not just security, across all 34 languages. ⁷ trace_taint/get_typed_taint_flow cross function calls for security; general dataflow tools (get_data_flow, get_reaching_definitions) are per-function only. ⁸ Optional --pdg index (TS/JS only) adds taint source→sink tracking — security-scoped, not general cross-function flow. ⁹ Per its own README benchmark (2026-08-02), co-change eval returns 0 predicted files on every graded commit — "not yet a usable measurement." ¹⁰ get_complexity covers cyclomatic + cognitive complexity only — no Halstead metrics or maintainability index. ¹¹ Added Merkle-tree incremental indexing + watch mode (previously full re-index). ¹² OS-native file watcher reprocesses only changed files (debounced auto-sync); --force forces a full rebuild. ¹³ Merkle DAG + per-file MD5 hashing skips unchanged files, but each changed file still round-trips to the embedding provider + vector DB. ¹⁴ Cache-keyed, byte-budgeted chunk dispatch with incremental per-branch updates on checkout — finer than a full reprocess, but not per-file hashing. ¹⁵ Structural understanding, not vulnerability detection — use dedicated SAST tools (Semgrep, CodeQL, Snyk). ¹⁶ Requires an external Milvus vector DB + an embedding provider. A local keyless path exists (self-hosted Milvus + Ollama) but needs two running services; the managed path (Zilliz Cloud + OpenAI/VoyageAI/Gemini) trades that for cost. ¹⁷ Direct runtime deps declared in each project's own manifest (package.json/pyproject.toml), excluding dev/optional/transitive deps. ¹⁸ Single compiled binary — no separate packages to install. ¹⁹ mcp + core packages combined — plus the external vector DB + embedding provider noted above. ²⁰ Added GraphML, Neo4j Cypher, Obsidian vault, and SVG export. ²¹ Visualization frontend graph views, plus JSON-LD/N-Quads export for its Code Context Graph — but not GraphML or Neo4j specifically (a repo-wide code search found zero matches for either string); an internal DOT exporter exists (to_dot()) but isn't exposed via CLI or MCP. ²² PolyForm Noncommercial 1.0.0 license; separate commercial/enterprise licensing available.
What makes codegraph different
| Differentiator | In practice | |
|---|---|---|
| 🤖 | AI-first architecture | 34-tool MCP server — agents query the graph directly instead of scraping the filesystem. One call replaces 20+ grep/find/cat invocations |
| 🏷️ | Role classification | Every symbol auto-tagged as entry/core/utility/adapter/dead/leaf — agents understand a symbol's architectural role without reading surrounding code |
| 🔬 | Function-level, not just files | Traces handleAuth() → validateToken() → decryptJWT() and shows 14 callers across 9 files break if decryptJWT changes |
| ⚡ | Always-fresh graph | Three-tier change detection: journal (O(changed)) → mtime+size (O(n) stats) → hash (O(changed) reads). Sub-second rebuilds — agents work with current data |
| 💥 | Git diff impact | codegraph diff-impact shows changed functions, their callers, and full blast radius — enriched with historically coupled files from git co-change analysis. Ships with a GitHub Actions workflow |
| 🌐 | Multi-language, one graph | 34 languages in a single graph — JS/TS, Python, Go, Rust, Java, C#, PHP, Ruby, C/C++, Kotlin, Swift, Scala, Bash, HCL, Elixir, Lua, Dart, Zig, Haskell, OCaml, F#, Gleam, Clojure, Julia, R, Erlang, Solidity, Objective-C, CUDA, Groovy, Verilog — agents don't need per-language tools |
| 🧠 | Hybrid search | BM25 keyword + semantic embeddings fused via RRF — hybrid (default), semantic, or keyword mode; multi-query via "auth; token; JWT" |
| 🔬 | Dataflow + CFG | Track how data flows through and between functions — function-level edges (flows_to, returns, mutates), interprocedural variable-level edges (arg_in, return_out, def_use), and intraprocedural control flow graphs — all 34 languages |
| 🔓 | Fully local, zero cost | No API keys, no accounts, no network calls. Optionally bring your own LLM provider — your code only goes where you choose |
🚀 Quick Start
npm install -g @optave/codegraph
cd your-project
codegraph build # → .codegraph/graph.db created
That's it. The graph is ready. Now connect your AI agent.
For AI agents (primary use case)
Connect directly via MCP — your agent gets 34 tools to query the graph:
codegraph mcp # 34-tool MCP server — AI queries the graph directly
Or add codegraph to your agent's instructions (e.g. CLAUDE.md):
Before modifying code, always:
1. `codegraph where <name>` — find where the symbol lives
2. `codegraph context <name> -T` — get full context (source, deps, callers)
3. `codegraph fn-impact <name> -T` — check blast radius before editing
After modifying code:
4. `codegraph diff-impact --staged -T` — verify impact before committing
Full agent setup: AI Agent Guide · CLAUDE.md template
For developers
The same graph is available via CLI:
codegraph map # see most-connected files
codegraph query myFunc # find any function, see callers & callees
codegraph deps src/index.ts # file-level import/export map
Or install from source:
git clone https://github.com/optave/ops-codegraph-tool.git
cd codegraph && npm install && npm link
Dev builds: Pre-release tarballs are attached to GitHub Releases. Install with
npm install -g <path-to-tarball>. Note thatnpm install -g <tarball-url>does not work because npm cannot resolve optional platform-specific dependencies from a URL — download the.tgzfirst, then install from the local file.
✨ Features
| Feature | Description | |
|---|---|---|
| 🤖 | MCP server | 34-tool MCP server for AI assistants; single-repo by default, opt-in multi-repo |
| 🎯 | Deep context | context gives agents source, deps, callers, signature, and tests for a function in one call; audit --quick gives structural summaries |
| 🏷️ | Node role classification | Every symbol auto-tagged as entry/core/utility/adapter/dead/leaf based on connectivity — agents instantly know architectural role |
| 📦 | Batch querying | Accept a list of targets and return all results in one JSON payload — enables multi-agent parallel dispatch |
| 💥 | Impact analysis | Trace every file affected by a change (transitive) |
| 🧬 | Function-level tracing | Call chains, caller trees, function-level impact, and A→B pathfinding with qualified call resolution |
| 📍 | Fast lookup | where shows exactly where a symbol is defined and used — minimal, fast |
| 🔍 | Symbol search | Find any function, class, or method by name — exact match priority, relevance scoring, --file and --kind filters |
| 📁 | File dependencies | See what a file imports and what imports it |
| 📊 | Diff impact | Parse git diff, find overlapping functions, trace their callers |
| 🔗 | Co-change analysis | Analyze git history for files that always change together — surfaces hidden coupling the static graph can't see; enriches diff-impact with historically coupled files |
| 🗺️ | Module map | Bird's-eye view of your most-connected files |
| 🏗️ | Structure & hotspots | Directory cohesion scores, fan-in/fan-out hotspot detection, module boundaries |
| 🔄 | Cycle detection | Find circular dependencies at file or function level |
| 📤 | Export | DOT, Mermaid, JSON, GraphML, GraphSON, and Neo4j CSV graph export |
| 🧠 | Semantic search | Embeddings-powered natural language search with multi-query RRF ranking |
| 👀 | Watch mode | Incrementally update the graph as files change |
| ⚡ | Always fresh | Three-tier incremental detection — sub-second rebuilds even on large codebases |
| 🔬 | Data flow analysis | Intraprocedural parameter tracking, return consumers, argument flows, and mutation detection — all 34 languages |
| 🧮 | Complexity metrics | Cognitive, cyclomatic, nesting depth, Halstead, and Maintainability Index per function |
| 🏘️ | Community detection | Leiden clustering to discover natural module boundaries and architectural drift |
| 📜 | Manifesto rule engine | Configurable pass/fail rules with warn/fail thresholds for CI gates via check (exit code 1 on fail) |
| 👥 | CODEOWNERS integration | Map graph nodes to CODEOWNERS entries — see who owns each function, ownership boundaries in diff-impact |
| 💾 | Graph snapshots | snapshot save/restore for instant DB backup and rollback — checkpoint before refactoring, restore without rebuilding |
| 🔎 | Hybrid BM25 + semantic search | FTS5 keyword search + embedding-based semantic search fused via Reciprocal Rank Fusion — hybrid, semantic, or keyword modes |
| 📄 | Pagination & NDJSON streaming | Universal --limit/--offset pagination on all MCP tools and CLI commands; --ndjson for newline-delimited JSON streaming |
| 🔀 | Branch structural diff | Compare code structure between two git refs — added/removed/changed symbols with transitive caller impact |
| 🛡️ | Architecture boundaries | User-defined dependency rules between modules with onion architecture preset — violations flagged in manifesto and CI |
| ✅ | CI validation predicates | check command with configurable gates: complexity, blast radius, cycles, boundary violations — exit code 0/1 for CI |
| 📋 | Composite audit | Single audit command combining explain + impact + health metrics per function — one call instead of 3-4 |
| 🚦 | Triage queue | triage merges connectivity, hotspots, roles, and complexity into a ranked audit priority queue |
| 🔬 | Dataflow analysis | Track how data moves through and between functions — function-level (flows_to, returns, mutates) and interprocedural variable-level edges (arg_in, return_out, def_use) — all 34 languages, included by default, skip with --no-dataflow |
| 🧩 | Control flow graph | Intraprocedural CFG construction for all 34 languages — cfg command with text/DOT/Mermaid output, included by default, skip with --no-cfg |
| 🔎 | AST node querying | Stored queryable AST nodes (calls, new, string, regex, throw, await) — ast command with SQL GLOB pattern matching |
| 🧬 | Expanded node/edge types | parameter, property, constant node kinds with parent_id for sub-declaration queries; contains, parameter_of, receiver edge kinds |
| 📊 | Exports analysis | exports <file> shows all exported symbols with per-symbol consumers, re-export detection, and counts |
| 📈 | Interactive viewer | codegraph plot generates an interactive HTML graph viewer with hierarchical/force/radial layouts, complexity overlays, and drill-down |
| 🏷️ | Stable JSON schema | normalizeSymbol utility ensures consistent 7-field output (name, kind, file, line, endLine, role, fileHash) across all commands |
See docs/examples for real-world CLI and MCP usage examples.
📦 Commands
Build & Watch
codegraph build [dir] # Parse and build the dependency graph
codegraph build --no-incremental # Force full rebuild
codegraph build --dataflow # Extract data flow edges (flows_to, returns, mutates)
codegraph build --engine wasm # Force WASM engine (skip native)
codegraph watch [dir] # Watch for changes, update graph incrementally
Query & Explore
codegraph query <name> # Find a symbol — shows callers and callees
codegraph deps <file> # File imports/exports
codegraph map # Top 20 most-connected files
codegraph map -n 50 --no-tests # Top 50, excluding test files
codegraph where <name> # Where is a symbol defined and used?
codegraph where --file src/db.js # List symbols, imports, exports for a file
codegraph stats # Graph health: nodes, edges, languages, quality score
codegraph roles # Node role classification (entry, core, utility, adapter, dead, leaf)
codegraph roles --role dead -T # Find dead code (unreferenced, non-exported symbols)
codegraph roles --dynamic # Show dynamic call sink edges (eval, computed-key, unresolved)
codegraph roles --role core --file src/ # Core symbols in src/
codegraph exports src/queries.js # Per-symbol consumer analysis (who calls each export)
codegraph children <name> # List parameters, properties, constants of a symbol
Deep Context (designed for AI agents)
codegraph context <name> # Full context: source, deps, callers, signature, tests
codegraph context <name> --depth 2 --no-tests # Include callee source 2 levels deep
codegraph brief <file> # Token-efficient file summary: symbols, roles, risk tiers
codegraph audit <file> --quick # Structural summary: public API, internals, data flow
codegraph audit <function> --quick # Function summary: signature, calls, callers, tests
Impact Analysis
codegraph impact <file> # Transitive reverse dependency trace
codegraph query <name> # Function-level: callers, callees, call chain
codegraph query <name> --no-tests --depth 5
codegraph fn-impact <name> # What functions break if this one changes
codegraph path <from> <to> # Shortest path between two symbols (A calls...calls B)
codegraph path <from> <to> --reverse # Follow edges backward
codegraph path <from> <to> --depth 5 --kinds calls,imports
codegraph diff-impact # Impact of unstaged git changes
codegraph diff-impact --staged # Impact of staged changes
codegraph diff-impact HEAD~3 # Impact vs a specific ref
codegraph diff-impact main --format mermaid -T # Mermaid flowchart of blast radius
codegraph branch-compare main feature-branch # Structural diff between two refs
codegraph branch-compare main HEAD --no-tests # Symbols added/removed/changed vs main
codegraph branch-compare v2.4.0 v2.5.0 --json # JSON output for programmatic use
codegraph branch-compare main HEAD --format mermaid # Mermaid diagram of structural changes
codegraph MCP 질문
codegraph MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add ops-codegraph-tool -- npx -y @optave/codegraph를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
codegraph MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
codegraph MCP server는 몇 개의 도구를 제공하나요?
MCP server는 34개의 도구를 노출하여 AI agent가 의존성 그래프를 직접 쿼리할 수 있도록 합니다.
codegraph 사용 시 API 키나 네트워크 접속이 필요한가요?
아니요. API 키, 계정 또는 텔레메트리 없이 로컬에서 완전히 실행됩니다.
codegraph는 몇 개의 언어를 지원하나요?
34개 언어에 대해 함수 단위 의존성 그래프를 구축합니다.
codegraph를 어떻게 시작하나요?
npm 패키지를 전역으로 설치한 후 프로젝트 내부에서 build 명령어를 실행합니다.
CI에서 아키텍처 규칙을 강제할 수 있나요?
네, check 및 manifesto 명령어를 통해 exit code로 품질 및 경계 임계값을 강제할 수 있습니다.