CODE-DAEMON MCPCD-610-B
User's HandbookCode intelligence seriesBeta · Rev. 6.1.0

CODE-
DAEMONMCP

Code intelligence for AI agents — local, GPU-accelerated, one daemon for all your agents.

Code-Daemon is an MCP server that gives your AI coding agent a real understanding of your codebase: a code graph, semantic search, impact analysis, call tracing, safe refactoring, security scanning and auto-generated documentation. Everything runs on your machine — your code never leaves it.

DOWNLOAD BETA 6.1.0 ↓ HOW IT WORKS →
Code-Daemon — a horned daemon writing code on a scroll
FIG. 0 · THE DAEMON× 1 PER MACHINE
EXECUTION
LOCAL
DAEMONS PER MACHINE
1
AGENTS DETECTED
9
LANGUAGES
13 + JSON/CSS/SQL
PLATFORMS
WIN · LINUX · MACOS
SECTION 1

Download

BETA 6.1.0
PLATFORMARCHIVE
Windows x64(coming soon)GET ↓
Linux x64(coming soon)GET ↓
macOS (Apple Silicon)(coming soon)GET ↓
SECTION 2

What happens when you run it

Unpack the archive to a permanent folder and run code-daemon-core once. It will:

▶ STEPS 2.1 — 2.3 RUN AUTOMATICALLYNO MANUAL SETUP REQUIRED
  1. 2.1

    Register the MCP server in your AI agents.

    Installed agents are detected automatically and Code-Daemon is added to each one's MCP config:

    Claude CodeCodex CLIGemini CLICopilot CLIVS CodeCursorWindsurfZedOpenCode
  2. 2.2

    Download the inference runtime that fits your GPU

    From cdn.code-daemon.com — TensorRT or CUDA builds matched to your NVIDIA architecture, OpenVINO for Intel CPU / iGPU / NPU, Vulkan for AMD GPUs. Only the pack your hardware needs is fetched.

  3. 2.3

    Download the models

    From huggingface.co/faxenoff — Code-Daemon's own distilled models: code embeddings, a search reranker, a relation classifier and small local LLMs for summaries and documentation.

Then restart your AI agent. That's it — indexing starts automatically the first time the agent opens a project, and a file watcher keeps the index current as you edit.

SECTION 3

One daemon, many agents

Claude Code
Cursor
Codex CLI
▼
code-daemon-mcpstdio proxy · ~700 KB · × N
NAMED PIPE /
UNIX SOCKET▶
code-daemon-core
daemon · × 1 per machine
INDEXMODELSGPU
FIGURE 3-1 · Process topology
3.1 · PROXY
Your AI agent launches code-daemon-mcp — a ~700 KB stdio proxy client, not the server itself.
3.2 · DAEMON
The proxy connects to code-daemon-core. There is always exactly one daemon, no matter how many agents or windows are open. The first proxy starts it; every other one attaches.
3.3 · SHARED STATE
The daemon owns the index, the models and the GPU. Open one project in three agents — it is indexed once, held in memory once, and every agent sees the same graph.
SECTION 4

Hardware

TIERHARDWAREEXPERIENCE
BESTDiscrete NVIDIA GPU, RTX 2060 or newerFull speed: TensorRT embeddings (thousands of chunks per second), local LLM documentation, reranking
BESTHigh-end discrete AMD Radeon GPU (RX 7800 XT / 7900 class)Runs through Vulkan — full feature set, local LLM documentation, reranking
BESTMacBook Pro, M4 Pro or newerNative Apple Silicon inference, unified memory — the fastest LLM documentation of any supported device
GOODEntry-level AMD Radeon GPURuns through Vulkan — slower, but comfortable for everyday indexing and search
GOODMacBook Air, M4 / Apple M3Native Apple Silicon inference — code indexing about 2× slower than M4 Pro, but LLM documentation still faster than on most discrete GPUs
WORKSNo discrete GPU: Intel NPU + iGPU + CPUOpenVINO spreads the work across NPU, integrated GPU and CPU — slower indexing; LLM documentation not available yet

