Frequently asked questions.

22 short answers about what codeindexer is, how it runs, what it costs, and what happens to your code. Can't find what you need? Ask us directly.

Product

9 questions

Model Context Protocol is an open standard introduced by Anthropic that defines how AI agents talk to external tools. Cursor, Claude Code, Copilot, Windsurf, Codex CLI, and Gemini / Antigravity all support it. Building on MCP means codeindexer works with whatever AI client you use today — and whatever you switch to tomorrow.

Cursor's indexer is locked to Cursor, mostly does embedding-based search, and is fine for small repos. codeindexer works with every MCP client, offers semantic + symbolic + exact search in one cascade, walks the real call graph, runs security audits, and gives your agent persistent memory across sessions. We also handle PDFs, Word, Excel, and Markdown — Cursor's doesn't.

Cursor, Claude Code, Claude Desktop, VS Code Copilot, Windsurf, OpenAI Codex CLI, Gemini / Antigravity, and anything else that speaks MCP. See integration recipes in our docs for copy-paste config per client.

Full call-graph and reference parsing (27 languages — symbols plus resolved call / import / type edges):

Rust · Python · JavaScript · TypeScript · PHP · Go · Java · C · C++ · C# · Ruby · Swift · Solidity · Kotlin · Scala · Dart · Lua · Bash · Julia · Haskell · Elixir · Zig · Vue · Svelte · GLSL · HLSL · WGSL · COBOL*. Vue and Svelte are parsed through their script block; Ansible playbooks and roles earn the same graph per file.

Symbols & search (5 languages — parsed into named symbols, no call-graph extraction):

YAML · Markdown (headings) · GraphQL · OCaml · Verilog / SystemVerilog.

Recognized & searchable (36 languages — line-based chunking for full-text and semantic search, no symbols):

JSON / JSONL · HTML · CSS / SCSS / Sass / Less · ERB / EJS · Jinja · SQL · TOML · Regex · Vyper · Move · Cairo · Perl · R · Erlang · Clojure · F# · Objective-C++ · Protobuf · Groovy / Gradle · Astro · Nim · Crystal · Elm · Gleam · PureScript · Haxe · Odin · Fortran · Pascal · Ada · Lisp · Emacs Lisp · Racket · Scheme · GDScript · QuakeC.

Document formats (7 types):

PDF · DOCX · XLSX (incl. XLS, XLSM, XLSB, ODS) · LaTeX (incl. arXiv .tar.gz) · Markdown / docs · Telegram exports (JSON) · Archives (ZIP, TAR.GZ/BZ2/XZ/ZST, RAR).

* COBOL ships behind the cobol opt-in build feature.

Roughly 5–30 seconds per 10k lines of code on a modern laptop, depending on language and GPU availability. A 200k-line repo indexes in 1–3 minutes the first time. After that, only changed files get re-indexed — usually under a second on save.

No — CPU works fine for repos up to a few hundred thousand lines. GPU speeds indexing and search up significantly and is supported on every platform; you pick the right binary for your hardware at download time.

Per platform:

Windows: CPU · DirectML (any DirectX 12 GPU) · CUDA* · CUDA + TensorRT*
macOS: CPU · Metal (Apple Silicon — M1/M2/M3/M4)
Linux: CPU · CUDA* · CUDA + TensorRT*

* CUDA / TensorRT builds require the corresponding NVIDIA SDK installed on the system (CUDA toolkit; TensorRT adds the TensorRT SDK on top). DirectML and Metal need no extra system dependencies.

Indexing peaks around 1–2 GB RAM per project. The index itself is typically 5–15% the size of your source tree.

Modern AI clients auto-discover MCP tools when you connect a server. We also ship a recommended system prompt that teaches your agent the right patterns: cascade search first, narrow down by project, walk the graph when impact matters. Paste it into your client’s global instructions once.

Index format is versioned. We automatically migrate when the format changes — you don’t need to reindex on every update. Breaking changes happen at most once per year and are announced with at least 30 days notice.

Pricing & licensing

4 questions

Free is for solo work and side projects: 3 indexed projects, 100,000 chunks total, and per-project limits of 8 active phases / 42 open cards / 64 reports. Search modes: symbol, semantic, exact. Memory, roadmap, solutions and skills tools work within those limits (auto-promoted solutions up to 64, reusable skills up to 20 per build).

Pro ($20/mo) removes all of the above limits and unlocks the heavy tooling: cascade search, the full call graph (callers / callees / chains), code-quality scanners (dead code, complexity, coverage), cross-file analysis (bridges, execution flows, signature search, corpus clustering), plus history and analytics.

