Code-Graph-RAG Roadmap: 2026–2027 Development Plan

Code-Graph-RAG is a two-component open-source system that converts source code into a knowledge graph and enables natural-language querying, with a public roadmap outlining seven major goals through mid-2027.

This article breaks down the official Code-Graph-RAG roadmap maintained in the vitali87/code-graph-rag repository. You'll learn what improvements are planned, which architectural components are affected, and what deliberate constraints keep the project focused on local-first, CLI-driven code intelligence.

How Code-Graph-RAG Works Today

Before examining future plans, understanding the current architecture clarifies why each roadmap item matters.

The system splits cleanly into two layers:

• Multi-Language Parser — A Tree-sitter-based ingestion pipeline that parses source code and stores structured AST data in Memgraph (codebase_rag/parsers/).
• RAG System (codebase_rag/) — A CLI and Python SDK that translates natural language into Cypher queries, retrieves relevant code snippets, and supports AI-driven edits.

The ask() function in codebase_rag/cli.py and the real-time cgr-updater command both depend on this pipeline, as shown in the usage examples below.

Seven Priority Goals (Mid-2026 to Mid-2027)

The roadmap organizes development into seven concrete objectives, each tied to specific files and measurable outcomes.

1. Deepen Analysis Quality for Existing Languages

Better call-resolution, type inference, and data-flow edges across all supported languages.

This improves the AST extraction logic in codebase_rag/parsers/ and enriches the Memgraph schema documented in [docs/architecture/graph-schema.md](https://github.com/vitali87/code-graph-rag/blob/main/docs/architecture/graph-schema.md). Rather than adding surface-level language support, the focus is making existing extractions more precise—especially for cross-file references and implicit type flows.

2. Improve Dead-Code Detection Precision

Reduce false positives by validating against large open-source repositories.

The dead-code analyzer in codebase_rag/dead_code.py will be stress-tested against real-world codebases. Findings from this process feed back into both the analysis heuristics and the evaluation harness that measures accuracy.

3. Maintain and Extend the Evaluation Harness

Keep per-language AST oracles current and expand test coverage.

The evals/ directory—particularly files like evals/static_calls.py—provides ground-truth validation for parser output. This roadmap item ensures new analysis features ship with rigorous, automated correctness checks.

4. Grow the Configuration-Driven Language Tier

Enable new languages via YAML configuration instead of custom extractors.

Code-Graph-RAG already supports a hybrid architecture: hand-written Tree-sitter extractors for complex languages, and ast-grep YAML rules for simpler cases. This goal extends codebase_rag/language_spec.py to make YAML-driven additions the default path, lowering the barrier for community contributions.

5. Stabilize the SDK and MCP Server

Maintain API stability under the pre-1.0 versioning policy.

Three public interfaces fall under this umbrella:

• The Typer-based CLI (codebase_rag/cli.py) — ask and cgr-updater commands
• The generated Python SDK (codebase_rag/sdk/)
• The Model-Context-Protocol (MCP) server integration

Breaking changes will be documented, but full semantic-versioning guarantees wait until a 1.0 release.

6. Performance and Incremental Updates

Reduce ingestion time for large repositories and accelerate real-time syncing.

Two specific modules are targeted:

• codebase_rag/graph_updater.py — handles live file watching and delta updates
• codebase_rag/embedder.py — manages vector embedding and caching

Together, these changes make Code-Graph-RAG practical for monorepo-scale codebases without sacrificing the local-first architecture.

7. Security Posture

Retain the OpenSSF Best Practices badge and pursue silver-level certification.

This involves dependency hygiene tracked in pyproject.toml (which pins tree-sitter, pymgclient, mcp, and other critical packages) plus continuous security scanning via GitHub Workflows.

What the Project Will Not Do

The roadmap explicitly defines three boundaries to maintain focus:

Excluded Scope	Rationale
No new first-class language extractors without concrete user demand	Keeps maintenance burden manageable; YAML-tier expansion preferred
No hosted SaaS offering	Preserves local-first, privacy-respecting design
No API stability guarantees before 1.0	Allows iterative refinement based on real-world usage

These constraints reinforce Code-Graph-RAG's identity as a maintainable, open-source CLI tool that runs entirely on the user's machine.

Using Code-Graph-RAG Today

The following examples demonstrate the core workflows that the roadmap aims to improve.

Python SDK: Load and Query

from codebase_rag.graph_loader import load_graph
from codebase_rag.cli import ask

# Load a pre-indexed Python package

graph = load_graph("my_python_pkg")

# Ask natural-language questions; Cypher generation happens automatically

answer = ask("Where is the function that parses JSON?", graph=graph)
print(answer)

load_graph() is implemented in codebase_rag/graph_loader.py, while ask() wraps the RAG pipeline including Cypher translation and snippet retrieval.

CLI: Real-Time Graph Updates

# Watch a repository and automatically refresh the knowledge graph on file changes

cgr-updater --path /path/to/repo --watch

This invokes the watcher logic in codebase_rag/graph_updater.py, which the roadmap targets for performance optimization.

Summary

• Code-Graph-RAG combines Tree-sitter parsing with a Memgraph-backed RAG system for natural-language code exploration.
• The 2026–2027 roadmap prioritizes analysis depth, dead-code accuracy, evaluation coverage, YAML-driven language expansion, SDK stability, performance, and security.
• Key architectural files include codebase_rag/parsers/ (extraction), codebase_rag/graph_updater.py (live updates), evals/ (testing), and codebase_rag/cli.py (user interface).
• Explicit exclusions keep the project local-first, pre-1.0 flexible, and focused on configuration-based language growth rather than unlimited custom extractors.

Frequently Asked Questions

When will Code-Graph-RAG reach version 1.0?

Per the roadmap, no specific date is set. The project follows a "pre-1.0 versioning policy" that allows API iteration while documenting breaking changes. Stability guarantees arrive only after the SDK, MCP server, and CLI interfaces mature through real-world usage.

How can I add support for a new programming language?

Use the YAML configuration tier in codebase_rag/language_spec.py with ast-grep rules for straightforward languages. First-class Tree-sitter extractors in codebase_rag/parsers/ are reserved for cases with demonstrated demand and community commitment to maintenance.

Is there a hosted or cloud version planned?

No. The roadmap explicitly excludes a SaaS offering. Code-Graph-RAG remains designed for local execution, keeping source code within the user's environment and avoiding external data transmission.

What database does Code-Graph-RAG use for the knowledge graph?

Memgraph serves as the primary graph database. The codebase_rag/graph_loader.py module handles connection and query execution, while pymgclient (listed in pyproject.toml) provides the Python driver.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}