feat: Add read-only mode for CodeGraph to enhance performance during queries

Author: jruokola

README.md

@@ -24,17 +24,26 @@
 
 ## 🎯 Overview
 
-CodeGraph is a powerful CLI tool that combines MCP (Model Context Protocol) server management with sophisticated code analysis capabilities. It provides a unified interface for indexing projects, managing embeddings, and running MCP servers with multiple transport options.
+CodeGraph is a powerful CLI tool that combines MCP (Model Context Protocol) server management with sophisticated code analysis capabilities. It provides a unified interface for indexing projects, managing embeddings, and running MCP servers with multiple transport options. All you now need is an Agent(s) to create your very own deep code and project knowledge synthehizer system!
 
 ### Key Capabilities
 
 - **🔍 Advanced Code Analysis**: Parse and analyze code across multiple languages using Tree-sitter
 - **🚄 Dual Transport Support**: Run MCP servers with STDIO, HTTP, or both simultaneously
 - **🎯 Vector Search**: Semantic code search using FAISS-powered vector embeddings
 - **📊 Graph-Based Architecture**: Navigate code relationships with RocksDB-backed graph storage
-- **⚡ High Performance**: Optimized for large codebases with parallel processing
+- **⚡ High Performance**: Optimized for large codebases with parallel processing and batched embeddings
 - **🔧 Flexible Configuration**: Extensive configuration options for embedding models and performance tuning
 
+## RAW PERFORMANCE ✨✨✨
+
+170K lines of rust code in 0.49sec! 21024 embeddings in 3:24mins! On M3 Pro 32GB Qdrant/all-MiniLM-L6-v2-onnx on CPU no Metal acceleration used!
+
+```bash
+Parsing completed: 353/353 files, 169397 lines in 0.49s (714.5 files/s, 342852 lines/s)
+[00:03:24] [########################################] 21024/21024 Embeddings complete
+```
+
 ## ✨ Features
 
 ### Core Features

crates/codegraph-graph/src/graph.rs

@@ -45,6 +45,19 @@ impl CodeGraph {
         })
     }
 
+    pub fn new_read_only() -> Result<Self> {
+        let storage = Arc::new(HighPerformanceRocksDbStorage::new_read_only("./data/graph.db")?);
+
+        Ok(Self {
+            storage,
+            node_cache: Arc::new(DashMap::with_capacity(100_000)),
+            edge_cache: Arc::new(DashMap::with_capacity(50_000)),
+            query_optimizer: None,
+            query_stats: Arc::new(RwLock::new(QueryStats::default())),
+            path_cache: Arc::new(DashMap::with_capacity(10_000)),
+        })
+    }
+
     pub fn new_with_cache() -> Result<Self> {
         let cache = GraphQueryCache::new();
         let cache_manager = CacheManager::new(cache, Duration::from_secs(60));

crates/codegraph-graph/src/storage.rs

@@ -195,6 +195,48 @@ impl HighPerformanceRocksDbStorage {
         Ok(storage)
     }
 
+    pub fn new_read_only<P: AsRef<Path>>(path: P) -> Result<Self> {
+        let mut db_opts = Options::default();
+        // Do not create missing; expect an existing DB schema
+        db_opts.set_compression_type(DBCompressionType::Lz4);
+        db_opts.set_bottommost_compression_type(DBCompressionType::Zstd);
+        db_opts.set_use_direct_reads(false);
+        db_opts.set_use_direct_io_for_flush_and_compaction(false);
+        db_opts.set_allow_mmap_reads(true);
+        db_opts.set_allow_mmap_writes(false);
+
+        // Open existing column families in read-only mode
+        let cf_names = vec![NODES_CF, EDGES_CF, INDICES_CF, METADATA_CF];
+        let db = DB::open_cf_for_read_only(&db_opts, &path, cf_names, false)
+            .map_err(|e| CodeGraphError::Database(format!("Failed to open database (read-only): {}", e)))?;
+
+        let batching_config = BatchingConfig::default();
+        let db_arc = Arc::new(db);
+        let read_cache = Arc::new(DashMap::with_capacity(100_000));
+        let read_coalescer = ReadCoalescer::new(
+            db_arc.clone(),
+            NODES_CF,
+            read_cache.clone(),
+            batching_config.clone(),
+        );
+
+        let storage = Self {
+            db: db_arc,
+            db_path: path.as_ref().to_path_buf(),
+            read_cache,
+            edge_cache: Arc::new(DashMap::with_capacity(50_000)),
+            edge_counter: AtomicU64::new(1),
+            memory_tables: Arc::new(RwLock::new(HashMap::new())),
+            batching_config: batching_config.clone(),
+            read_coalescer,
+        };
+
+        // Safe to attempt reading counters in read-only mode
+        let _ = storage.initialize_counters();
+
+        Ok(storage)
+    }
+
     pub(crate) fn add_node_inner(&self, node: &CodeNode) -> Result<()> {
         let node_id = node.id;
         let serializable_node = SerializableCodeNode::from(node.clone());

crates/codegraph-mcp/src/bin/codegraph.rs

@@ -211,6 +211,7 @@ enum Commands {
         #[arg(long, default_value = "512")] max_seq_len: usize,
         #[arg(long, help = "Remove existing .codegraph before indexing")] clean: bool,
         #[arg(long, default_value = "json", value_parser = clap::builder::PossibleValuesParser::new(["human","json"]))] format: String,
+        #[arg(long, help = "Open graph in read-only mode for perf queries")] graph_readonly: bool,
     },
     #[command(about = "Serve HTTP MCP endpoint")]
     #[cfg(feature = "server-http")]
@@ -538,7 +539,7 @@ async fn main() -> Result<()> {
                 }
             }
         }
