Your AI coding agent starts every session blind. Ask Claude Code, Cursor, or Codex a question about your repo and it does the same thing a new hire would: grep, glob, open a file, read 800 lines, open another file, repeat. That discovery loop burns tokens, wastes time, and still misses cross-file relationships that don't show up in a text search.
Codebase context tools fix this. They index your code once into something queryable (a knowledge graph, a vector index, or a virtual filesystem) and expose it to your agent, usually over MCP. The agent asks a targeted question and gets the exact code back instead of scanning for it. Fewer tokens, fewer tool calls, better first-attempt answers.
Below are seven open-source options, grouped by how they actually work. Each entry covers what it does, how it works, where it shines, and where it stops. Star counts are approximate and as of writing.
Code knowledge graphs
These parse your source into symbols and relationships (calls, imports, inheritance) and let the agent walk the graph.
1. CodeGraph
~57.3k stars · MIT · TypeScript · 100% local
CodeGraph builds a pre-indexed knowledge graph of your codebase and serves it to agents through an MCP server. Everything stays on your machine. It uses tree-sitter to parse code into a local SQLite database with FTS5 full-text search. No API keys, no cloud.
It's genuinely zero-config. Install, wire up your agents, index a project:
# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.sh | sh
codegraph install # auto-detects and configures your agents
cd your-project
codegraph init -i # creates the index and builds the graph
The installer auto-detects Claude Code, Cursor, Codex CLI, opencode, Gemini CLI, Kiro, and more. A native OS file watcher keeps the graph fresh as you edit, with a debounce window and a staleness banner so the agent never gets a silently wrong answer.
The standout features are the graph queries: codegraph_explore answers "how does X work" in one call, and codegraph_impact traces the blast radius of a symbol before you change it. It supports 20+ languages and does framework-aware route detection (Django, FastAPI, Express, NestJS, Spring, Rails, and others) plus cross-language bridging for mixed iOS / React Native codebases. The project's own benchmarks report roughly 16% lower cost and 58% fewer tool calls versus a bare agent.
Best for: teams that want a fast, local, no-nonsense structural index for their coding agents, especially large or polyglot repos.
Watch out for: it's purely structural code context. It knows your call graph, not why the code exists.
Repo: https://github.com/colbymchenry/codegraph
2. CodeGraphContext (CGC)
~3.9k stars · MIT · Python
CGC is both an MCP server and a standalone CLI. It indexes local code into a graph database and lets you query relationships in plain English through your agent, or directly from the terminal.
pip install codegraphcontext
codegraphcontext mcp setup # wizard configures your IDE/agent
codegraphcontext index .
The differentiator is backend flexibility. It ships with embedded databases (FalkorDB Lite, KuzuDB, LadybugDB) for zero-config local use, and scales up to Neo4j for large graphs. It supports 23 languages via tree-sitter, with optional SCIP indexers (scip-clang, scip-dotnet) for more accurate C/C++/C# call and inheritance resolution.
Beyond callers/callees and class hierarchies, CGC does code-quality analysis: dead-code detection, cyclomatic complexity, and full call-chain tracing across hundreds of files. It also has a live file watcher and a premium interactive HTML visualization of the graph.
Best for: developers who want CLI-first code analysis (complexity, dead code, call chains) as much as agent context, and who may already run Neo4j.
Watch out for: the graph-database setup adds moving parts compared to a single-file index, and heavier backends mean more to operate.
Repo: https://github.com/CodeGraphContext/CodeGraphContext
3. Graphify
~76.9k stars · MIT · Python (YC-backed)
Graphify is the broadest of the graph tools. It installs as a skill in your AI assistant: you type /graphify . and it maps your project into a knowledge graph you can query instead of grepping.
uv tool install graphifyy # note: package is "graphifyy"
graphify install # registers the skill with your assistant
# then, inside your assistant:
/graphify .
The twist: it doesn't stop at code. Graphify ingests code (36 tree-sitter grammars, parsed locally with no API calls), plus SQL schemas, docs, PDFs, images, and even videos, so app code, database schema, and infrastructure end up in one graph. Code extraction is local; everything non-code goes through your assistant's model.
You get three artifacts: an interactive graph.html, a GRAPH_REPORT.md with "god nodes" and surprising cross-file connections, and a graph.json you can query anytime. It uses Leiden community detection to cluster your codebase, commits the graph to git so the whole team shares one map, and can run as an MCP server over stdio or HTTP.
Best for: teams that want a queryable map spanning code and surrounding artifacts (schemas, docs, papers), with a shared graph checked into git.
Watch out for: the multi-modal extraction (docs, PDFs, images) uses your model API and can cost tokens; a code-only graph stays free and local.
Repo: https://github.com/safishamsi/graphify
Retrieval and memory engines
These lean on embeddings and semantic search rather than a pure graph, and add cross-session memory.
4. Code Context Engine (CCE)
~260 stars · MIT · Python · local-first
CCE takes the retrieval approach: it indexes your code into vector embeddings and serves the relevant chunks instead of whole files. One command sets it up:
uv tool install code-context-engine
cd /path/to/your/project
cce init # index, install hooks, register MCP server
Under the hood it's a hybrid retriever: vector similarity plus BM25 keyword matching fused with Reciprocal Rank Fusion, then graph expansion along CALLS/IMPORTS edges to pull in related code. Chunks are tree-sitter AST-aware (Python, JS/TS, PHP, Go, Rust, Java) and compressed to signatures + docstrings. It stores everything in a couple of SQLite files via sqlite-vec, so the install stays small and runs on CPU.
Two things set it apart. First, cross-session memory: record_decision("use JWT for auth", reason="...") persists to SQLite and surfaces via session_recall next session, so you stop re-explaining your architecture. Second, it's security-conscious by default: it skips secret files, scans content for leaked keys, and scrubs PII from memory writes. The project reports ~94% retrieval token savings benchmarked on FastAPI, with a live dashboard and dollar-cost tracking.
Best for: solo devs and small teams who want measurable token savings, semantic search, and persistent decisions without running a graph DB.
Watch out for: it's early and small. Fewer languages have full AST chunking, and adoption/community is still building.
Repo: https://github.com/elara-labs/code-context-engine
5. Bitloops
~230 stars · Apache-2.0 · Rust · local-first
Bitloops reframes the problem. Instead of only indexing code structure, it's a memory and context layer that captures agent reasoning alongside your repository. When code changes, it records the developer–agent workflow around each commit, so reviewers see not just the diff but how the change was produced.
curl -fsSL https://bitloops.com/install.sh | bash
bitloops init --install-default-daemon
Three ideas anchor it: repository memory shared across supported agents, targeted context retrieval (retrieve relevant code + prior reasoning instead of dumping the repo), and Git-linked reasoning capture for traceability and governance. It ships a local observability dashboard, and it can ingest external knowledge by URL: GitHub issues and PRs, Jira tickets, and Confluence pages linked to your repo context. Queries run through DevQL, a typed GraphQL interface over artifacts, checkpoints, and knowledge. It's local-first (SQLite/Postgres + DuckDB/ClickHouse) and agent-agnostic (Claude Code, Codex, Cursor, Gemini, Copilot, OpenCode).
Best for: teams that care about why: auditing AI-assisted changes and keeping agent reasoning searchable across sessions and reviewers.
Watch out for: it's early (small releases, low stars) and its value depends on adopting the git-linked capture workflow across the team.
Repo: https://github.com/bitloops/bitloops
Broader agent context databases
These aren't code-specific. They manage context for agents in general, which makes them powerful and heavier.
6. OpenViking
~26.3k stars · AGPL-3.0 · Python/Rust (by Volcengine)
OpenViking is a "context database" for AI agents. It abandons flat vector storage and organizes memory, resources, and skills as a virtual filesystem under a viking:// protocol, so agents ls, find, and grep context like files.
pip install openviking --upgrade
openviking-server init # interactive setup, can use local Ollama models
openviking-server
Its design solves problems the code-only tools don't touch: tiered L0/L1/L2 loading (a one-line abstract, an overview, then full detail) to cut tokens; directory recursive retrieval that locates a high-scoring directory before refining inside it; a visualized retrieval trajectory so you can debug why something was retrieved; and automatic session management that extracts long-term memory so the agent gets smarter with use. It needs both a VLM and an embedding model (Volcengine, OpenAI, or LiteLLM-compatible providers).
Best for: teams building agents that need managed long-term memory and resources, not just a static code index, with plugins for OpenClaw, OpenCode, and Claude Code memory.
Watch out for: it's the heaviest option here (a server plus model dependencies), and it's general-purpose context, not a code graph. The AGPL-3.0 license also matters for some commercial use.
Repo: https://github.com/volcengine/OpenViking
7. Airweave
~6.5k stars · MIT · Python (FastAPI)
Airweave is a context retrieval layer that connects your apps, tools, and databases, syncs them continuously, and exposes everything through one LLM-friendly search interface. Agents query it via SDK, REST, MCP, or CLI to get grounded, up-to-date context from many sources at once.
git clone https://github.com/airweave-ai/airweave.git
cd airweave
./start.sh # Docker + docker-compose; or use the hosted cloud
It ships 50+ integrations (Confluence, Jira, Linear, Notion, Slack, GitHub, GitLab, Gmail, Google Drive, Salesforce, HubSpot, and more) and handles auth, ingestion, syncing, indexing, and retrieval so you don't rebuild pipelines per agent. The stack reflects its scope: PostgreSQL for metadata, Vespa for vectors, Temporal for orchestration, Redis for pub/sub, Kubernetes for prod.
Best for: teams that need agents to retrieve across business data sources (tickets, docs, CRM, chat), not just source code.
Watch out for: it isn't a code-graph tool. It won't give you callers/callees or a call chain; it's a unified RAG layer over many SaaS sources, and it's the most infrastructure-heavy to self-host.
Repo: https://github.com/airweave-ai/airweave
Quick comparison
| Tool | Approach | Runtime | Storage | Best fit |
|---|---|---|---|---|
| CodeGraph | Code knowledge graph | Local | SQLite + FTS5 | Fast local structural context |
| CodeGraphContext | Code knowledge graph | Local/server | FalkorDB/Kuzu/Neo4j | CLI analysis + graph queries |
| Graphify | Multi-modal graph | Local + model | JSON/HTML graph | Code + docs + schema map |
| Code Context Engine | Hybrid retrieval + memory | Local | sqlite-vec | Token savings + decisions |
| Bitloops | Reasoning memory layer | Local | SQLite/DuckDB | Auditing AI-assisted changes |
| OpenViking | Agent context database | Server + models | Filesystem paradigm | Managed long-term agent memory |
| Airweave | Multi-source retrieval | Server (Docker/K8s) | Postgres + Vespa | Context across business apps |
Rough decision guide: want a drop-in local code graph? Start with CodeGraph or CodeGraphContext. Want code plus docs and schema in one map? Graphify. Want semantic search with persistent decisions? CCE. Want to audit why agents changed things? Bitloops. Building a general agent that needs managed memory or many data sources? OpenViking or Airweave.
Where these tools stop
Notice the pattern. Six of the seven index your code. They make your agent great at structural questions: who calls this, what breaks if I change it, where is this defined. That's real value, and if code structure is your only gap, pick one and move on.
But most of what makes a codebase hard to understand isn't in the code. It's the Jira ticket that explains why a weird workaround exists. The Slack thread where the team decided to drop a feature flag. The Confluence design doc, the Google Doc spec, the incident in your observability tool that made someone add that retry loop. A pure code graph can't see any of it, so your agent still guesses at intent.
There's a second gap: reach. These tools mostly feed coding agents. They don't help the ChatGPT or Claude chat window where a PM asks "how does billing work," and they don't plug into code review, where context matters most.
This is the space Bito's AI Architect works in. It builds a knowledge graph of your codebase, then connects the context around it: coding agents (Claude Code, Cursor), issue trackers (Jira, Linear), Slack, Confluence and Google Docs, and observability tools, plus custom instructions so it follows your team's conventions. That same context feeds chat agents (ChatGPT, Claude) and Bito's AI Code Review Agent, not just your IDE. The trade-off is scope: it's a broader, integration-driven layer rather than a single local index, so it fits teams whose real bottleneck is scattered knowledge across many systems, not just call graphs.
If your agent already writes correct code but keeps missing the why, that's the gap worth closing, whether with one of the open-source tools above, a broader layer like Bito's AI Architect, or a combination.
Takeaways
- AI agents waste most of their budget on discovery. A context index removes that.
- For local, code-only structure, CodeGraph, CodeGraphContext, and Graphify are the strongest open-source graph options; CCE and Bitloops add retrieval and memory.
- OpenViking and Airweave solve a bigger problem, general agent context, at the cost of more infrastructure.
- No code-only tool captures the reasoning, tickets, docs, and signals that explain why your code looks the way it does. Decide whether that gap matters for your team before you pick.
Try one on a real repo this week and measure the token difference yourself. That's the only benchmark that counts.
Top comments (0)