feat: Enhance CodeGraph MCP with edge derivation and server capabilities

- Integrated edge derivation using ParserGraphIntegrator in ProjectIndexer.
- Added support for new node types: Struct and Trait in indexing statistics.
- Introduced a new server module for handling HTTP and STDIO transports.
- Implemented various RPC methods for graph operations, code reading, patching, and test execution.
- Added documentation for MCP tools and repository knowledge system to guide usage.
- Improved text truncation logic in embedding generation to respect character boundaries.

Author: jruokola

.codegraph/index.json

@@ -168,4 +168,4 @@ CLAUDE.md
 AGENTS.md
 CRUSH.md
 OUROBOROS.md
-.codegraph/index.json
+.codegraph/

.gitignore

@@ -162,6 +162,98 @@ sudo dnf install cmake clang openssl-devel
 - **CUDA** (for GPU-accelerated embeddings)
 - **Git** (for repository integration)
 
+## 🚀 Performance Benchmarks
+
+Run repeatable, end-to-end benchmarks that measure indexing speed (with local embeddings + FAISS), vector search latency, and graph traversal throughput.
+
+### Build with performance features
+
+Pick one of the local embedding backends and enable FAISS:
+
+```bash
+# Option A: ONNX Runtime (CoreML on macOS, CPU otherwise)
+cargo install --path crates/codegraph-mcp --features "embeddings,codegraph-vector/onnx,faiss"
+
+# Option B: Local HF + Candle (CPU/Metal/CUDA)
+cargo install --path crates/codegraph-mcp --features "embeddings-local,faiss"
+```
+
+### Configure local embedding backend
+
+ONNX (CoreML/CPU):
+
+```bash
+export CODEGRAPH_EMBEDDING_PROVIDER=onnx
+# macOS: use CoreML
+export CODEGRAPH_ONNX_EP=coreml   # or cpu
+export CODEGRAPH_LOCAL_MODEL=/path/to/model.onnx
+```
+
+Local HF + Candle (CPU/Metal/CUDA):
+
+```bash
+export CODEGRAPH_EMBEDDING_PROVIDER=local
+# device: cpu | metal | cuda:<id>
+export CODEGRAPH_LOCAL_MODEL=sentence-transformers/all-MiniLM-L6-v2
+```
+
+### Run the benchmark
+
+```bash
+# Cold run (cleans .codegraph), warmup queries + timed trials
+codegraph perf . \
+  --langs rust,ts,go \
+  --warmup 3 --trials 20 \
+  --batch-size 128 --device metal \
+  --clean --format json
+```
+
+What it measures
+
+- Indexing: total time to parse -> embed -> build FAISS (global + shards)
+- Embedding throughput: embeddings per second
+- Vector search: latency (avg/p50/p95) across repeated queries
+- Graph traversal: BFS depth=2 micro-benchmark
+
+Sample output (numbers will vary by machine and codebase)
+
+```json
+{
+  "env": {
+    "embedding_provider": "local",
+    "device": "metal",
+    "features": { "faiss": true, "embeddings": true }
+  },
+  "dataset": {
+    "path": "/repo/large-project",
+    "languages": ["rust","ts","go"],
+    "files": 18234,
+    "lines": 2583190
+  },
+  "indexing": {
+    "total_seconds": 186.4,
+    "embeddings": 53421,
+    "throughput_embeddings_per_sec": 286.6
+  },
+  "vector_search": {
+    "queries": 100,
+    "latency_ms": { "avg": 18.7, "p50": 12.3, "p95": 32.9 }
+  },
+  "graph": {
+    "bfs_depth": 2,
+    "visited_nodes": 1000,
+    "elapsed_ms": 41.8
+  }
+}
+```
+
+Tips for reproducibility
+
+- Use `--clean` for cold start numbers, and run a second time for warm cache numbers.
+- Close background processes that may compete for CPU/GPU.
+- Pin versions: `rustc --version`, FAISS build, and the embedding model.
+- Record the host: CPU/GPU, RAM, storage, OS version.
+
 ## 🚀 Installation
 
 ### Method 1: Install from Source

Cargo.lock

@@ -241,6 +241,24 @@ where
                             meta.insert("kind".into(), "call".into());
                             meta.insert("file".into(), file.to_string_lossy().to_string());
                             edges.push((*from_id, *to_id, EdgeType::Calls, meta));
+                        } else if content.as_str().contains(other_name.as_str()) {
+                            // Reference without obvious call signature
+                            let mut meta = HashMap::new();
+                            meta.insert("kind".into(), "reference".into());
+                            meta.insert("file".into(), file.to_string_lossy().to_string());
+                            edges.push((*from_id, *to_id, EdgeType::References, meta));
+                        }
+                    }
+                    // Implements (rough heuristic for Rust/Java): "impl <Trait> for <Type>" or "implements <Iface>"
+                    let lc = content.to_lowercase();
+                    if lc.contains(" implements ") {
+                        for (other_name, to_id, _ctx2) in names_in_file.iter() {
+                            if lc.contains(&other_name.to_lowercase()) {
+                                let mut meta = HashMap::new();
+                                meta.insert("kind".into(), "implements".into());
+                                meta.insert("file".into(), file.to_string_lossy().to_string());
+                                edges.push((*from_id, *to_id, EdgeType::Implements, meta));
+                            }
                         }
                     }
                 }

README.md

@@ -44,6 +44,9 @@ faiss = { workspace = true, optional = true }
 # codegraph-api not used directly here; avoid pulling heavy deps
 ## core-rag-mcp-server intentionally not linked to keep binary lean
 
+axum = { workspace = true, optional = true }
+hyper = { workspace = true, optional = true }
+
 [dev-dependencies]
 tokio-test = { workspace = true }
 tempfile = { workspace = true }
@@ -58,3 +61,4 @@ faiss = ["dep:faiss"]
 embeddings = ["dep:codegraph-vector"]
 embeddings-local = ["embeddings", "codegraph-vector/local-embeddings"]
 embeddings-openai = ["embeddings", "codegraph-vector/openai"]
+server-http = ["dep:axum", "dep:hyper"]