-        Commands::Perf { path, langs, warmup, trials, queries, workers, batch_size, device, max_seq_len, clean, format } => {
+        Commands::Perf { path, langs, warmup, trials, queries, workers, batch_size, device, max_seq_len, clean, format, graph_readonly } => {
             handle_perf(
                 path,
                 langs,
@@ -551,6 +552,7 @@ async fn main() -> Result<()> {
                 max_seq_len,
                 clean,
                 format,
+                graph_readonly,
             )
             .await?;
         }
@@ -1171,6 +1173,7 @@ async fn handle_perf(
     max_seq_len: usize,
     clean: bool,
     format: String,
+    graph_readonly: bool,
 ) -> Result<()> {
     use std::time::Instant;
     use serde_json::json;
@@ -1197,6 +1200,10 @@ async fn handle_perf(
     let t0 = Instant::now();
     let stats = indexer.index_project(&path).await?;
     let indexing_secs = t0.elapsed().as_secs_f64();
+    // Release RocksDB handle before running queries (which open their own graph handles)
+    drop(indexer);
+    // Give RocksDB a brief moment to release OS locks
+    tokio::time::sleep(std::time::Duration::from_millis(75)).await;
 
     let qset = if let Some(q) = queries {
         q
@@ -1236,7 +1243,30 @@ async fn handle_perf(
         latencies_ms.iter().sum::<f64>() / latencies_ms.len() as f64
     };
 
-    let graph = codegraph_graph::CodeGraph::new()?;
+    // Open graph with small retry to avoid transient lock contention
+    let graph = {
+        use std::time::Duration;
+        let mut attempts = 0;
+        loop {
+            let open_res = if graph_readonly {
+                codegraph_graph::CodeGraph::new_read_only()
+            } else {
+                codegraph_graph::CodeGraph::new()
+            };
+            match open_res {
+                Ok(g) => break g,
+                Err(e) => {
+                    let msg = e.to_string();
+                    if msg.contains("LOCK") && attempts < 10 {
+                        tokio::time::sleep(Duration::from_millis(50)).await;
+                        attempts += 1;
+                        continue;
+                    }
+                    return Err(e.into());
+                }
+            }
+        }
+    };
     let mut any_node: Option<codegraph_core::NodeId> = None;
     if let Ok(ids_raw) = std::fs::read_to_string(".codegraph/faiss_ids.json") {
         if let Ok(ids) = serde_json::from_str::<Vec<codegraph_core::NodeId>>(&ids_raw) {

crates/codegraph-mcp/src/server.rs

@@ -299,7 +299,24 @@ pub async fn bin_search_with_scores(
         scored.dedup_by_key(|(id, _)| *id);
         let top: Vec<(codegraph_core::NodeId, f32)> = scored.into_iter().take(limit).collect();
 
-        let graph = codegraph_graph::CodeGraph::new()?;
+    let graph = {
+        use std::time::Duration;
+        let mut attempts = 0;
+        loop {
+            match codegraph_graph::CodeGraph::new_read_only() {
+                Ok(g) => break g,
+                Err(e) => {
+                    let msg = e.to_string();
+                    if msg.contains("LOCK") && attempts < 10 {
+                        tokio::time::sleep(Duration::from_millis(50)).await;
+                        attempts += 1;
+                        continue;
+                    }
+                    return Err(e.into());
+                }
+            }
+        }
+    };
         let mut out = Vec::new();
         for (id, score) in top {
             if let Some(node) = graph.get_node(id).await? {