Make your AI agent actually understand your code.
A sharper agent that sees your whole codebase — one precise query where it used to grep blind a dozen times.
Out of the box, your agent greps blind — it burns tokens rebuilding what your codebase already knows, then guesses. codeindexer hands it a real map: a queryable call graph that answers “what breaks if I change this?” from actual callers, semantic search across every repo, and a memory of past decisions that survives every session. 100% local — your code never leaves your machine.
Three ways in. Pick yours.
The same local engine underneath — pointed at what you actually care about. Choose the door that sounds like you.
For developers
A smarter agent, less guesswork.
Solo, side-project, or daily driver — make Cursor, Claude Code or Copilot sharper and more precise.
- Compact mode trims tool output up to 80%
- Real answers from a call graph, not guesses
- Free forever for up to 3 projects
For enterprise
Reliability, support, and control.
For engineering orgs shipping critical software under real compliance pressure.
- On-prem / self-hosted — code never leaves your VPC
- 4-hour critical SLA, direct line to engineering
- Custom parsers + procurement-ready docs
For AI agents
The full toolbox, specced.
The deep technical surface: every tool, every language, the graph and the memory model.
- 32 MCP tools — search, graph, memory, audit
- Cross-language call graph + blast radius
- Persistent memory across every session
One install.
Every AI client.
Real code intelligence.
A single Rust binary — fully offline, no cloud, no API key. It indexes your projects once into a real graph database, exposes all 32 tools over MCP, and tunes itself to your RAM — comfortable on a 16 GB laptop.
What your agent gains
Search by meaning, not by string
Semantic, symbolic and exact search in one cascade — ask in plain language and get the right chunk, not a regex scan.
A real call graph
Walk callers and callees across languages. PageRank-style ranking surfaces load-bearing functions and scores a change's blast radius before it ships.
Follows calls across service seams
REST, gRPC, queues, FFI, GraphQL — best-effort links show where a call likely lands, instead of grepping blind across the boundary.
Memory that survives every session
Decisions, solutions and roadmaps persist across sessions and every client — so even a smaller or local model works from real structure, not guesses.
It also runs a quality & security audit on demand — all of it on your machine. Your code never leaves it, and what the tools produce stays yours too: memory and reports are plain files, exportable to markdown you can commit to your repo.
Four hard questions, answered straight.
The questions a good CTO asks before letting a new tool anywhere near the team. Here are ours — answered the way we’d want them answered.
Commoditization
“Won’t Cursor and Copilot just build this in?”
They’re building retrieval — inside their own walls.
- A built-in index belongs to the tool, not to you. Switch IDE, model or vendor and your context stays behind. codeindexer sits a layer above your tools — move from Claude to Gemini to a local model and keep the graph, the search, the memory.
- An IDE vendor profits from lock-in, so portable context is the one feature they won’t ship. Building on an open standard (MCP) is the opposite bet.
- Built-in retrieval is embedding search. A cross-language call graph, blast radius, persistent memory and a security audit are a different category of tool.
- And if they do catch up? You’ve lost nothing — see the next card.
Dependency risk
“Isn’t this another dependency we can’t see into?”
It never enters your dependency tree.
-
Not in
package.json, not inCargo.toml, not in CI, not 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 — there’s nothing to audit on the wire.
-
Switching it off tomorrow costs you convenience, not a broken build. Uninstall is
rm, not a migration project.
Knowledge ownership
“Shouldn’t our decisions live in our repo, not in a tool?”
They do. That’s the design.
- Memory is files on your machine — and decisions, cards and reports export to plain markdown you can commit right next to your code.
- The index is derived data. Your repo stays the single source of truth; codeindexer just makes it queryable for the agent.
- It’s memory for the agent, not a replacement for your docs — the agent reads it so your team stops re-explaining the architecture every session.
The honest one
“Do we actually need it?”
Maybe not. Honestly.
- Small repo, one AI client, an agent that never gets lost, nobody re-solving solved problems? Skip it — you’re fine.
- It starts paying 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 every week.
- Free for 3 projects, no card, no cloud — the cheapest way to find out is to point it at your gnarliest repo for a day.
Three doors, one engine.
Pick the path that fits — developer, enterprise, or agent — or just download it free and point your AI client at your repo.
Built for AI agents.
Here's what they think of it.
Context: Copy & conversion pass on the codeindexer.dev site — the indexer running on its own repository
Context: Indexing Laravel + Livewire codebases
Context: Studying a large Rust project
Context: Pre-launch review pass on the codeindexer.dev marketing site
Four real sessions across Anthropic, OpenAI and Google — more as we run them. No fabricated testimonials, no “Anonymous CTO at Fortune-500 says”.