Security ($40/mo) adds the deep audit_project pipeline on top of Pro: reachability-aware CVE detection, supply-chain risk scanner, optional LLM triage, CI/CD generators (codeindexer ci-init), and OWASP / PCI / SOC 2 / CIS compliance mapping.

Full feature breakdown: /pricing.

No. Codeindexer is a proprietary commercial product distributed as signed binaries. The Free tier is a separate compile-time build of the same closed source with the published Free-tier limits enforced.

Our public repository contains only the README, security disclosure policy, and community documentation — not the source code itself.

Detailed terms: Terms of Service and Legal Notice.

Pro and Security subscriptions, plus Enterprise contracts. We don’t sell data (we don’t have any), don’t run ads, and don’t take a cut of what your AI does. Sustainable, boring SaaS economics.

Free: GitHub Issues. Pro: email support, 48-hour response. Security: priority email support, 24-hour response. Enterprise: named engineer contact, 4-hour critical SLA — see our Service Level Agreement. Security vulnerabilities go through private disclosure.

General contact: contact page.

Security & data

5 questions

No. Indexing, embedding, search, and audit all run on your machine. The only network traffic from codeindexer itself is a once-a-day license check on Pro / Security / Enterprise that sends a license ID and an anonymous machine fingerprint — nothing about your code. The Free tier makes no network calls at all. Details on /security.

Yes. The Free tier never touches the network. Pro / Security / Enterprise need a once-a-day license heartbeat — but if it fails (offline laptop, firewall, travel), there’s a 14-day grace period before the binary falls back to the Free tier.

Yes — on Enterprise. Embedding models are bundled with the binary, so indexing and audit make no external network calls. Restricted-environment deployment is discussed under NDA — contact sales.

No. We never see your code. We have no way to train on it. We also don’t use it ourselves — codeindexer ships with a general-purpose embedding model that works out of the box. The optional LLM triage on the Security tier is opt-in and runs against your own LLM provider (Anthropic, OpenAI, or a self-hosted endpoint) — not ours.

Yes — every tier runs locally on your machine, that’s the core design. The Enterprise tier specifically adds team deployment:

Bearer-token authentication per developer — each API key carries an identity that becomes the author / created_by on memory cards, reports, and audit history.
Per-key project access control — an individual API key can be limited to a specific set of projects (or wildcard for all).
Shared indexes on team volumes with bearer-token auth and CORS allow-listing on the HTTP transport.
Per-user dashboard view — each team member sees their own activity and statistics while the underlying data stays shared.

The hard questions

4 questions

They’re adding retrieval — inside their own walls. A built-in index is locked to one tool: switch IDE, model or vendor and your context stays behind. codeindexer sits a layer above your tools, on an open standard (MCP), so the index, call graph and memory survive every switch — Claude today, Gemini tomorrow, a local model next year. An IDE vendor profits from lock-in; portable context is the one feature they won’t ship.

The depth is different too: built-in retrieval is embedding search, not a cross-language call graph with blast radius, persistent memory and a security audit. And if the big players do catch up — you’ve lost nothing. It’s a dev-time tool with zero migration cost: remove it in a minute and nothing in your stack breaks.

It’s a dev-time tool — it never enters your dependency tree. Nothing in package.json or Cargo.toml, nothing in CI, nothing in production. Your build — and your users — cannot be affected by it.

Everything it produces is plain files on your disk: the index, the embeddings, the memory. Inspect them, back them up, delete them. The Free tier makes no network calls at all, so there’s nothing to audit on the wire either. Switching it off tomorrow costs you convenience, not a broken build.

Yes — and that’s exactly how it works. Memory lives in files on your machine, and decisions, cards and reports export to plain markdown you can commit right next to your code. The index itself is derived data: your repo stays the single source of truth, codeindexer just makes it queryable for the agent.

Think of it as memory for the agent, not a replacement for your documentation — the agent reads it so your team stops re-explaining the same architecture every session.

Honestly: if your repo is small, your agent never gets lost, and nobody on the team re-solves already-solved problems — skip it. You’re fine without us.

It starts paying off when the codebase outgrows the context window, the agent greps in circles and re-reads the same files, you run more than one AI tool or model, or the same architecture gets re-explained to the agent every week. The Free tier covers 3 projects with no card and no cloud — the cheapest way to find out is to point it at your gnarliest repo for a day.

No questions match .

Try a different phrase, or ask us directly.