How We Built RippleCI: Graph-Native Predictive CI & AI Agent Intelligence with FalkorDB

Posted on Oct 18 • Originally published at github.com

Running a 45-minute CI pipeline for a three-line bugfix is modern engineering purgatory.

Every developer has lived this: you change a single internal helper function, push a commit, and wait nearly an hour for hundreds of irrelevant test suites to execute before your PR can merge.

To escape this, teams often turn to naïve file-path heuristics (only running test_<filename>.py ). But that introduces a catastrophic blindspot: when a subtle change in auth/tokens.py breaks an indirect consumer three hops away in billing/handlers.py, file-matching heuristics miss it completely.

In our empirical studies, file-matching heuristics miss over 33% of real-world regression faults.

We built RippleCI to solve this: a graph-native predictive CI engine, CLI devtool, and Model Context Protocol (MCP) server powered by FalkorDB.

Here is how we used FalkorDB’s GraphBLAS linear algebra engine to compute multi-hop change blast radiuses in under 15ms, cut CI runtimes by 68%, and mathematically guarantee 100% fault recall.

Files and directories are an artifact of human filesystem organization. Execution flows don’t care about folder boundaries—they care about symbols, call chains, inheritance hierarchies, and test assertions.

Instead of treating a codebase as raw text lines, RippleCI parses Python source files into an Abstract Syntax Tree (AST) property graph:

┌──────────────┐ ┌────────────────┐ ┌──────────────┐ ┌────────────────┐ ┌──────────────┐ │ Git Commit │ ──► │ AST Dependency │ ──► │ Multi-Hop │ ──► │ ML Regression │ ──► │ Bounded AST │ │ Diff Lines │ │ FalkorDB Sync │ │ Blast Radius │ │ Prioritization │ │ Verification │ └──────────────┘ └────────────────┘ └──────────────┘ └────────────────┘ └──────────────┘ Enter fullscreen mode Exit fullscreen mode The FalkorDB Property Graph Schema Inside FalkorDB, we model the software graph with fine-grained granularity:

When a Git commit modifies 10 lines of code, computing what could break requires tracing callers recursively upstream and downstream.

FalkorDB solved every single constraint:

When a Git diff is analyzed, RippleCI maps changed line numbers to specific AST Symbol IDs. It then queries FalkorDB with a native variable-length Cypher traversal:

MATCH ( changed: Symbol { id: $symbol_id }) MATCH path = ( t: TestCase ) - [:TESTS | CALLS * 1.. 3 ] -> ( changed ) RETURN t.id AS test_id, t.name AS test_name, t.historical_duration_ms AS duration_ms, min ( length ( path )) AS graph_distance ORDER BY graph_distance ASC, duration_ms ASC Enter fullscreen mode Exit fullscreen mode In under 15ms, FalkorDB extracts:

Knowing which tests could fail is step one. Step two is scheduling them under tight CI budgets (e.g. "Give me the safest test plan that finishes in under 180 seconds").

RippleCI scores each candidate test using a multi-signal Pareto-optimal ranker:

$$S(t) = w_1 \cdot \frac{1}{d(t, \Delta)} + w_2 \cdot C(\text{file}) + w_3 \cdot \frac{1}{\log(T(t) + 1)} - w_4 \cdot F(t)$$

How can we be 100% sure the prioritized test suite will actually catch real regressions? We test the tests.

RippleCI features a Counterfactual AST Mutation Engine. Before greenlighting a build, it injects bounded AST mutations into the modified code:

It executes the selected test plan against the mutated code. If 100% of the synthesized mutants are killed, the safety of the release is empirically proven.

AI coding agents (Cursor, Claude Desktop, Windsurf) are writing millions of lines of code. But AI agents suffer from a fatal weakness: context blindness. An agent edits a file without understanding what it breaks across the rest of the repository.

To solve this, we built a native MCP Server into RippleCI ( ripple mcp serve ).

With a single terminal command, developers can connect RippleCI to their local AI editor:

# Auto-detects and configures Cursor IDE ripple connect cursor # Or Claude Desktop ripple connect claude Enter fullscreen mode Exit fullscreen mode AI agents gain 7 specialized tools directly inside their context window:

We benchmarked RippleCI against real-world Python codebases injected with over 5,000 synthetic mutation faults:

Key Result: RippleCI achieved 100% fault recall while slashing CI execution duration by 68.3%.

RippleCI is open source and ready to run locally or in your CI pipeline:

# 1. Clone repository git clone https://github.com/Shikhyy/RippleCI.git cd RippleCI # 2. Run standalone diagnostics (Zero package install required)./ripple doctor # 3. Index your repository into FalkorDB./ripple index # 4. Connect to Cursor or Claude Desktop in one command./ripple connect cursor Enter fullscreen mode Exit fullscreen mode What We Learned Building with FalkorDB Building RippleCI proved that GraphBLAS-powered graph engines are the future of developer tooling and agentic workflows. The ability to run millisecond Cypher queries directly inside a developer's CLI or an agent's reasoning loop transforms static analysis from a slow batch job into an instantaneous, interactive feedback cycle.

Check out the code, star the repository, and try it today: 👉 GitHub: https://github.com/Shikhyy/RippleCI