MINIMUM: 8 GB RAM. Windows 10+ (x64), Linux (x64), macOS on Apple Silicon.

4.1How long does it take? A 1M-line project

Approximate first-time figures for a project of ~1 million lines of code (60 000–120 000 functions, classes and methods, depending on the language — the figures assume ~90 000) with an ordinary amount of documentation: a README and a docs folder of 100–150 pages plus its git history (~5 000 text chunks). Docgraph time grows with the documentation, not the code. The figures are extrapolated from our own measured runs on real repositories, so treat them as orders of magnitude, not guarantees. On Windows and Linux the discrete GPU and OpenVINO (iGPU / NPU / CPU) work in parallel.

DEVICECODE INDEXDOCGRAPHAUTODOC
NVIDIA RTX 40 / 50 series~40 s~180 s~2.3 h
NVIDIA RTX 20 / 30 series~60 s~250 s~3.2 h
AMD Radeon (Vulkan)~70 s~270 s~3.5 h
Apple MacBook Pro, M4 Pro~80 s~4 min~6 h
Apple MacBook Air, M4~100 s~5 min~14 h
Intel NPU + iGPU + CPU, no discrete GPU~130 s——
  • Code index — parsing, code graph and embeddings. Search, navigation, tracing and impact analysis work as soon as it is done.
  • Docgraph — knowledge graph over docs and commits (entity extraction, relations, topic summaries).
  • AutoDoc — a local LLM writes documentation for every module. It runs in the background and never blocks the tools; after the first pass only changed modules are re-documented.
  • On an Intel-only machine docgraph summaries and AutoDoc are not available yet: they need a local LLM, which runs on NVIDIA, AMD or Apple GPUs.
  • On Apple Silicon the embeddings, the search reranker and the docgraph relation model run on the Neural Engine; the LLM runs on the GPU. A fanless MacBook Air slows down under hours of load, and the AutoDoc figure for it already includes that; a MacBook Pro keeps its speed.
  • After the first pass, edits are indexed incrementally — only the changed files are re-processed.
SECTION 5

Features

5.1 — 5.10

5.1Search

  • Semantic search — find code by what it does, not by what it is called. Hybrid vector + text + graph ranking, with a local reranker on top.
  • Indexed grep — trigram-indexed literal and regex search across the whole project, instantly.
  • Symbol lookup — find entities by name or name pattern; list everything a file defines.
  • Similar code — nearest neighbours of a function by meaning, even with different names.
  • Cross-language search — one query across every language in the repo, grouped by language.
  • Related concepts — search hits plus their most important graph neighbours.
  • Knowledge search — one answer combining code, project docs and git history.

5.2Navigation & code graph

  • Code graph — entities (functions, classes, methods, modules) and their relationships: calls, imports, inheritance, containment.
  • Entity relationships — every incoming and outgoing edge of a symbol.
  • Graph metrics — PageRank, betweenness, communities, bus factor.
  • Architecture diagrams — Mermaid / Graphviz / D2, generated from the real graph.
  • Architecture layers & tech stack — detects API / service / data / UI layers, languages, frameworks and tooling.
  • Surprising links — non-obvious cross-module connections, each with an explanation.

5.3Tracing & debugging

  • Trace flow — the execution path from A to B, as a diagram.
  • Who calls this — all callers of a function; also answers “why is this never called?”.
  • Data-flow tracing — how a value moves through call chains.
  • Variable tracing — where a variable is assigned and under which conditions.
  • Stack-trace analysis — paste a stack trace, get it mapped onto your indexed code.
  • Decision points — the dispatch hubs on a flow, where one function fans out to many.

5.4Impact analysis

  • Change impact — what breaks if you change a symbol: dependents, depth, risk.
  • “Does X affect Y?” — a direct yes / no instead of the whole dependency closure.
  • Public-API impact — breaking-change risk for exported APIs.
  • OpenAPI / Swagger impact — which code is touched by a spec change.
  • State impact & state chaos — shared mutable state, god objects, circular dependencies.

