Codehelper
Codehelper is a local-first repository intelligence MCP server exposing 60+ tools for AI coding assistants to search, understand, and safely modify code — without uploading it to the cloud.
Repository & Code Intelligence
Index git repositories to build symbol and call graphs
Search and navigate symbols (
query,search_hybrid,scout)Get full source, callers, callees, imports, and blast radius for any symbol (
context,context_bundle)Trace call paths between symbols, inspect API surfaces, find dead code, and rank architectural hotspots by churn × centrality
AST structural search via tree-sitter S-expression patterns
Find Go interface implementations and similar symbols
Safe Code Editing & Refactoring
Apply patches (search/replace or unified diffs), write files, insert code at symbols, rename symbols across all reference sites, and revert any edit via revert token
change_kit: single call to get everything needed to safely change a symboledit_cycle: fused edit → verify → re-index → respond workflow
Planning & Architecture
kickoff: one-call task starter with orientation, reuse candidates, docs, and stepsplan/scope: ground tasks with blast radius, decision points, and MVP suggestions before writing codeagent_plan: create and manage persisted, editable plans with todos
Verification & Quality
Run compiler/static analysis (go build/vet, cargo check, tsc), lint/build/test gates, and line-level code review for security, contracts, and performance
preflight/finish_check: release readiness gates combining change detection, diff review, and hygiene checksDetermine test impact via reverse call graph; read CI status via gh CLI
Memory & Learning
Persist ADR-style decisions, fix patterns, and facts across sessions (
agent_memory)Store cross-project learned rules by framework/language (
hints) and maintain a project glossary
Browser & Web
Headless Chromium automation for screenshots, accessibility audits, performance metrics, and UI interaction sequences
Fast HTTP-only verification for APIs and health checks
Web search for current documentation, error messages, or library facts
Docs & External Info
Fetch version-correct official documentation for any library or framework
Register custom documentation sources for internal libraries
Environment & Operations
Detect toolchain versions, scripts, docker-compose hints, and aliases
Read local log files, query database schemas, and run read-only SQL against SQLite or MySQL databases
Execute predefined recipes on configured SSH hosts and run command aliases
View per-project tool-usage and token consumption reports
Codehelper
Local-first repo intelligence for AI coding assistants.
Codehelper indexes git repositories on your machine, builds a symbol and call graph, and exposes 60+ MCP tools so Cursor, Claude Code, Codex, and other MCP clients can search, understand, and safely change your code — without uploading the whole repo to a cloud model.
Three reasons to use Codehelper
Project-aware agents — Search symbols, callers, and blast radius locally instead of grepping whole files.
Works offline — No API keys; your code stays on your machine.
Fits your editor — MCP for Cursor, Claude Code, Codex; one
codehelper initper repo.
Related MCP server: Graft
Installation
Linux / macOS (recommended):
curl -fsSL https://raw.githubusercontent.com/VeyrForge/codehelper/main/scripts/install.sh | shWindows (PowerShell):
powershell -ExecutionPolicy Bypass -File .\scripts\install.ps1From source (requires Go 1.25+, CGO, and a C compiler):
git clone https://github.com/VeyrForge/codehelper.git && cd codehelper
npm run buildPrebuilt 3.0.3 bundles (Linux, macOS, Windows) include codehelper, MCP server, ge 1.1.1, and greencompress 1.1.1 on GitHub Releases.
Updates: codehelper upgrade downloads the latest release from VeyrForge/codehelper by default. Override the upgrade source with --repo owner/name or CODEHELPER_UPGRADE_REPO. codehelper update rebuilds from a local git checkout and works from any directory (remembers the source path, or use CODEHELPER_SOURCE / update /path/to/codehelper).
30-second example
cd your-git-repo
codehelper init
codehelper help tools --mainReload Cursor or Claude Code after the first init, then call project_context once per session so the agent knows which tools exist and how fresh the index is.
See it work
No bundled demo video yet — here is a typical first session:
$ codehelper init
init: ready — index + watch daemon active
$ codehelper status
symbols: 1247 edges: 3891 freshness: current
$ codehelper help tools --main
project_context bootstrap tool catalog + index stats
query search the symbol graph
context source + callers + callees
impact blast radius before you editBenchmark methodology (no invented competitor numbers): docs/BENCHMARK_COMPARISON.md.
Supported platforms
Platform | Install | Notes |
Linux |
| Full support; primary CI target |
macOS |
| Universal + per-arch release binaries |
Windows |
| x64 supported |
Client | Setup |
Cursor | Per-project |
Claude Code | Managed block in |
Codex | Reads generated |
How it works
Layer | Technology |
Indexing | tree-sitter parsers + SQLite symbol/call graph |
Search | BM25 + trigrams + call-graph ranking (optional local semantic rerank — docs/LOCAL_EMBED.md) |
MCP transport | stdio (default) or HTTP ( |
Optional local models | Green Engine embed/chat + Green Compress weights |
init indexes the repo, starts the watch daemon, wires MCP for your editor, and writes agent rules. Optional local dashboard: ge ui serve → http://127.0.0.1:8780
Full tool reference: docs/MCP_TOOLS.md
Benchmarks
See docs/BENCHMARK_COMPARISON.md for competitor-comparison methodology (arms, metrics, bed tiers — no invented competitor numbers). Fill measured cells from reproducible local harness runs only.
Caveats: many published tables are self-repo (this tree) or methodology-lite paired locate probes (MCP vs host file walk). Those are not end-to-end coding-assistant issue-fix rates. Prefer multi-bed hold-outs (CODEHELPER_TESTBEDS) and fill competitor cells only from local re-runs.
# One recipe: prepare + paired + dated report
scripts/testbeds-all.sh
scripts/testbeds-all.sh fixture # always-safe, no bedsLayout and prepare/eval usage: docs/TESTBEDS.md.
Documentation
docs/MCP_TOOLS.md — MCP tool reference
docs/BENCHMARK_COMPARISON.md — benchmark methodology + harness (no fake competitor numbers)
CHANGELOG.md — version history
third_party/README.md — bundled Green stack binaries
Limitations
Requires a git repository for indexing.
CGO and a C compiler are required to build from source (tree-sitter).
Semantic rerank: optional tiny local embed path (
bash scripts/install-local-embed.sh/codehelper green init-embed) — see docs/LOCAL_EMBED.md. Enrichment needs optional local model services (Green Engine).Windows arm64 CI is experimental/non-blocking (
windows-11-arm). Releases always ship Windows amd64; a*_windows_universal.zipis published only when both amd64 and arm64 builds succeed (historical*_windows_universal.zipassets through v3.0.2 were amd64-sized and should not be treated as true universal).
Contributing
Bug reports, benchmark results, compatibility notes, and suggested improvements are welcome on the official VeyrForge/codehelper repository.
Pull requests improving Codehelper are welcome. By contributing, you agree to the Contributor License Agreement. You may also keep private/internal forks for your own deployment under the BUSL-1.1 Additional Use Grant. Do not offer Codehelper (or a substantially similar substitute) to third parties as a hosted or competing product. See License and permitted use and LICENSE-FAQ.md.
Public release history
See CHANGELOG.md and GitHub Releases.
License and permitted use
Codehelper is source-available under the Business Source License 1.1 (BUSL-1.1). It is not OSI open source until the Change License applies.
You may:
Use and run Codehelper (including in production) for personal use or internal business purposes (including employees and contractors acting on your behalf)
Copy, modify, and create derivative works for those same purposes — without having to contribute changes back
Use Codehelper to develop, test, maintain, review, or operate software for yourself or your customers (without offering Codehelper itself as a product or service)
Study the published source
You may not (until the Change License applies):
Offer Codehelper or a modified version to third parties as a hosted, managed, embedded, or distributed product or service whose primary purpose is to provide functionality substantially similar to Codehelper as a substitute
Sell a renamed fork or embed Codehelper as the main feature of another paid product without a commercial license
Change Date: 2029-07-24 — on that date, or the fourth anniversary of the first public BSL distribution of this version (whichever is earlier), this version becomes available under Apache License 2.0.
Tutorials and blog posts may include short illustrative snippets from the published source for explanation, provided they do not redistribute the software as a competing product or imply an OSI open-source grant before the Change Date.
For commercial redistribution, OEM licensing, or other usage not covered above, contact licensing@veyrforge.com.
This section is a plain-language summary. The binding terms are in LICENSE. Interpretive Q&A: LICENSE-FAQ.md. See also CLA.md, SECURITY.md, docs/PERMISSIONS.md, and docs/ROADMAP.md.
Available Tools
39 toolsagent_execute_todoC
Execute one approved/planned todo through the agent loop with optional verify gate
Inputs: task_id (required), repo, verify, todo_id, +2 more.
agent_memoryA
Persist and recall project memory (goal.md §25). action=record saves an ADR-style DECISION with its rationale (the WHY) so a later session recalls it instead of re-litigating; search/list retrieve prior decisions, fix patterns, and facts. Also propose/approve/reject for task-scoped proposals.
Inputs: action (required), repo, tags, text, +5 more.
agent_planB
Create or refresh a persisted editable plan with todos from expand_request intake
Inputs: request (required), repo, quick, persist, +5 more.
apply_patch_workspace_fileADestructive
Apply one or more search/replace hunks to an existing file. Preferred arg: hunks=[{old_string,new_string,replace_all?,exact?}]. Aliases accepted: edits/changes/replacements, or patch as the same array, or a small unified-diff string with context/-/+ lines. Each old_string must match the current file exactly once unless replace_all is true. If an exact match fails purely on whitespace/indentation (tabs vs spaces, trailing space) AND the snippet anchors to exactly one place, the patch is still applied — new_string is reindented to the file's real style and the response notes whitespace_adjusted. Exact matches also restyle new_string indent chars to the file's tab/space convention. Pass exact=true on a hunk to disable tolerant re-anchoring. Preserves untouched content verbatim. Returns a unified diff and revert_token.
Inputs: path (required), repo, hunks, patch, +1 more.
browserAIdempotent
Render a URL in headless Chromium and SEE it: returns a WebP screenshot the model can view, plus console output, uncaught JS errors, failed requests, optional performance metrics, and page metadata. Use this (not web, which is HTTP-only) for the VISUAL result or client-side JS behavior — verifying a local dev UI (http://localhost:3000) after a change. Write & run a UI test: outline=true lists the interactive elements with ready-to-use selectors, then actions clicks/fills/asserts through the flow (pass/fail reported). WordPress admin: recipe=wp_login|wp_admin|wp_plugins|wp_posts|wp_new_post + site= fills login from encrypted/env secrets (never logged) and waits for #wpadminbar (plugins/posts navigate after). Session reuse: session= keeps cookies across browser calls in this MCP process. Responsive check: device=mobile|tablet|desktop, or devices=["all"] to capture every viewport in one call. Performance check: metrics=true (FCP, load, request count, page weight). Watch it happen: headed=true opens a visible browser that highlights each click/input. Lean by default — the opt-in outline is bounded, not a full-DOM dump. Loopback always allowed; set allow_private for LAN. Needs the managed browser: if missing, run ch browser install once. Binary must be built with -tags rod (default codehelper update / install.sh).
Inputs: gui, url, repo, site, +35 more.
change_kitARead-onlyIdempotent
Everything needed to change one symbol SAFELY, in a single call: its definition source, every call site (with the calling line), the tests that cover it, the risk tier, and a consistency checklist. Use right before editing a symbol — it replaces the read/grep round-trips you'd otherwise make and stops you from missing a caller. The edit-time companion to scout.
Inputs: target (required), repo, format.
db_queryARead-onlyIdempotent
Read-only SQL against a configured database profile (sqlite or mysql/MariaDB). DDL/DML blocked. Requires connections add-db --read-only; secrets via env:/secret only.
Inputs: sql (required), connection (required), repo, format, +1 more.
db_schemaARead-onlyIdempotent
Schema introspection for a configured sqlite or mysql database. Optional comma-separated table filter.
Inputs: connection (required), repo, format, tables.
dead_codeARead-onlyIdempotent
Find symbols that nothing in the indexed graph references — candidate dead code. Lists functions/methods (optionally types/vars) with no inbound call or read edge, after excluding entrypoints, tests, and HTTP handlers that a runtime invokes. Returns CANDIDATES to verify, not a delete list: the call graph misses dynamic dispatch, reflection, and cross-repo callers. Use before a cleanup pass; confirm each with impact(upstream) + a name search first.
Inputs: repo, kinds, top_k, format, +2 more.
docsARead-onlyIdempotent
Up-to-date official documentation for a library/framework/API (codehelper's local-first answer to Context7). Resolves the version this project pins from its manifests, then fetches version-correct docs preferring the llms.txt/llms-full.txt standard before HTML. library may also be a direct https URL (docs page, API reference, or OpenAPI page) to fetch it as-is. Unknown libraries resolve via npm/PyPI/crates metadata; if one is still missing, register it with docs_add. Network fetch is privacy-gated.
Inputs: library (required), repo, topic, format, +4 more.
edit_cycleA
Post-edit loop: optional change_kit preview, apply_patch, index refresh, since (changed symbols + blast radius), and diagnostics. Fuses the edit → verify → re-index → respond workflow.
Inputs: path, repo, patch, format, +2 more.
env_contextARead-onlyIdempotent
Detect toolchain versions, npm/make scripts, docker-compose hint, and configured aliases/log sources from project files — one call, no shell.
Inputs: repo, format.
find_implementationsARead-onlyIdempotent
Which concrete types implement a Go interface — a heuristic interface→implementation map without go/types. Reads the interface's method set and reports every type whose methods cover it (structural typing); partial matches list the missing methods (often means embedding). Use to answer 'what satisfies this interface?' that ranked search can't. Heuristic: verify pointer-receiver/signatures before relying on it.
Inputs: interface (required), repo, format.
glossaryA
Review the project vocabulary seed and promote terms into the shared glossary. action=review lists frequent candidate terms enriched with the symbols they connect to; action=promote writes a term+definition into the committable project_memory.json; action=list shows the approved glossary.
Inputs: action (required), repo, term, limit, +1 more.
hintsA
Global, cross-project learned hints/rules ('don't forget X when working with Y'), keyed by framework/language/dependency/project_type and applied to any project that matches. Use action=add to remember something you discovered (so future work on this stack — in any project — gets the hint up front); action=list to review; action=remove to delete by id. Persisted in ~/.codehelper/learned_hints.json (local-first, syncable).
Inputs: action (required), id, repo, text, +2 more.
hotspotsARead-onlyIdempotent
Rank files by architectural RISK = git churn × call-graph centrality. A file changed often (git history) AND depended on heavily (inbound call edges) is where defects are most likely and refactoring most valuable — high churn alone is just active code, high centrality alone is stable infrastructure, their product isolates the risky core. Deterministic, no model. Use to pick refactor targets, focus review, or find where a change is most dangerous; inspect the top rows with context/change_kit and impact.
Inputs: repo, top_k, format, commits.
investigateARead-onlyIdempotent
Fused investigation: by default query + context + impact + test_impact. Pass recipe=architecture|dead_code|security|perf for specialized audits (architect Q&A pack, dead_code candidates, review_diff security smells, or hotspots+impact). Returns a compact JSON bundle — replaces chained MCP calls.
Inputs: path, repo, query, format, +2 more.
list_workspace_directoryARead-onlyIdempotent
List one directory (non-recursive) under the repo root — for LAYOUT only. To FIND code, prefer query/scout, which search the whole indexed graph at once; do not walk the tree directory-by-directory.
Inputs: path, repo, format, max_entries.
log_readARead-onlyIdempotent
Tail a configured LOCAL log source (from connections add-log). Remote logs use remote_exec with a tail recipe.
Inputs: source (required), repo, lines, format.
orchestrateARead-onlyIdempotent
Run a guided local investigation workflow: classify task, execute a deterministic tool chain (query/context/impact/test_impact/etc.), return a context pack + compact tool trace + verification hints. Requires orchestration enabled.
Inputs: task (required), repo, detail, format.
orchestrationBRead-onlyIdempotent
Enable, disable, or check local orchestration for this project. When enabled, use orchestrate for guided investigation workflows with tool trace memory and feedback/rerun loops.
Inputs: action (required), repo.
orchestration_feedbackB
Store correction for an orchestration run and update orchestration memory. Returns constraints for orchestration_rerun.
Inputs: run_id (required), message (required), repo, avoid_entities, +2 more.
orchestration_memoryBRead-onlyIdempotent
Search orchestration memory (feedback rules, negative memory, workflow hints) learned from prior runs.
Inputs: repo, limit, query.
planARead-onlyIdempotent
Architect-mode planner: turn a task into a grounded plan BEFORE writing code — reuse candidates, blast radius, decision_points, role checklist, steps + verify cmds. role=architect = design Q&A (cite symbols; no edit until accepted; pairs with investigate recipe=architecture). Other roles: security|performance|refactor|feature (default). Prefer kickoff for the same pack plus orient/docs.
Inputs: task (required), repo, role, format.
queryARead-onlyIdempotent
Locate symbols in the indexed graph (BM25/FTS + 1–2 hop graph expand + RRF; optional vector channel) — not web search. Prefer search_hybrid when you also want a package public_api_map. Production/app defs rank above sample/test/fixture/style noise; pass path= on follow-up context/context_bundle/impact when ambiguous. For broad/architecture questions set include_context_pack=true and limit 24-32. Pair hits with context_bundle before claiming behavior. Empty hits → rephrase, ast_query, or analyze.
Inputs: query (required), repo, limit, top_k, +6 more.
remote_execAIdempotent
Run a NAMED recipe on a configured SSH host (never free-form shell). Host and recipe must exist in connections config; remote argv must be on the host allowlist.
Inputs: host (required), recipe (required), repo, format, +2 more.
remote_listARead-onlyIdempotent
Read-only map of configured SSH hosts, DB connections, log sources, and command aliases for this project. Secrets are never returned — configure via codehelper connections CLI.
Inputs: repo, format.
rename_symbolADestructive
Preview-first, graph-driven rename of a symbol and its references (codehelper's heuristic answer to an LSP rename — no language server, no go/types). Resolves the definition via the symbol graph, collects graph-confirmed reference sites, and ALSO runs a word-boundary textual scan to catch references the graph missed, classifying every site as graph-confirmed (high confidence) or textual-only (unverified — may be a same-named field, comment, or string). Returns a per-file plan by default; pass apply=true to write graph-confirmed sites (and include_textual=true to also write textual-only ones). Not type-aware: review before applying.
Inputs: to (required), name (required), line, path, +4 more.
reviewARead-onlyIdempotent
Deterministic diff AUDIT in one call (no LLM): the symbols changed vs base_ref, each with its blast radius + risk tier + covering-test count, plus flags — public_api_changes (potential breaking), untested_changes (test gaps), high_risk — the tests_to_run, and a security/performance/reuse/contracts checklist. Use AFTER editing, before finishing. The write-side complement to plan; pair with diagnostics (build/vet) and review_diff (line-level).
Inputs: repo, format, base_ref.
run_aliasAIdempotent
Run a user-configured command alias (declarative argv or remote recipe). Aliases with requires_approval need approved=true.
Inputs: name (required), repo, format, params, +1 more.
run_traceARead-onlyIdempotent
Full orchestration run trace on demand: tool calls, arguments summaries, durations, and errors. Use after orchestrate when compact trace is not enough.
Inputs: run_id (required), repo.
scopeARead-onlyIdempotent
Turn a VAGUE idea into a buildable spec — for when you (or the user) have an idea but don't know what to specify and aren't thinking about security/scale/failure. Returns a Why/What/How restatement, the clarifying_questions that actually change architecture/security/data, the decisions_to_make (data shape, scale, auth boundary), the unstated_nonfunctionals beginners skip, existing building blocks to reuse, and a suggested MVP vs out-of-scope. Use BEFORE kickoff/plan when the request is fuzzy; answer the questions with the user, then run kickoff on the concrete task.
Inputs: idea (required), repo, format.
scoutARead-onlyIdempotent
Before adding/fixing: ranked reuse candidates (caller counts) + usage_of_top call site + impact_of_top. Production defs beat sample/test/fixture (collision_note when demoted). Use when locating 'what already does X?' — reuse beats reinventing. Then context/change_kit before editing.
Inputs: task (required), repo, top_k, format.
similarARead-onlyIdempotent
Similar-implementation search for ONE symbol: ranks other symbols whose name, signature, and package resemble the target. Use when you found one function and want peers to extend/copy — distinct from scout (task-oriented reuse) and find_implementations (Go interface satisfaction).
Inputs: name (required), repo, top_k, format.
sinceARead-onlyIdempotent
What changed since a git ref, and what to do about it — in ONE call. Fuses detect_changes + impact + test_impact: the symbols changed vs base_ref (including uncommitted edits), the downstream blast radius (distinct dependents, worst risk tier, must-update call sites), and the test files to re-run (reverse call-graph closure, a SAFE over-approximation). Use right after editing, before running the suite — the post-edit companion to scout. Also lists new untracked source files the index can't see yet.
Inputs: repo, format, base_ref, test_depth, +1 more.
traceARead-onlyIdempotent
Call-graph navigation in ONE deterministic step instead of hopping context→context (a tool call per hop). With from and to: the exact SHORTEST call path between two symbols — "how does the HTTP handler reach the DB write?" — including detecting when the dependency actually runs the other way. With only from: the outbound call-flow tree. Use this for hidden/transitive dependencies that ranked search can't surface; pair with impact (blast radius) and context (1-hop neighbors).
Inputs: from (required), to, repo, depth, +1 more.
usage_reportARead-onlyIdempotent
Per-project tool-usage + token report. Layers: (1) codehelper OUTPUT — how much context each tool injected, by tool/session/client (claude-code/cursor/codex) — measurable for EVERY client; (2) Claude + Codex MODEL TOKENS — real billed tokens per session, parsed from Claude Code transcripts (/.claude) and Codex rollouts (/.codex); Cursor doesn't expose these locally. Also surfaces the last change-verification (verify/diagnostics) outcome and a recent-call trail. Read-only; never indexes.
Inputs: refs, repo, format, verbose.
verifyAIdempotent
Run lint/build/test gates with argv-mode default (no shell), per-command timeout, optional allowlist. REQUIRED before finish_check: after a green run set finish_check verify_ran=true; if cmds are missing/ephemeral use verify_abstained=true + verify_reason — never invent a green gate.
Inputs: repo_root (required), lint_cmd, test_cmd, build_cmd, +4 more.
web_searchARead-onlyIdempotent
Search the web for current information and return a compact ranked list of {title, url, snippet} to then fetch/verify with the web or browser tools. Use for finding docs, error messages, library/version facts, or current events — anything outside the indexed repo. Provider is configured via ch config search (Tavily/Brave free keys, or keyless DuckDuckGo fallback). Does not crawl; it finds the URLs to look at.
Inputs: query (required), count, provider.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
Many tools occupy overlapping investigative territory: scout, similar, query, find_implementations, trace, and change_kit all help locate or understand code, while investigate and orchestrate both run fused workflows. The descriptions are detailed, but an agent would struggle to reliably pick between these parallel search/investigation paths and related post-edit tools like since, review, edit_cycle, and verify.
Names are consistently snake_case, which is good, but the style mixes bare verbs (investigate, plan, query, review, trace, verify), bare nouns (hotspots, browser, docs, glossary, hints), and prefixed groups (agent_*, orchestration_*). The pattern is readable but not predictable enough to infer what a tool does from its name alone.
At 39 tools, this is well into the 'too many' range even for a broad code-assistant server. Several tools are redundant or could be consolidated, such as the orchestration cluster (orchestrate, orchestration, orchestration_feedback, orchestration_memory, run_trace) and the overlapping edit/review cluster (edit_cycle, since, review, verify, apply_patch_workspace_file).
The surface is broad, but descriptions repeatedly reference tools that are not exposed: context, impact, test_impact, context_bundle, diagnostics, review_diff, kickoff, docs_add, and orient. The set also lacks an explicit create-file workflow, only patching existing files. These missing pieces create dead ends and force agents to work around gaps in the advertised workflow.
Maintenance
Related MCP Connectors
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Shared context for your codebase: a hosted code knowledge graph over MCP. Free plan, OAuth sign-up.
Codebase intelligence for AI agents — dead code, blast radius, ownership.
Related MCP Servers
- AlicenseCqualityCmaintenanceLocal-first codebase intelligence engine providing AI coding agents with a typed MCP toolset for understanding and navigating code repositories.10054Apache 2.0
- AlicenseBqualityDmaintenanceLocal-first codebase context engine that parses code into a ranked dependency graph and serves it to AI tools via MCP for deep structural understanding.518 npm2MIT
- AlicenseNot gradedqualityBmaintenanceMCP server for local-first code intelligence, providing structural code graph, semantic search, and impact analysis to AI agents.2MIT
- AlicenseAqualityAmaintenanceCodebase intelligence and context engine for AI coding agents: search, symbol lookup, impact analysis, and context building via MCP.11MIT