심볼 검색, 의존성 분석 및 영향도 평가를 위해 쿼리 가능한 지식 그래프를 사용하여 AI agent가 코드베이스를 탐색할 수 있도록 합니다.
다른 이름 Nxtsoft/CGraph, cgraph-mcp
- 스타
- 2
- Tools
- —
- 다운로드, 30일
- —
- 최신 버전
- 0.9.7
- 마지막 커밋
- 2026년 10월 21일
- 라이선스
- MIT
CGraph MCP란?
CGraph은(는) MCP server입니다. 심볼 검색, 의존성 분석 및 영향도 평가를 위해 쿼리 가능한 지식 그래프를 사용하여 AI agent가 코드베이스를 탐색할 수 있도록 합니다.
프로젝트 README에서 생성된 요약
CGraph MCP server 정보
CGraph는 대규모 코드베이스를 쿼리 가능한 지식 그래프로 변환하여 AI agent가 복잡한 구조를 탐색할 수 있도록 돕습니다. 단순한 텍스트 검색에 의존하는 대신 심볼 간의 결정론적 관계를 추출하므로, agent가 서로 다른 파일과 모듈이 어떻게 상호작용하는지 이해할 수 있습니다. 이 도구는 Claude 또는 Codex와 같은 코딩 agent를 사용하는 개발자를 위해 설계되었으며, 아키텍처 관련 질문에 답하기 위해 수십 개의 파일을 일일이 읽을 필요가 없도록 구조적 지도를 제공합니다.
시스템은 스캐닝을 위한 원샷 CLI, 실시간 파일 감시를 위한 상주 데몬, 전용 MCP server를 포함한 여러 구성 요소로 작동합니다. 사용자는 의존성 분석을 위한 graph_impact 또는 관련 코드 스니펫을 가져오기 위한 graph_context와 같은 도구를 통해 그래프와 상호작용할 수 있습니다. 엔진은 tree-sitter를 사용하여 구조를 추출하며 C++, Python, Go, TypeScript를 포함한 광범위한 언어를 지원합니다. 그래프가 미리 계산되어 있기 때문에 쿼리가 약 10 ms 내에 처리되어 실시간 agent 추론에 매우 효율적입니다.
활용 사례
- 1코드 변경 영향도 분석AI agent가 특정 심볼의 모든 전이적 의존성을 식별하여 변경 시 영향을 받는 범위를 결정할 수 있습니다.
- 2리포지토리 아키텍처 파악개발자는 커뮤니티 탐지(community detection)를 사용하여 대규모 리포지토리를 별개의 모듈로 자동 클러스터링할 수 있습니다.
- 3agent 컨텍스트 사용 최적화파일 전체를 읽는 대신, agent가 토큰 예산에 맞춘 특정 소스 번들을 요청하여 컨텍스트 창 공간을 절약할 수 있습니다.
- 4핵심 코드 허브 식별중심성 순위(centrality ranking)를 사용하여 거대한 코드베이스 내에서 가장 중요한 핵심 파일을 찾을 수 있습니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
CGraph MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 CGraph MCP 설치
$ claude mcp add cgraph -- npx -y cgraph-mcpCursor에 CGraph MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"cgraph": {
"command": "npx",
"args": [
"-y",
"cgraph-mcp"
]
}
}
}VS Code에 CGraph MCP 설치
.vscode/mcp.json
{
"servers": {
"cgraph": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"cgraph-mcp"
]
}
}
}VS Code CLI에 CGraph MCP 설치
$ code --add-mcp '{"name":"cgraph","type":"stdio","command":"npx","args":["-y","cgraph-mcp"]}'Claude Desktop에 CGraph MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"cgraph": {
"command": "npx",
"args": [
"-y",
"cgraph-mcp"
]
}
}
}Codex에 CGraph MCP 설치
$ codex mcp add cgraph -- npx -y cgraph-mcpCodex config.toml에 CGraph MCP 설치
~/.codex/config.toml
[mcp_servers.cgraph] command = "npx" args = ["-y", "cgraph-mcp"]
Gemini CLI에 CGraph MCP 설치
$ gemini mcp add -s user cgraph npx -- -y cgraph-mcpGemini settings.json에 CGraph MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"cgraph": {
"command": "npx",
"args": [
"-y",
"cgraph-mcp"
]
}
}
}구성
CGRAPH_CLIENTCGRAPH_PROJECT_ROOTVCPKG_ROOT
| 이름 | 설명 | 유형 |
|---|---|---|
| CGRAPH_CLIENT | — | |
| CGRAPH_PROJECT_ROOT | — | |
| VCPKG_ROOT | — |
자동 검사
2026년 11월 13일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능nxtsoft/cgraph is public and reachablegithub.com/nxtsoft/cgraph ↗통과
- 패키지가 이 저장소를 소스로 명시cgraph-mcp names nxtsoft/cgraph as sourcenpmjs.com/package/cgraph-mcp ↗통과
- 빌드 출처(Sigstore 증명)No build attestation published for this release검사되지 않음
- 오픈 소스 라이선스 (OSI)MITspdx.org/licenses/MIT.html ↗통과
- 최근 1년 내 커밋 또는 릴리스Last commit or release 2026-10-21github.com/nxtsoft/cgraph ↗통과
- OpenSSF Scorecard검사되지 않음
- 패키지 이름이 인기 패키지와 유사하지 않음No popular package one edit away from cgraph-mcp통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음1 resolved dependencies checked; no critical advisoryosv.dev ↗통과
- 모델에 대한 숨겨진 지침 없음0 tool descriptions and the README read; no override phrases, credential paths or hidden characters통과
- 파괴적인 도구에 라벨 표시됨검사되지 않음
- 원격 엔드포인트가 MCP 핸드셰이크에 응답검사되지 않음
README
GitHub에서 보기English · 简体中文
Scan a project · extract structure into a deterministic graph · query it in ~10 ms from a daemon, a thin client, or an MCP server.
Contents
Why CGraph? · Architecture · Repository layout · What it produces · Output formats · Performance · Retrieval benchmark · Languages · Quick start · Install & Setup · Use with coding agents · CLI · daemon · MCP reference · Host integrations & enrichment · Development notes · Contributing · License
Why CGraph?
Reading a large repo to answer "what calls this?" or "what breaks if I change it?" means loading dozens of files — and those answers aren't in any single file. They live in the relationships between files. CGraph precomputes them so you (and your AI agent) navigate by graph, not grep.
| 🔗 Reverse dependencies & blast radius | graph_impact returns every transitive dependent of a symbol in ~10 ms. On a real 10,706-node repo it surfaced 93 dependents of one god-file, instantly — an answer grep can't give you. |
| 🧭 Navigate, don't grep | Centrality-ranked search, node neighborhoods, shortest paths, and token-budgeted source bundles — served warm in ~10 ms instead of many file reads that burn context. |
| 🏛️ Architecture at a glance | Centrality ranking surfaces the load-bearing files; Leiden/Louvain community detection clusters the repo into modules automatically. |
| ⚡ Deterministic & fast | A full 10k-node graph builds in ~2 s; no LLM in the extraction path — same input, same graph, every time. |
| 🤖 Built for coding agents | A standard MCP server drops the graph straight into Claude / Codex, so they reason over structure instead of blindly reading files. |
The pitch in one line: for a codebase too big to hold in your head, CGraph is the index that decides which code to read —
ctags/"find all references", precomputed, centrality-ranked, and exposed over MCP.
Architecture
cgraph— one-shot scan → portable disk exports (graph.json,graph.html,graph.svg,obsidian.md,cypher.txt,modules.mmd,modules.svg,design.mmd,design.md).graphd+cgraph-client— a resident per-project daemon with live file-watching; warmquery/path/explain/impact/contextin ~10 ms.cgraph-mcp— a Model Context Protocol server so agents navigate the graph directly.
The engine owns deterministic extraction, fragment validation, cache state, and local graph mutation; hosts own model choice and semantic enrichment.
Repository layout
src/cli/ One-shot CLI entrypoint: cgraph
src/daemon/ Daemon entrypoint: graphd
src/client/ Thin client runtime and cgraph-client executable
src/mcp/ MCP request handling and cgraph-mcp executable
src/engine/ Detection, extraction, graph building, analysis, daemon ops
tests/smoke/ CTest smoke coverage for engine, daemon, MCP, and integration paths
tests/fuzz/ Optional libFuzzer targets
integrations/ Host hook and always-on integration scripts
docs/ Host integration contract and benchmark notes
vendor/ Vendored tree-sitter core and grammars
What it produces
A single scan turns a source tree into an interactive, explorable graph — communities colored, hubs sized by centrality:
The real graph.html viewer on a 10,708-node / 28,945-edge codebase — self-contained HTML, no external JS.
Output formats
graph.json— directed node-link JSON with graph metadata, nodes, and links. Node ids derive from each file's path relative to the project root, so the same commit built from two checkouts yields the same ids and two graphs can be joined by id;source_filestays the path the graph was read fromgraph.html— browser-readable interactive graph viewgraph.svg— static graph visualizationobsidian.md— markdown export for Obsidian-style navigationcypher.txt— Neo4j Cypher statementsmodules.mmd— module dependency diagram as Mermaidmodules.svg— module dependency diagram as a layered static imagedesign.mmd— entry points and their top call flows as a Mermaidflowchart TDdesign.md— the same as Markdown: entry-point table, nested flows, layers by call distance
Performance
The interactive viewer used to run an O(N²) force simulation in the browser on every open. Layout is now precomputed once in C++ (via igraph), and repaints are viewport-culled — both dependency-free:
| graph | time-to-settle before | after | per-frame repaint |
|---|---|---|---|
| 10,000 nodes | 35.2 s (main thread pinned) | ~0 ms (static layout) | 20–34× cheaper (zoom/pan) |
Retrieval benchmark
CGraph has been scored on Agent Retrieval Bench: 427 samples from 25 repositories, each checked out at its base commit, scored with the benchmark's own metric code. The table covers all 345 positive samples.
| Method | Recall@20 | MRR | BCY@8k |
|---|---|---|---|
| CGraph bin-v0.9.1 (label + code-text search) | 0.6362 | 0.2787 | 0.4319 |
| CGraph bin-v0.8.3 (label-only text search) | 0.5726 | 0.2356 | 0.3790 |
| RepoMap (published) | 0.6333 | 0.2158 | 0.3788 |
| RepoMap (rerun on this harness) | 0.6311 | 0.2156 | 0.3846 |
| Qwen3-Embedding-8B (published) | 0.7029 | 0.2336 | 0.3732 |
| Qwen3-Embedding-4B (published) | 0.6306 | 0.2379 | 0.3409 |
| BM25 (published) | 0.4452 | 0.1520 | 0.2051 |
How bin-v0.9.1 compares:
- Recall@20. Level with RepoMap (the difference is inside run-to-run noise of about 0.006). Below Qwen3-Embedding-8B. Above the other published single methods.
- MRR. Higher than every published single method.
- BCY@8k. Higher than every published single method, by more than the noise floor.
- Against the paper's fusion of Qwen3-Embedding-8B and RepoMap, on the 287-sample core it reports: MRR is level (the fusion scores only its top 20; CGraph's MRR over its top 20 is 0.276 vs 0.271, inside the noise floor); Recall@20 (0.633 vs 0.733) and BCY@8k (0.440 vs 0.488) are lower.
- Abstention. CGraph does not abstain on no-gold samples.
Per-task tables, pins, the noise floor and caveats are in
bench/arb/RESULTS.md. Reproduce with bench/arb/run.sh.
Languages
Tree-sitter-backed structural extraction, with regex/structured extraction for a few config formats:
Plus structured/regex extraction for Apex, Delphi form/source, MSBuild/XML project files, and MCP config files.
Type members
Seven languages emit a field node per declared member, with a defines edge from the owner:
| Language | Owners with members | Field properties |
|---|---|---|
| C, C++ | class, struct only — not enum or union |
none |
| TypeScript, TSX | interface, object type alias, class (constructor parameter properties included), enum | type_text, optional, readonly |
| Go | struct, including multi-name and embedded fields | type_text |
| Rust | named and tuple struct, union, enum variant, trait associated type and constant | type_text |
| Python | class-body assignment, including chained and tuple targets | type_text when annotated |
| Java | class, record, enum | type_text, readonly |
Members are declared members only: no inherited-member expansion, no alias flattening, no runtime
attribute inference. A declaration that is already a node of its own — a TypeScript
method_signature, a Rust trait method or type alias — keeps its function or type node and is not
also a field. A field never takes the id a function or type holds; it moves instead, so a symbol's
id stays stable.
A class-like declaration without a body (struct FileCacheEntry;) is a forward declaration and mints
no node; only the body-bearing definition does.
Fields are members, not navigation targets: graph_context packs the owner (whose snippet spans its
members) rather than the members, and report modules symbol counts exclude them.
HTTP endpoints
JavaScript and TypeScript services get one endpoint node per route the code serves, with the
full path composed across files: an Elysia, Express or Hono chain's own prefix (new Elysia({ prefix: '/notebooks' }), .basePath('/v1')) beneath every .use(child), .use('/p', child) or
.route('/p', child) that mounts it, up to the top-level chain, read through as any and
as unknown as T casts and resolved through imports (aliased ones included). A chain built inline
inside .use(new Elysia({ prefix }).get(…)), a .group('/v2', app => app.get(…)) or .guard()
callback, and a module re-exported as export const deckModule = deckRoutes as unknown as Elysia
all compose the same way. A Next.js app/api/x/[id]/route.ts exporting GET is GET /api/x/:id.
A repository holding a langgraph.json with a non-empty graphs object is a LangGraph Agent
Server: its 49 framework routes (POST /runs/wait, POST /threads/{thread_id}/runs/stream,
GET /assistants/{assistant_id}, ..., the table @langchain/langgraph-api 1.5.1 registers, less its four crons routes, which answer 500 "Not implemented"; see
https://docs.langchain.com/langsmith/server-api-ref) are served endpoints handled by a
langgraph_server node spanning that object, with one langgraph_graph node per graph. A group
the config switches off (http.disable_runs, disable_store, ...) is not served.
Kotlin and Java Spring controllers get the same nodes: a method annotated @GetMapping("/{id}")
(or @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping, or @RequestMapping with a
method) under a class-level @RequestMapping("/api/v1/users") is GET /api/v1/users/{id}.
Paths are read from string literals only (positional, value =, path =, or an array of them); a
path built from a constant, and a method-level @RequestMapping without method, are not minted.
A Spring Boot application whose build.gradle(.kts) or pom.xml applies the Boot plugin (not
apply false; Maven: the Boot parent, or the plugin outside <pluginManagement>, packaging not
pom) and depends on spring-boot-starter-actuator and a web starter serves the Actuator
endpoints its src/main/resources/application[-profile].{yml,yaml,properties} expose: health
by default, else management.endpoints.web.exposure.include less exclude, under
management.endpoints.web.base-path (default /actuator), with the discovery page, health
groups, per-endpoint access, and prometheus / caches only with the Prometheus registry / the
cache module. The liveness and readiness groups are on by default for Boot 4 (unless
probes.enabled is false) and only when it is true for Boot 3 or an unknown version. Where they
sit follows Boot's ManagementPortType: a negative management.server.port or
spring.main.web-application-type: none serves nothing; the same port puts them under the context
path; another port under management.server.base-path. The endpoints are the union over the base
config and each profile, handled by the actuator_exposure node at the include line that won
(or the build file's spring_actuator node when nothing sets it). Endpoints that need another bean
or dependency, profile expressions, placeholders without a default, and YAML anchors, aliases,
tags or flow mappings on the deciding keys are not modeled (those configurations serve nothing);
see spring_actuator.hpp.
Python FastAPI services get them too: a function decorated @router.post("/{project_id}/setup")
(or .get, .put, .patch, .delete, .head, .options, or .api_route(path, methods=[...]),
which defaults to GET) on a module-level router = APIRouter(prefix="/project") or app = FastAPI() is POST /project/{project_id}/setup beneath every include_router(router, prefix="/v1") or app.mount("/v1", sub_app) that mounts it, composed across files through
imports: from api.routes.x import router as x_router (the alias is the only name bound),
from app.routers import users then include_router(users.router) (a submodule), import app.routers.items as items then include_router(items.router), a router a package's
__init__.py imports and another file imports from the package, and each router of a
for r in (users.router, items.router): app.include_router(r) loop over a literal tuple or list.
A path, prefix or methods list that is not a plain string literal (an f-string that
interpolates, prefix=settings.PREFIX), a route or include_router inside a function (an app
factory), and an include_router on anything but a module-level router of its file
(app = create_app(), app.router, self.app, a router imported from another file) are not
minted and are counted in routes_unresolved / mounts_unresolved; a router whose every mount is
one of those mints nothing. A loop over anything else (for r in ROUTERS:) is counted unresolved
without identifying its routers. A router nothing mounts is served at its own prefix, as a
JavaScript router is. add_api_route(...) is not read, and a mount of a longer dotted name
(include_router(api.v1.router)) is counted unresolved without placing its router. Flask is not
read: register_blueprint(url_prefix=) replaces the blueprint's own prefix rather than composing
with it.
The node's id is endpoint:GET /api/v1/notebooks/{}/notes with no repository in it and {} for
every parameter segment (:id, {id}, [id]), its label keeps the provider's spelling
(GET /api/v1/notebooks/:id/notes), and it carries method and path, the handler's file and
span, a contains edge from that file and a handled_by edge to the handler, so graph_impact
on a handler reaches its endpoint. Chains mounted twice serve their routes twice; a route on a
router the file only receives as a function parameter (function register(app) { app.get(…) })
is not minted, and stats.json counts it under route_resolution.routes_unresolved.
Database tables join the same walk. Every CREATE TABLE in a repo's .sql migrations is a
sql_table node, and a Drizzle model declared with a literal name (export const competitors = pgTable('competitors', …), likewise mysqlTable and sqliteTable) gets a maps_table edge to the
table of that name. A dependents walk that reaches a file through an import, or from a
module-level value it declares, also reaches the endpoints the file serves, so graph_impact on
sql_table_competitors goes table, model, the services importing it, their route files, and the
routes. A path through a function, class or endpoint does not serve routes, whether it climbs to
the function's own file or follows an import of the function (and on to the app file that mounts
the route file): a changed function reaches the routes it affects through the calls into their
handlers, not every route nearby. A seam service node is listed when reached but not walked
through, so one consumer edge into it does not pull in every endpoint of that service.
The callers are in the graph too. A fetch(\${API_URL}/api/v1/projects/${id}/publish`, { method:
'POST' }), an openapi-fetch api.GET('/api/v1/projects/{id}', …), an axios.post(…), and a call through a path wrapper (apiFetch(path)whose ownfetch(`${base}${path}`)appends a parameter to a module constant) each give the calling function (or the module-level object the arrow initialises) aCONSUMESedge toendpoint: . The host interpolation is dropped (except a call that takes a runtime value, such as ${base(id)}/x, a URL builder that may hold part of the path, which leaves the request unresolved unless the builder is a function of the same file, which is read), a whole-segment interpolation is {}, the method comes from the call's literal method option, the wrapper's own, or the client verb, else GET. What one file says for certain is read through: a URL held in a local (const url = `${BASE}/x`, new URL(...)thenurl.toString(), a let set per branch), a class field prefix (${this.API_BASE}/v1/...), an axios instance's baseURL (this.api.get('v1/users')underbaseURL: '/api/backend'), a class-method wrapper (this.patch(`v1/users/${id}/enable`)), and a wrapper whose path or method is a later parameter (mlBackendRequest('POST', `/project/${id}/setup`), a method parameter's default applying when a call leaves it out). When this repository does not serve the route the node is minted with served: false and no source; when it does (a Next.js route file fetched from the same app) the one node has both a handler and its callers. A URL whose value the file cannot read, a method a call does not spell out, a relative path (v1/users) with no base ending in /to join it to, or an absolutehttps://literal adds nothing and is counted underroute_resolution.calls_unresolved. Kotlin and Go clients consume the same way: a Ktor client.patch("$baseUrl/api/v1/sessions/$id/invalidate") { … } on a receiver whose name ends like a client (client, httpClient, api; not clientsorhttpCache), Go's http.Get(url)andhttp.NewRequest(method, url, body), and any Go call passing a context, then a method (http.MethodPostor"POST"), then a path, such as c.Do(ctx, http.MethodGet,
"/api/v1/auth/me", nil). A Go route registration (r.Handle(http.MethodGet, "/x", h)), a call with a funcliteral argument,httptestand an assertion onr.Methodcarry no context or a handler, and are no requests. The leading$baseUrl of a Ktor URL is the host; a Go client method's path is relative to its own base, so a value in front of it (n.Base+"/import") leaves the call unresolved. A function whose request appends one of its parameters (postAuth(ctx, path, req)callingc.Do(ctx, http.MethodPost, path, body), or client.post("$baseUrl$path"), also from inside a lambda such as withContext(…) { … }) is a wrapper, and a call to it in the same file with a path literal (c.postAuth(ctx, "/api/v1/auth/login", req), postLoginOutcome(path = "/api/v1/…")) consumes the joined route. A Ktor client.request(url) { method = … }sets its verb in the builder and is counted unresolved. Because the id carries no repository, two graphs built separately share their endpoint nodes.seam fuse scopes every other node id by its service (api::src_db_client_ts`), so two repositories with the same relative file stay two nodes:
cgraph seam discover --graph api=api-out/graph.json --graph web=web-out/graph.json --out seam-drop
cgraph seam fuse --seam seam-drop/chunk_00.json --graph api=api-out/graph.json --graph web=web-out/graph.json --out fused
seam discover writes the seam fragment from what each graph serves (SERVED_BY, HANDLED_BY),
consumes (CONSUMES, CONSUMED_AT) and documents (DOCUMENTED_IN) with no hand-written spec,
and reports how many endpoints matched across services, how many are consumed with no provider
among the graphs, and, when a graph carries a contract document, the drift: endpoints the
document promises that no service serves, and endpoints served that no document mentions.
A front end that reaches its backend through its own catch-all proxy (idp-front-end calls
/api/backend/v1/users/{id}; its app/api/backend/[...path]/route.ts forwards to
${BACKEND_URL}/api/v1/users/{id}) names that with --prefix REPO:/from=/to on both seam discover
and seam fuse (--prefix web:/api/backend=/api). An endpoint web consumes but does not serve,
under /api/backend, then joins the provider's /api/... endpoint; its CONSUMED_AT edge keeps
the consumer's own path as via, and the log counts the endpoints each prefix joined. A route the
front end serves itself (/api/backend/healthz) is never mapped, and a proxied path only the front
end serves is not joined. Each repository's own graph keeps its own spelling. The forwarding target
is not read from the proxy's code: it is built at run time from the handler's parameters, so it is
declared, not guessed.
Contracts other than endpoints are recorded by extractors as provides_contract /
uses_contract facts: header:<name> (case-folded), claim:<name>, env:<NAME>, DynamoDB tables
as dynamo:<name>, gRPC methods as grpc:<Service>/<Method>, message topics and queues as
topic:<broker>:<name>, and tables and graph labels as table:<database>:<name> /
label:<database>:<name>. They do not all join alike:
- Claims and non-standard headers (
x-tenant-id) join like endpoints, by id. A standard HTTP header (authorization,content-type, any IANA permanent field name,x-request-id,x-forwarded-*,traceparent) never joins: every service uses those for its own reasons. Nor does a standard JWT claim, which any issuer writes with the same meaning (iss,sub,exp,email,name,scope,client_id: the IANA JWT Claims registry's RFC 7519, OpenID Connect, RFC 7800, RFC 8693 and RFC 9449 names); application claims (roles,tenant_id,session_id) do. A claim name alone does not say whose token it is in, so the reposito
CGraph MCP 질문
CGraph MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add cgraph -- npx -y cgraph-mcp를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
CGraph MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
그래프 검색 속도는 어느 정도인가요?
영향도 및 경로 분석과 같은 쿼리는 데몬 또는 MCP server에서 약 10 ms 내에 처리됩니다.
CGraph는 코드 구조를 추출할 때 LLM을 사용하나요?
아니요, 추출 프로세스는 결정론적이며 추출 과정에서 LLM을 사용하지 않습니다.
지원되는 프로그래밍 언어는 무엇인가요?
tree-sitter를 통해 C, C++, C#, Go, Java, JavaScript, Python, Rust, Scala, TypeScript 등 다양한 언어를 지원합니다.