5.5Refactoring & editing

  • Structural edits — replace a whole entity by name, search-replace, or edit a line range. Dry-run preview by default.
  • Rename symbol — project-wide, word-boundary safe.
  • Batch modify / batch rename — mass changes with filters and preview.
  • File operations — create, copy, rename, split and merge files; add members to a class.
  • Change history — every edit is snapshotted: list, diff, step back, step forward.
  • Refactoring suggestions — ranked by complexity and coupling.

5.6Code quality

  • Duplicate detection — structural duplicates and token-level clones.
  • Hotspots — the most complex and most coupled code.
  • Design patterns & anti-patterns — framework-aware (Angular, Spring, Django, Express, …).
  • Validation — lint a file or a whole directory.

5.7Security

  • Security scan — SQL injection, XSS, hard-coded secrets, dangerous functions.
  • Taint analysis — source-to-sink flows for SQLi, XSS, command injection, path traversal and SSRF, each with a confidence level.
  • Library contract checks — flags API misuse against known library contracts.

5.8Documentation & knowledge

  • AutoDoc — module documentation generated by a local LLM and kept in sync with the code as it changes. Output in English, Russian, German, French, Spanish, Chinese or Japanese.
  • Onboarding tour — a guided walkthrough of the codebase for new developers.
  • Changelog — generated from git history.
  • Knowledge graph — project docs and commits indexed and linked to the code they describe.
  • Review questions — what a reviewer or newcomer should ask, drawn from the graph.

5.9Git & collaboration

  • Review context — for changed files: affected entities and what can be skipped.
  • Semantic merge — three-way merge that understands code structure; merge-conflict preview and merge suggestions across branches.
  • Worktrees for parallel agents — spawn, list and clean up git worktrees so several agents can work side by side.
  • Compressed shell — run tests, git and build commands with output summarised for the agent.

5.10Operations

  • Automatic indexing — incremental on every file change, full on branch switch.
  • Scheduler & GPU manager — models are loaded and evicted to fit your VRAM.
  • Status & metrics — index health, graph statistics, per-tool latency, memory and DB sizes.
SECTION 6

Languages — how deep the parsing goes

Every number below is measured, not claimed: each language is indexed on real open-source projects and compared against the language's own compiler-grade indexer (SCIP: scip-typescript, scip-python, scip-go, scip-java, rust-analyzer, scip-clang, Roslyn, ZLS; Swift, which has no SCIP indexer, against the Swift compiler's own index store).

STRUCTURE
Of all definitions (functions, classes, methods, fields…) the compiler sees, the share Code-Daemon extracts too.
CALL ACCURACY
Of the call edges impact analysis follows, the share that point to exactly the same target the compiler resolves.
LANGUAGESTRUCTURECALL ACCURACY
C94.3 %99.9 %
C++92.9 %99.5 %
Zig97.0 %99.6 %
TypeScript99.5 %98.8 %
Java99.9 %97.8 %
Rust99.7 %97.4 %
Go99.2 %95.9 %
C#99.5 %95.0 %
JavaScript100 %91.7 %
Python99.6 %91.0 %
Kotlin97.0 %86.6 %
Swift95.0 %84.3 %
Bashfunctions, variables, source · no reference indexer

Where a language was measured on several projects, the number is the average across them.

Also indexed: JSON, CSS, SQL (schemas and embedded SQL), plus project docs (Markdown) and git history for the knowledge graph.

ON THE ROADMAP — NEW LANGUAGES
RubyPHPVue / Svelte / AstroLuaElixirPowerShellProtocol BuffersCMakeMakefileStarlark / BazelSQL DDL filesSCSS / LESSVB.NETRazor
SECTION 7

Privacy

Your code is parsed, embedded and searched locally, by local models.

Code-Daemon itself goes online only once, during installation, to download runtimes (cdn.code-daemon.com) and models (huggingface.co/faxenoff).