What it does
Call graphs, blast radius and API-breakage gates. Every answer reports its own completeness.
- Connects 내 컴퓨터에서 실행
- Account or key No key needed
- Category 개발자 도구
함께 쓰기
이런 작업을 AI에게 가르치는 Skill, 이것과 함께 쓸 수 있습니다
andrej-karpathy-skills
A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy's observations on LLM coding pitfalls.
graphify
Turn any codebase, with its docs, SQL schemas, configs, and PDFs, into a queryable knowledge graph. A /graphify skill for Claude Code, Cursor, Codex, and Gemini CLI: local deterministic AST parsing, every edge explained, no vector store.
이 순위인 이유
목록은 사용 점수(100점 만점)로 정렬되며 구성은 다음과 같습니다
| 인기 | 7/80 | GitHub 별 또는 주간 다운로드: 큰 쪽 60, 작은 쪽 20 |
|---|---|---|
| 최신성 | 12/12 | 30일 안에 릴리스나 코드 변경이 있으면 만점 |
| 응답 중 | 0/8 | 마지막 점검 때 클라우드 엔드포인트가 응답 |
| 사용 점수 | 19/100 |
품질: 기본 점검 3/3개 통과(표시만, 정렬에는 안 씀) · 상승세: 데이터 없음 (급상승 탭에서만 사용)
설치
쓰고 있는 AI 앱을 고른 다음 설정을 복사하세요.
검사 3/3 통과 · 내 컴퓨터에서 실행돼요
먼저: 어떤 AI를 쓰시나요?
쓰는 앱을 고르면 아래에 단계가 나옵니다.
Claude는 아직 ctx — queryable code graph에 연결할 수 없어요
제작자가 아직 MCP 레지스트리에 설치 방법을 올리지 않았어요
ChatGPT는 아직 ctx — queryable code graph에 연결할 수 없어요
제작자가 아직 MCP 레지스트리에 설치 방법을 올리지 않았어요
대신 이렇게 할 수 있어요
B · 개발자 도구에서 ChatGPT에 연결되는 다른 서버
같은 분류에서 많이 쓰는 것 중 키 없이 주소만으로 연결되는 것을 골랐어요
- Sentry✓ ChatGPT
- Compiler Explorer✓ ChatGPT
- GitDiagram✓ ChatGPT
Claude Code는 아직 ctx — queryable code graph에 연결할 수 없어요
제작자가 아직 MCP 레지스트리에 설치 방법을 올리지 않았어요
Cursor는 아직 ctx — queryable code graph에 연결할 수 없어요
제작자가 아직 MCP 레지스트리에 설치 방법을 올리지 않았어요
VS Code는 아직 ctx — queryable code graph에 연결할 수 없어요
제작자가 아직 MCP 레지스트리에 설치 방법을 올리지 않았어요
한눈에 보기
- 주간 다운로드i
- npm/PyPI에 없음
- 연결 방식
- 내 컴퓨터에서 실행
- 최신 버전i
- 0.28.1
- 레지스트리 공개i
- 2026년 11월 16일
- 코드 마지막 변경i
- 2026년 11월 18일
- 제작자
- Eagle-Logic
- 패키지
cargo: code-context- 웹사이트
- github.com
- 레지스트리 상태
- 활성
어떤 앱에서 쓸 수 있나요
이 서버의 연결 방식과 각 앱의 공식 문서를 바탕으로 했어요. 2026년 11월 10일 확인.
내 컴퓨터에서 실행하는 앱
GooseLM StudioMsty StudioCherry StudioVisual StudioWindsurf (Devin Desktop)ZedKiroClineContinueJetBrains AI AssistantCodex CLIGemini CLIOpenCodenodecodeWarpLibreChatRaycast
할 수 있는 일
내 컴퓨터에서 실행돼요. 설치하면 AI 앱에 도구 목록이 나타나요.
기본 점검i
누구나 볼 수 있는 정보를 점검했고, 코드는 읽지 않았어요. 해당하지 않는 항목은 개수에서 뺐어요. · 2026년 11월 19일 점검
- ✓ 통과
제작자와 저장소 일치
레지스트리 이름이 GitHub 계정 Eagle-Logic 기준으로 확인되었고, 이 계정이 저장소를 소유하고 있어요
- ✓ 통과
계속 관리되고 있음
코드 마지막 변경: 어제
- ✓ 통과
라이선스 있음
MIT 사용
- – 해당 없음
엔드포인트 응답
내 컴퓨터에서 실행되는 서버라 인터넷 엔드포인트가 없어요
- – 해당 없음
OAuth로 로그인
내 컴퓨터에서 실행되며, 대신 로컬 설정을 사용해요
- … 아직 점검 안 함
도구 설명에 숨겨진 지시 없음
내 컴퓨터에서 실행돼요. 도구 목록은 인터넷 엔드포인트가 있는 서버에서만 읽을 수 있어요
제작자: 재확인 요청 또는 잘못된 정보 신고
제작자용: README에 배지 달기
제작자라면 이 코드를 README에 붙여 넣으세요. 배지는 이 페이지로 연결됩니다.
[](https://mcp.popnx.com/en/servers/eagle-logic-ctx)토론
질문하고, 팁을 나누고, 안 되는 점을 알려 주세요. "도움이 됨"이 많은 순서예요.
사용자 리뷰
아직 리뷰가 없어요
개발자 도구 카테고리의 다른 서버와 비교i
- 이 카테고리의 다른 서버 6182개 중 81%보다 스타가 많아요
- 이 카테고리의 다른 서버 6182개 중 89%보다 최근에 레지스트리에 공개됐어요
- 기본 점검 결과가 이 카테고리의 다른 서버 6182개 중 99%와 같거나 더 좋아요
레지스트리에서 이 카테고리의 활성 서버 전체와 비교했어요. 스타는 게시자가 저장소를 소유한 경우에만 세요.
자주 묻는 질문
ctx — queryable code graph, 안전한가요?
해당하는 기본 점검 3개 중 3개를 통과했어요. 코드는 읽지 않았어요. 키나 토큰을 넣기 전에 서버가 어떤 권한을 요구하는지 확인하고, 꼭 필요한 권한만 있는 키를 쓰세요.
어떤 키나 코드가 필요한가요?
레지스트리에 필수 키가 나와 있지 않아요. 다만 처음 쓸 때 로그인을 요구하는 서버도 있어요.
내 컴퓨터에서 실행되나요, 클라우드에서 실행되나요?
내 컴퓨터에서 실행돼요. AI 앱이 필요할 때 실행하고, 데이터는 제작자의 서버를 거치지 않아요(서버 자체가 온라인 서비스를 호출하는 경우는 제외).
아직 관리되고 있나요?
GitHub 저장소는 마지막으로 어제 변경됐고, 최신 버전(0.28.1)은 3일 전 레지스트리에 올라왔어요.
어떤 앱에서 쓸 수 있나요?
Claude Desktop, Claude Code, Cursor, VS Code처럼 MCP를 지원하는 앱에서 쓸 수 있어요. 내 컴퓨터에 Rust도 있어야 해요.
대신 쓸 수 있는 건 뭐가 있나요?
같은 카테고리에는: GitDiagram, Appllama, Cloudflare MCP, Omnara, Repowise
비슷하게 동작하는 다른 것
같은 카테고리, 다른 제작자, 명령 확인 완료. 공식이 먼저, 그다음 스타 순.
카드 보는 법:↓ 주간 다운로드i★ GitHub 스타i세 기둥: 리뷰 · 점검 · 사용 정도i업데이트 = 최신 버전을 레지스트리에 공개한 날i
GitDiagram
Architecture diagrams, explanations and Mermaid source for public GitHub repositories.
Appllama
Study screens, flows and paywalls from top-earning iOS apps, then build from what wins.
Omnara
Deploy durable AI agents with Omnara, an open-source managed-agent platform.
Repowise
Codebase intelligence for AI coding agents: graph, git history, docs, decisions, code health.
| 이 항목 ctx — queryable code graph | GitDiagram | Appllama | Cloudflare MCP | Omnara | Repowise | |
|---|---|---|---|---|---|---|
| 실행 위치 | 컴퓨터에 설치 필요 | 클라우드에서 동작, 설치 불필요 | 클라우드에서 동작, 설치 불필요 | 클라우드에서 동작, 설치 불필요 | 클라우드에서 동작, 설치 불필요 | 클라우드 또는 컴퓨터 설치 모두 가능 |
| 키 필요 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| Claude에서 +로 추가 | 아니요 | 아니요 | 아니요 | 예 | 아니요 | 아니요 |
| 기본 점검 | 3/3 | 4/4 | 4/4 | 4/4 | 4/4 | 5/5 |
| 라이선스 | MIT | MIT | MIT | Apache-2.0 | Apache-2.0 | AGPL-3.0 |
| 가격 | 등록 정보에 비용 없음 | 등록 정보에 비용 없음 | 등록 정보에 비용 없음 | 등록 정보에 비용 없음 | 등록 정보에 비용 없음 | 등록 정보에 비용 없음 |
제작자의 README
README 열기
제작자의 저장소에서 쓰인 그대로 가져왔어요. PopNx MCP가 검토하거나 보증한 내용이 아니에요. HTML, 이미지, 스크립트는 제거했어요. 링크를 누르면 이 사이트를 벗어나요.
ctx
*The binary is ctx. The crate is code-context (ctx was taken on crates.io in 2017).*
A queryable code graph for coding agents. Not a map you paste at boot — a set of queries an agent runs mid-task: *who calls this, how does execution get here, what breaks if I change it, what must a move touch, does my port still match the original.*
One Rust binary. Tree-sitter for Rust, Python, TypeScript/TSX, JavaScript/JSX, Go, Java, and Markdown. No language servers, no embeddings, no index to warm. The graph is a pure function of the source tree — same code in, same answer out — and it builds in ~100 ms, so every query runs against current source.
$ ctx callers resolve_call
1 caller(s) of 'resolve_call':
extract::Walk::rec (src/extract/mod.rs:2368-2462 #ab0418a77d9f) → resolve_call
completeness: no call site named resolve_call went unresolved anywhere in this tree — this blast radius is complete to the limit of what ctx parses. At least 1005 undescended region(s) in this tree were not read; see ctx doctor.
That last line is the whole idea, and it does two jobs. It claims completeness for what ctx read, and it bounds that claim by counting what it never read — macro bodies and static/const initializers, whose contents are not parsed as code. A call hiding in one is absent rather than unresolved, so nothing else would have revealed it. Every other code graph tells you what it found. `ctx` tells you what it missed — per edge, in aggregate, and with the grep list to check it yourself.
It matters because the failure mode of a code graph is silent. A blast radius that comes back short reads exactly like a blast radius that is complete, and an agent cannot tell the difference — so it changes the signature and ships the break. Every tool in this space has gaps; this one is built so you can enumerate them.
→ [EXAMPLES.md](EXAMPLES.md) — ten commands run against this repo, verbatim output, including the parts where ctx reports its own limits.
→ [BENCHMARK.md](BENCHMARK.md) — the same claims re-run on six public repositories pinned to exact commits, reproducible with ./bench/run.sh. Including the row where it finds a limitation in ctx.
→ [What the integration itself costs](#measuring-what-it-costs) — ctx's own MCP tool definitions sit in every turn whether a tool is ever called or not, which makes them 3.0× the standing cost of the CLI instructions block. That is the shape this project objects to, measured on itself.
Four things you won't find elsewhere
1. Every edge tells you how much to trust it
Every static analyzer guesses. ctx is the one that says where.
An edge backed by a resolved import, a path, a self receiver, or a declared type is unmarked — rely on it. An edge inferred from an *opaque* receiver (expr.method(), where nothing in the source states the type) is marked ~. A branch of a dynamic-dispatch fan-out is marked *. And ctx doctor names every callee it could not pin at all, with counts:
## Internal recall — the number to trust
1521/1606 = 94.7% of call sites that could be internal, ctx pinned this many.
What ctx missed (callee names that exist here but went unpinned)
grep these; every other edge in the map is one ctx could prove. 50 walk 11 context 8 group 4 est_tokens
Low-confidence zones (edges to distrust — grep to confirm)
parity 18% heuristic (11/61 edges) main 7% heuristic (9/127 edges) refactor 5% heuristic (1/20 edges) extract 2% heuristic (4/235 edges)
The recall number comes with the exact grep list for everything it doesn't cover. The denominator is honest too: a call into std or a third-party crate is excluded, because no internal edge could exist for it however good the resolver gets — and that classification is by evidence (is this name defined anywhere under the root?), not a hardcoded list.
Heuristic method attribution is also language-scoped. A unique method name is evidence only within one language; across languages it is coincidence, so tok.apply_chat_template(...) in Python is never attributed to a Rust method of the same name. Before that guard, 45 of 50 reported callers of that name were artifacts and ~18% of module dep edges were impossible Python→Rust edges — which then distorted core's ranking.
The honest bit isn't that coverage is high. It's that the gaps are enumerable.
That property is not decoration — it is how this tool gets built. Go support went from 36.8% to 89.6% internal recall on go-chi/chi in six steps, and every step was a class of call site the census had already named by count: package scope spanning files, constructor return types, calls leaving through an external import, a func literal shadowing its enclosing scope, the /vN in a module path binding the wrong package name, and method chains. Not one of those was visible in the aggregate number. Each was one line in *What ctx missed*, with the grep to confirm it.
A tool that reported only "36.8%" would have told you it was bad without telling you why, which is the position every other code graph leaves you in.
2. changed --api — a breaking-change gate that names who breaks
Builds the public API surface at a base ref (in a throwaway detached worktree) and in the working tree, then reports what was removed or whose signature changed — each with the callers it breaks.
$ ctx changed --api --since HEAD~1
API changes vs HEAD~1
0 removed, 4 changed, 7 added.
Changed signature — potentially breaking
- query::coverage_report [fn] (src/query.rs:1420) was: pub fn coverage_report(g: &Graph, unsupported: &[(String, usize)], json_out: bool) -> String now: pub fn coverage_report(g: &Graph, unsupported: &[(String, usize)], explain: bool, json_out: bool) -> String callers (5): mcp::dispatch, query::tests::coverage_separates_internal_external_and_blind_spots, …
--strict turns it into a CI gate, and fails only on removals. That asymmetry is deliberate. A removal is unambiguous: nothing can call what is gone. A signature change might be an added optional parameter or a new struct field — routine, compatible work — and ctx is structural, with no type resolution, so it cannot tell that from a changed parameter type. Failing on both was tried and would have blocked ordinary additive commits on the first real repo it met; a gate that cries wolf gets switched off, which is worse than no gate. So signature changes are reported, and under --strict say explicitly that they were reported and not failed.
Treat it as a tripwire that surfaces an unintended removal in review, not as a semver authority — a language-specific tool with a type system (cargo-semver-checks, apidiff, japicmp) is stricter within its language. The trade ctx makes is breadth: one gate across Rust, Python, TypeScript, JavaScript and Go in a polyglot repo.
# .github/workflows/ci.yml — PR-only; fetch-depth 0, the default shallow clone
has no merge base.
- uses: actions/checkout@v7 with: { fetch-depth: 0 }
- run: cargo install code-context --locked
- run: ctx changed --api --strict --since "origin/${{ github.base_ref }}"
This isn't a context tool. It's CI.
3. move-plan — a refactor oracle, not an actuator
move-plan emits every site a module relocation must touch; move-verify checks the result. ctx never writes source files.
ctx move-plan native::gate native::routing::gate # file move + every import rewrite
... agent applies the edits ...
ctx move-verify native::gate native::routing::gate # exits non-zero if anything is orphaned
The reasoning: an agent can already make edits cheaply and precisely. What it cannot do is know it found *every* site, or prove nothing was orphaned. The scarce thing is ground truth, not typing — and staying read-only keeps ctx free of partial application and undo semantics.
Scope is bounded by what ctx can prove. Moves ride on import and link resolution — path arithmetic, deterministic, non-heuristic — which is ctx's strongest signal, so the site list is exact for the languages it parses. Dependents reached only by receiver inference have no literal string to rewrite and are listed separately as *unverified*, never mixed in with real sites. Rust mod declarations are not imports, so the plan names them as a required manual step rather than omitting them silently. Renaming a *method* is deliberately not offered: it would ride on receiver inference, which resolves a minority of call sites, and a plan built on that would silently miss some.
4. parity — cross-language port fidelity
Porting Python to Rust, or TypeScript to Python? parity answers "is this port a faithful structural copy?" Because the item model is language-neutral, a source module and its port are two renderings of one skeleton.
$ ctx parity research/gate.py src/gate.rs --aliases py-rust
ctx parity — source → port
source 6 members · target 5 · aligned 5 (83% of source) · 1 via alias
Missing in port (1) — in source, no counterpart in target
fn Gate.record gate.py:18
Arity drift (1)
fn Gate.score source=2 → port=1 gate.py:7
Aligned via alias (1) — matched through a rename rule, not exactly
fn Gate.init → Gate.new (via init → new)
parity: 5/6 source aligned · 1 missing · 1 arity · 0 call · 0 moved
A dropped method, a dropped parameter, and the __init__→new rename, in one command. --strict exits non-zero on any missing member. I'm not aware of another tool that does this. It might be more or less useful depending on your specific languages and abstractions.
"How is this different from aider's repo map?"
Aider's repo map — and the MCP servers that repackage it, like RepoMapper — compresses a repository into a ranked blob that gets injected at the start of a session, sized to a token budget. It's a good answer to "what is this codebase" for a model that has seen none of it.
ctx answers a different question. Once the agent is *in* a task, it doesn't need the repo ranked — it needs specific facts: trace, path, callers, context, changed --api, move-plan, parity. Those are queries mid-task, not a blob at boot. Ranking is one small command here (ctx core), not the product.
The nearer comparison is Serena, which does LSP-backed symbol navigation. Against it, ctx trades semantic precision for two things:
ctx | LSP-based (Serena) | |
|---|---|---|
| setup | one binary, grammars compiled in | a language server per language, configured and running |
| startup | ~100 ms graph build, per query | server warm-up, project indexing |
| determinism | pure function of the source tree | depends on server state, versions, build artifacts |
| uncertainty | marked per edge (~, *) + a miss census | resolved or absent, silently |
| coverage | 7 languages (today), one graph across all of them | as many as you install servers for |
If you need type-perfect resolution inside one language, use an LSP. If you want the same graph across a polyglot repo with nothing to install and answers that state their own confidence, that's this.
ctx does ship the boot map too (ctx map), so you can have it if you want it. But we'll say plainly what dogfooding taught us: it's the least useful thing here. More on why.
"Why not just grep?"
Often you should. Here is the measurement, including where grep wins.
Counting tokens. Every figure in this README is ctx's own estimate —
len/3, the same one `--max-tokens