高性能MCP工具：gortex

简介

Features

• Knowledge graph — every file, symbol, import, call chain, and type relationship in one queryable structure
• Multi-repo workspaces — index multiple repositories into a single graph with cross-repo symbol resolution, project grouping, reference tags, and per-repo scoping. A dedicated cross-repo edge layer materialises cross_repo_calls / cross_repo_implements / cross_repo_extends edges whenever a relation's endpoints live in different repos — surfaced via analyze kind: "cross_repo". Resolution is evidence-gated: cross-repo links are only drawn when the symbol evidence clears a confidence bar, so unrelated same-named symbols don't get wired together
• Per-session workspace isolation — under the daemon, each MCP session's queries are scoped to the workspace it connected from; sessions on different repos never see each other's graph slices even though they share one process
• 257 languages across three tiers — bespoke tree-sitter extractors (~30) for the deep-resolution tier (Go, TypeScript, Python, Rust, Java, C#, Kotlin, Swift, C, C++, Ruby, Elixir, OCaml, …), regex extractors (~60) for niche/legacy (ABAP, COBOL, Verse, AL, AutoHotkey, …), and forest-backed signature-only (~165 via alexaandru/go-sitter-forest, extended by drop-in user grammars via .gortex.yaml's index.grammars key) for the long tail (Vue, Svelte, Astro, GraphQL, Prisma, Latex, Typst, Agda, Idris, Hack, Haxe, MLIR, LLVM, SystemVerilog, Cedar, CEL, TLA+, Robot, Hurl, …) — plus notebook-style sources: Jupyter .ipynb (nbformat 3 + 4) and Databricks notebooks (.dbc archives + source-format .py / .scala / .sql / .R with # COMMAND ---------- separators) extract each cell as its own graph node (code → KindFunction, markdown/raw → KindVariable) tagged with cell_index / cell_kind / cell_language so %%sql / %%scala cell magics and Databricks %magic directives surface as language-routed symbols. See docs/languages.md for the full table
• 119 MCP tools — symbol lookup, call chains, blast radius, community/process discovery, contract detection, unified analyze (dead code, hotspots with novelty + directional ranking modes, cycles, connectivity_health (isolated/leaf node counts, effective-vs-nominal graph size, dead-weight-by-file attribution), channel-ops, goroutine-spawns, field-writers, config-readers, event-emitters, error-surface, external-calls, routes, models, components, k8s_resources, images, kustomize, cross-repo, dbt_models, unsafe_patterns, health_score, role (six-class classifier), constructors_missing_fields (literal-site field-completeness check), clusters (community projections with density + spread + language mix; algorithm selects leiden (default), louvain, or recursive-spectral-bisection spectral), concepts (LLM-or-heuristic cluster theme labels), impact (composite per-symbol change-impact score 0..100 + risk label from PageRank centrality + transitive reach + cyclomatic complexity + co-change coupling + community span), named (runs named detector bundles from the .gortex.yaml::queries block — 10 built-in security bundles ship), tests_as_edges (first-class view over the test→code edge layer, grouped by symbol or by test)), near-duplicate clone detection (find_clones), structural code search (search_ast with bundled detectors), CPG-lite dataflow (flow_between / taint_paths over value-flow / arg-of / returns-to edges), five proactive push channels — diagnostics, workspace readiness, daemon health, stale refs, graph invalidation (subscribe_diagnostics / subscribe_workspace_readiness / subscribe_daemon_health / subscribe_stale_refs / subscribe_graph_invalidated and their unsubscribe_* pairs) — plus code actions (get_code_actions / apply_code_action / fix_all_in_file) wired across every running language server, scaffolding, inline editing, symbol renaming, read-free file writes (edit_file / write_file) with path-traversal guard + dry_run, multi-axis structured retrieval (winnow_symbols), multi-repo management, agent feedback loop, context export, graph-validated config hygiene (audit_agent_config), opening-move routing (plan_turn), narrative repo overview (get_repo_outline), cold-start query suggestions (suggest_queries — 5-10 starter queries from entry points, hubs, bridges, and subsystems), test-coverage gaps (get_untested_symbols), session memory (save_note / query_notes / distill_session — per-repo notes auto-linked to symbols, survive context compactions), cross-session development memories with workspace + global scopes (store_memory / query_memories / surface_memories / edit_memory / rename_memory — symbol-anchored, deterministically ranked; compound across sessions and teammates; promote workspace-local invariants to user-level with one call), repository-local persistent notebook (notebook_save / notebook_find / notebook_list / notebook_show / notebook_used — markdown entries committed to git so agent journal entries surface in PR review), composed workflow primitives — get_architecture (single-shot snapshot: outline + communities + hotspots + entry points + processes + cross-repo + contracts; a resolution arg — file / package / service / system — instead returns a rolled-up hierarchical view with weighted rollup edges and no function leaves), replay_episode (incident investigation walking callers + timeline + coverage gaps + incident memories from a symptom anchor), get_knowledge_gaps (disconnected nodes + thin communities + single-file communities + untested hotspots), get_surprising_connections (composite anomaly scorer over five signals), safe_delete_symbol (atomic dead-code removal with graph-aware safety gate), verify_citation (git-show + substring check at a SHA), check_onboarding_performed (boolean readiness probe over essential memory kinds), check_references (one-call composite over imports + name search + usage graph), generate_skill (bundle a directory into .claude/skills/<name>/SKILL.md + references/), gortex_wakeup (paste-ready ~500-token codebase digest; matched gortex wakeup CLI for MCP-less users), get_churn_rate (per-symbol commit density from blame), find_co_changing_symbols (ranked git co-change neighbours over mined co_change edges), search_artifacts / get_artifact (full-text + by-id lookup over the context-artifacts manifest — schemas, API specs, infra configs, ADRs), get_coupling_metrics (Robert C. Martin Ca/Ce/instability per package or community), get_extraction_candidates (ranked refactor suggestions from log-scaled size × callers × fan-out), list_inspections / run_inspections (uniform inspector surface composing existing analyzers), graph_completion_search (consumes the pluggable Retriever protocol for vector-or-graph hybrid candidate sets), and an optional in-process LLM research agent (ask)
• Semantic search — hybrid BM25 + vector search with RRF fusion, on by default via a baked GloVe-50d table (~3.8 MB embedded in the binary, top 20k tokens; CPU-only, zero network, zero native dependencies). Large symbols are split into AST-aware windows before embedding and de-chunked at query time so a 500-line function lands as the specific window that matched. Equivalence-class vocabulary expansion (curated software-concept synonyms + per-repo auto-concepts mined from naming patterns) bridges auth ≈ authentication ≈ login deterministically without an LLM. A HITS authority/hub signal feeds the rerank pipeline so heavily-referenced symbols outrank shallow utility nodes, with a hub penalty that holds called-by-everything infra down. A per-keyword TaskMemory layer means a new task with similar keywords inherits learned associations from prior searches, not just exact-query matches. A keyword-soup query defense detects degenerate boolean / OR-soup phrasing, skips wasted LLM expansion, and splits the soup into BM25-fusable terms. Markdown documentation is a first-class corpus too — corpus: "docs" returns ranked README / ADR / design-doc sections. Opt-in embedding.provider: local (Hugot MiniLM-L6-v2) or api (Ollama / OpenAI, with a bounded concurrent worker pool for indexing); the vector index is persisted in the daemon snapshot so restarts re-warm in milliseconds. Optional build tags switch to ONNX or GoMLX for higher throughput
• Language-agnostic concurrency analyzers — analyze kind=race_writes flags struct-field writes from inside a goroutine-reachable function whose writer has no detected lock acquisition (Lock / RLock / Acquire / WithLock / synchronized / Do recognised across Go, Rust, Java, TS, Python, C#); analyze kind=unclosed_channels flags channels with sends but no close() call from any sender or receiver, classified high / medium / low risk based on sender count + receiver presence. Rides existing EdgeSpawns / EdgeSends / EdgeRecvs / EdgeWrites / EdgeCalls edges — no LSP dependency, works on every language whose extractor emits the substrate (Go full; TS, Python, Kotlin, Rust, C# for spawns + writes). Pairs with the existing channel_ops + goroutine_spawns + field_writers producer-side analyzers. Navigation results carry the same intelligence: get_callers and analyze kind=goroutine_spawns annotate each caller / spawn target with sync_guarded (the symbol is a method on a lock-holding type — sync.Mutex / RWMutex in Go, Mutex / RwLock in Rust, ReentrantLock in Java, SemaphoreSlim in C#) and cross_concurrent (the symbol is launched across a concurrency boundary — goroutine / async / promise / worker pool), each with a short human-readable explanation and absent when not applicable
• Bundled unsafe-patterns scan — analyze kind=unsafe_patterns fans out seven tree-sitter detectors over the whole indexed file set in one call: Go panic, Rust .unwrap / .expect / panic! / todo! / unimplemented! / unreachable! / assert! (+ debug_assert*) / unsafe { } / unsafe fn, Python assert (stripped by -O in production), JS / TS throw. Filters by language / detector / severity / path_prefix; severity-ranked rows (error > warning > info) with a per-detector count summary; exclude_tests defaults to true so test asserts don't drown real findings. Each rule is also invocable individually via search_ast detector=…
• Composite code-health score — analyze kind=health_score aggregates coverage_pct + complexity (fan-in/out + community-crossings) + recency (last_authored) + session churn into one 0..100 value per symbol plus an A..F grade. Missing axes are skipped (not zero-imputed) so a repo with no blame enrichment still produces meaningful scores from the axes that are available. Every response carries a population distribution (mean / median / std-dev / Gini coefficient over risk inequality / per-grade counts). Pass roll_up=file or roll_up=repo for per-file / per-repo averages with min/max bands. Filters: path_prefix, kinds, grade, min_score, max_score, min_axes, limit. Sorted ascending so the worst symbols surface first under truncation
• Scope-based static resolver for C / C++ / Java / PHP — beyond tree-sitter's local match, the resolver knows about each language's scope rules and uses them to disambiguate same-named symbols before falling back to directory-locality. C prefers a same-file static function over a same-name extern; C++ prefers a same-namespace candidate and walks Argument-Dependent Lookup (Koenig) namespaces harvested from the call's argument types when same-namespace lookup misses; Java pins unqualified calls to the enclosing class first, then walks the extends chain up to 8 hops; PHP resolves parent::/self::/static:: against the inheritance chain. Scope-resolved edges stamp OriginASTResolved + Meta["resolution"]="scope" so the per-edge tier surface tells scope wins from generic-locality wins. No LSP dependency on these languages — pure static analysis from the tree-sitter parse
• Sub-millisecond impact analysis — explain_change_impact, detect_changes, flow_between step-impact, and the prompt safe_to_change / pre_commit flows all share a precomputed reach index that walks every node's incoming edges to depth 3 at index time and stamps the result on Node.Meta. Blast-radius queries become O(seeds × reach) map lookups instead of a depth-3 BFS, the representative in-edge confidence + label ride alongside each tier entry so consumers don't pay a second GetInEdges per result, and the daemon snapshot persists the index so warm-starts skip the build cost entirely. Bounded incremental rebuilds keep AnalyzeImpact correct after every file watcher patch; queries on nodes added after the last build (or any depth >3 query) transparently fall back to the live walk so consumers never see a stale result
• LSP-enriched call-graph tiers — every edge carries an origin tier (lsp_resolved / lsp_dispatch / ast_resolved / ast_inferred / text_matched) plus a coarse tier label (lsp / ast / heuristic) derived from it, so agents can group or filter by provenance without recomputing the mapping; pass min_tier to get_callers, find_usages, find_implementations, flow_between, taint_paths, etc. to restrict results to compiler-verified edges for high-stakes refactors. flow_between prunes below-tier edges during BFS (no broken paths) and emits per-step origins / tiers plus a per-path worst_tier in the GCX1 wire format so reviewers see the weakest link without decoding every step. For TS/JS/JSX/TSX, the cross-file resolver consults typescript-language-server on the hot path (not just as an after-the-fact enricher), so LSP-grade precision lands on the first query rather than waiting for the enrichment pass. Opt-out with GORTEX_LSP_RESOLVER=0
• MCP progress notifications — long-running indexing and track_repository calls emit notifications/progress with stage messages (walking files → parsing → resolving → semantic enrichment → search index → contracts → done) so hosts show real progress bars on large repos
• Five proactive push channels — per-session opt-in subscribe/unsubscribe tools, delta-filtered, initial replay, auto-cleanup on disconnect. notifications/diagnostics (LSP publishDiagnostics fan-out; filter by min_severity / path_prefix), notifications/workspace_readiness (daemon warmup phase transitions: snapshot_loaded → parallel_parse → deferred_passes_all → global_resolve → end_batch → watcher_started → ready), notifications/daemon_health (periodic ticker — default 15 s, clampable 1 s..5 min — snapshots uptime, alloc/sys/heap, num_goroutine, num_gc, tracked_repos, sessions, lsp_alive, graph nodes/edges; only runs while ≥1 subscriber is attached), notifications/stale_refs (per-session intersect of watcher symbol-change events against the session's viewed/modified working set — fires only when a change actually touches what this session has consumed), notifications/graph_invalidated (coarse "the graph was rebuilt, drop cached results" signal fired on every re-analysis — {node_count, edge_count, reason, ts}, unfiltered). Subscriber counts + last-known states surface in graph_stats under notifications for debugging
• Type-aware resolution — infers receiver types from variable declarations, composite literals, and Go constructor conventions to disambiguate same-named methods across types
• On-disk persistence — snapshots the graph on shutdown, restores on startup with incremental re-indexing of only changed files (~200ms vs 3-5s full re-index). Snapshots are keyed by (repo, branch), so switching branches reuses each branch's cached index, and git worktrees of one repo share that base. Change detection is mtime-based by default, with an opt-in BLAKE3 Merkle-tree mode (index.merkle / GORTEX_MERKLE) that diffs by content hash — a touched-but-unchanged file is skipped. A cross-process advisory lock guards the index store against concurrent writers
• HTTP server (gortex server) — versioned /v1/* JSON API exposing all MCP tools (/v1/health, /v1/tools, /v1/tools/{name}, /v1/stats, /v1/graph, /v1/events SSE) for IDE plugins, CI, and the Next.js web UI. Localhost bind + bearer-token auth (--auth-token / $GORTEX_SERVER_TOKEN) by default; CORS configurable for separate frontend origins
• MCP 2026 Streamable HTTP transport (/mcp) — the wire format the June 2026 MCP spec locks in. One endpoint (POST/GET/DELETE /mcp), per-request session replay via Mcp-Session-Id and an in-memory streamable.SessionStore (swap for Redis to run multiple workers behind a load balancer), JSON-RPC batching, SSE upstream for server-initiated notifications, multi-server router reuse so tools/call frames still proxy across the federation. Always-on for gortex server; opt-in on the daemon via gortex daemon start --http-addr 127.0.0.1:7411 [--http-auth-token <token>]
• Semantic enrichment — pluggable SCIP, go/types, and LSP providers upgrade edge confidence from ~70-85% (tree-sitter) to 95-100% (compiler-verified). Additive — graceful degradation when external tools unavailable. The SCIP provider has a definitions-only fast path (mode: definitions) for a C# / .NET (scip-dotnet) coverage helper that wants compiler-grade symbol coverage without paying for full reference ingestion; per-server command / args / env overrides in .gortex.yaml let heavyweight servers (notably jdtls) be pinned to a specific JRE. A per-language connect: { network, address, fallback_spawn } block dials an already-running language server (the one the IDE is already managing on tcp or a unix socket) instead of spawning a duplicate subprocess — the dial transport closes the carrier cleanly on shutdown without sending the LSP shutdown / exit sequence, so the IDE keeps its server alive. fallback_spawn: true opts into a spawn fallback after a failed dial; left unset, a failed dial returns a clear passive-attach error rather than racing the IDE for a port. Reconnects use exponential backoff capped at 30 s and reset the dynamic capability table on every fresh session
• Crash-resilient indexing — opt-in (index.crash_isolation) tree-sitter extraction in worker subprocesses, so a grammar SIGSEGV / OOM / hang on one pathological file is contained: the bad file is quarantined with Meta["parse_error"], the quarantine persists across daemon restarts, and the index pass still completes. The worker pool is long-lived — reused across single-file re-indexes so the watcher path never re-spawns a worker per file. A per-file extraction budget (index.max_extract_millis), the size cap, and content-based bundled/minified-artifact detection (a minified bundle or a sourcemap is recognised by content and skipped — on by default, index.index_minified opts back in) each leave a synthetic node carrying skipped_due_to_timeout / skipped_due_to_size / skipped_due_to_minified telemetry instead of dropping the file silently. Pluggable pre-ingestion content transforms (index.transforms) rewrite bytes before parsing — built-in BOM stripping, plus user external-command processors (minified-bundle expansion, SVG/TOON, PDF→markdown) that can even re-type a file to a language its extension does not natively map to
• Framework-aware extraction — first-class entry points (Alembic migrations, Next.js pages / App-Router files, ASP.NET host files) stamped so the dead-code analyzer never flags runtime-invoked symbols; Swift HTTP routes (Vapor provider + Alamofire consumer); a XAML / AXAML extractor (x:Class code-behind link, named controls, {Binding} expressions); .NET DI registrations + COM-interop flags on C# files; Lombok / MapStruct / Kotlin / CommunityToolkit.Mvvm source-generated members surfaced via has_generated_members. New analyze kinds — env_var_users, sql_call_sites, fixes_history (git bug-fix-commit hotspots), edge_audit (graph-completeness self-diagnostic), domain (user-pluggable TOML extractor rules), impact (quad-signal change-impact composite), named (named detector bundles from .gortex.yaml::queries), and tests_as_edges (test→code edge-layer view). pyrefly and tsgo join the language-server registry
• Agent feedback loop — unified feedback tool (action: "record" / "query") lets agents report which symbols were useful/missing. Cross-session persistence improves future smart_context quality via feedback-aware reranking
• Context export — export_context tool + gortex context CLI render graph context as portable markdown/JSON briefings for sharing outside MCP (Slack, PRs, docs, non-MCP AI tools)
• ETag conditional fetch — content-hash based if_none_match on source-reading tools avoids re-transmitting unchanged symbols during iterative editing
• Token savings tracking — per-call tokens_saved field on source-reading tools + session-level metrics in graph_stats (calls counted, tokens returned, tokens saved, efficiency ratio). gortex savings renders a three-bucket dashboard (Today / Last 7 days / All time) with 16-cell █/░ bars, percentage saved, raw token counts, and USD cost avoided priced against the headline model. Per-call JSONL log at <cache>/savings.jsonl powers windowed buckets and the --verbose per-tool breakdown (get_symbol_source / batch_symbols / smart_context)
• GCX1 compact wire format — published, round-trippable text format for MCP tool responses. Opt-in per call via format: "gcx" on every list-shaped tool (~17). Auto-served as the default for known clients (Claude Code, Cursor, VS Code, Zed, Aider, Kilo Code, OpenCode, OpenClaw, Codex) when no format is passed; explicit format always wins. Median −27.4% savings vs JSON across a 20-case benchmark under tiktoken cl100k_base (Claude 3 / Opus 4 / Sonnet 4 / Haiku 4.5 / GPT-4o family) and a parallel −27.3% under Claude Opus 4.7 input-token counts (best case −38.3%), 100% round-trip integrity. Spec: docs/wire-format.md. Standalone MIT-licensed reference implementations: Go (github.com/gortexhq/gcx-go) and TypeScript (github.com/gortexhq/gcx-ts, npm @gortex/wire). Reproducible harness: bench/wire-format/ (dual-tokenizer scorecard; --use-api for exact Opus 4.7 counts via Anthropic count_tokens)
• TOON fallback wire format — second-tier compact text (~10–15% smaller than JSON, lossy but human-friendly) on every list-shaped tool for clients that don't yet speak GCX. Pass format: "toon"
• Budget-by-default MCP responses — list-shaped tools cap each page at the project default budget and return next_cursor for the tail. Pagination, sparse fieldsets, and graceful degradation built in. Per-call caps via max_bytes and max_tokens (composable — tighter wins; ~3.5 bytes/token heuristic calibrated across JSON / TOON / GCX1). Truncation rides on the response as _truncated_by_budget / _truncated_by_tokens / _max_returned_<list> markers (JSON) or a # truncated_by_budget=true / # max_tokens=N truncated_by_tokens=true comment (GCX)
• Graded-fidelity context economy — smart_context can return a context_manifest (fidelity: "graded") that tiers symbols by graph distance — focus symbols at full source, their caller/callee ring as elided signature stubs, the keyword-match remainder as outline — all packed under one token_budget, with budget pressure demoting entries full → compressed → outline rather than dropping them. estimate: true projects a call's token cost before fetching; an if_none_match pack root turns a repeated call on unchanged code into a near-zero-token not_modified no-op. compress_bodies takes a keep predicate (stub a whole file except the symbols being edited); get_symbol_source / read_file take max_lines for AST-aware salience truncation — the control-flow skeleton is kept and leaf-statement runs collapse to … N lines elided … markers instead of a blind line cut. Source-returning tools attach structured omissions notes (compressed / truncated / binary / vendored / generated) so the model is never guessing about absent code
• Response post-filter re-cutting — every large tool response is captured into a bounded per-session ring; ctx_grep / ctx_slice / ctx_peek / head_results / ctx_stats re-cut a prior result — regex search with -A/-B/-C context and a grep-style match block, explicit line slices, head/tail previews — without re-issuing the original query
• 16 MCP resources — bootstrap state (gortex://stats, gortex://workspace, gortex://repos, gortex://active-project, gortex://schema, gortex://session, gortex://index-health), community / process rollups (gortex://communities, gortex://community/{id}, gortex://processes, gortex://process/{id}), and analyzer-backed summaries (gortex://report, gortex://god-nodes, gortex://surprises, gortex://audit, gortex://questions). Read-only, URI-addressable, push notifications/resources/updated after each graph re-warm — no polling
• Framework graph layer — handler→route edges from HTTP / gRPC / GraphQL / WebSocket / Phoenix / Kafka topic registrations; ORM model→table edges across GORM, SQLAlchemy, Django, ActiveRecord, JPA, TypeORM, Ecto; component-tree edges for JSX/TSX and Phoenix HEEx. Surfaced via analyze kind: "routes" / "models" / "components"
• Infrastructure graph layer — first-class KindResource (Kubernetes Deployments, Services, Ingresses, ConfigMaps, Secrets, CronJobs), KindKustomization (overlay tree), and KindImage (Dockerfile FROM targets and K8s container.image) with depends_on / configures / mounts / exposes / uses_env edges. Cross-references with code-side os.Getenv calls automatically. Surfaced via analyze kind: "k8s_resources" / "kustomize" / "images"
• CPG-lite dataflow — value_flow (intra-procedural assignment / return / range), arg_of (caller arg → callee param), and returns_to (callee → assignment LHS) edges built at index time. flow_between returns ranked dataflow paths between two symbol IDs; taint_paths does pattern-driven source→sink sweeps for security audits
• Near-duplicate clone detection — every substantial function body is reduced to a 64-slot token-normalised MinHash signature at index time, LSH banding finds candidate pairs, and a Jaccard threshold filter keeps the true clones — emitted as symmetric similar_to edges. find_clones surfaces the clusters; find_clones {dead_only: true} yields the Gortex-unique "dead duplicates of live code" diagnostic. Gated behind the clones coverage domain (default on, threshold tunable in .gortex.yaml)
• Stratified test classification — test symbols are classified by role (unit / integration / e2e / benchmark / fixture) and the tests edges carry that role, so winnow_symbols can filter "production functions only, no tests" and coverage analyzers can reason per-tier
• Local LLM research agent (optional) — built with -tags llama and a configured llm.model, the ask MCP tool runs a small GGUF model in-process via llama.cpp that navigates the graph with gortex tools and returns a synthesized answer — one call replaces a long chain of search_symbols / get_callers / contracts calls. chain: true traces a request across repos (consumer → contract → provider → downstream). Falls through to direct tools when the build tag or model is absent
• 3 MCP prompts — pre_commit, orientation, safe_to_change for guided workflows
• LLM features (optional) — opt-in ask research agent + LLM-assisted search_symbols ranking, behind a pluggable provider (local llama.cpp / Anthropic / OpenAI / Ollama). Off by default; the HTTP providers need no native dependencies. See LLM Features
• Two-tier config — global config (~/.config/gortex/config.yaml) for projects and repo lists, per-repo .gortex.yaml for guards, excludes, and local overrides
• Guard rules — project-specific constraints (co-change, boundary) enforced via check_guards, plus an architecture: block: declarative rules: (max_fan_out dependency-cone limits, deny_callers_outside caller boundaries) and named layers: (path globs with directional allow/deny dependency lists)
• Watch mode — surgical graph updates on file change across all tracked repos, live sync with agents
• Web UI — standalone Next.js 15 app at gortexhq/web (separate repo so it deploys independently) that talks to gortex server over /v1/*, with Sigma.js 2D graphs and five react-three-fiber 3D views (City, Strata, Galaxies, Constellation, Graph3D)
• IMPLEMENTS inference — structural interface satisfaction for Go, TypeScript, Java, Rust, C#, Scala, Swift, Protobuf
• PreToolUse + PostToolUse + PreCompact + Stop hooks — two postures, picked at install (gortex install --hook-mode={deny,enrich}): deny (default) has PreToolUse enrich Read/Grep/Glob/Bash with graph context and redirect by deny to Gortex MCP tools (matching Task also briefs spawned subagents with an inline tool-swap table + task-scoped smart_context); enrich never denies — PreToolUse downgrades the deny rationale to soft additionalContext and a PostToolUse hook augments the actual tool output with graph context (enclosing symbols for Grep hits, file footprints for Read, indexed-vs-unindexed summary for Glob), trading enforcement for easier onboarding. PreCompact injects a condensed orientation snapshot (index stats, recently-modified symbols, top hotspots, feedback-ranked symbols) before Claude Code compacts the conversation. Stop runs post-task diagnostics (detect_changes → get_test_targets, check_guards, analyze dead_code, contracts check on modified symbols) so the agent self-corrects before handoff. All hooks degrade silently when the server is unreachable
• Long-living daemon (optional) — gortex daemon start runs a single shared process that holds the graph for every tracked repo. Each Claude Code / Cursor / Kiro window connects as a thin stdio proxy over a Unix socket, getting per-client session isolation (recent activity, token stats) + cross-repo queries by default. Live fsnotify watching on every tracked repo so file edits flow into the graph without manual reload. gortex install sets up user-level config; gortex daemon install-service installs a LaunchAgent (macOS) or systemd --user unit (Linux) so the OS supervises lifecycle and auto-starts at login — no sudo required. Binaries fall back to embedded mode if the daemon isn't running; the feature is additive
• Benchmarked — per-language parsing, query engine, indexer benchmarks
• Per-community skills — gortex init --skills (default on) auto-generates SKILL.md per detected community with key files, entry points, cross-community connections, and MCP tool invocations for Claude Code auto-discovery; the same routing table lands in every detected agent's per-repo instructions file
• Eval framework — SWE-bench harness for A/B benchmarking tool effectiveness with Docker-based environments and multi-model support
• gortex eval CLI — first-class evaluation harness. Subcommands: recall (fixture-driven any-hit R@1/5/20 + MRR per ranker, per-tier breakdown, p50/p95 latency, tokens-returned, optional LLM judge for CQS-style dual-judge scoring), embedders (ONNX variant comparison — size + init + embed latency + end-to-end quality across MiniLM variants, BGE, Jina; list subcommand surfaces the next-gen Python-backed model registry — EmbeddingGemma / Qwen3-Embedding-8B / NV-Embed-v2 / potion-code-16m — with availability + install hints), baselines (NDCG@10 + latency vs ripgrep / probe / colgrep / grepai / coderankembed / semble; --smoke verifies wiring without paying for heavy Python deps), quality {drift|confidence|replay|tune} (measurement infra: embedder drift detector + per-query confidence summary + ranker-config replay + rerank weight-tuning suggestion), swebench (passthrough), stdbench (CoIR / SWE-ContextBench / ContextBench standardized-benchmark loaders — Recall@K / NDCG@10 / MRR), tokens (GCX1 wire-format bench). Seed fixture at bench/fixtures/retrieval.yaml; published BM25 baseline on Gortex: R@1 42.3% · R@5 55.1% · R@20 63.5% · exact R@5 96.8%. Published reproducible benches in BENCHMARK.md; SWE-bench results template in BENCHMARK-SWE.md; methodology in docs/04-evaluation/.
• Zero dependencies — everything runs in-process, in memory, no external services