feat: add clean install guide and enhance tool call parsing in agentic orchestrator

Author: jruokola

CLEAN_INSTALL.md

@@ -0,0 +1,50 @@
+# Clean Install Guide
+
+Follow these steps to remove every trace of a previous CodeGraph MCP installation and rebuild from scratch.
+
+1. **Stop running servers**  
+   Close every terminal session that is running `codegraph start …` (Ctrl+C) so no process holds binaries or logs open.
+
+2. **Remove installed binaries**  
+   If you used the installer, it dropped symlinks/binaries into `/usr/local/bin`. Remove them:
+   ```bash
+   sudo rm -f /usr/local/bin/codegraph /usr/local/bin/codegraph-official
+   ```
+
+3. **Delete the installer support directory**  
+   The installer caches logs/config under `~/.codegraph`. Remove it to avoid stale state:
+   ```bash
+   rm -rf ~/.codegraph
+   ```
+
+4. **Clean the repository build artifacts**  
+   From the repo root run both commands to guarantee a fresh rebuild:
+   ```bash
+   cargo clean
+   rm -rf target
+   ```
+
+5. **(Optional) Remove Python test environments**  
+   If you created a virtualenv or pip install for `test_http_mcp.py`, delete that environment so you can reinstall dependencies cleanly.
+
+6. **Re-run the installer**  
+   Execute the installer once (choose the script you normally use, e.g. cloud):
+   ```bash
+   ./install-codegraph-cloud.sh
+   ```
+   This recreates `/usr/local/bin/codegraph` pointing at the freshly built release binary.
+
+7. **Rebuild your development binary**  
+   Inside the repo, rebuild with the required features so the local `target/` tree matches your latest changes:
+   ```bash
+   cargo build -p codegraph-mcp --features "ai-enhanced,server-http"
+   ```
+
+8. **Start the MCP server with the new binary**  
+   Launch STDIO or HTTP using the freshly built binary (debug path shown here):
+   ```bash
+   ./target/debug/codegraph start mcp http --port 3003
+   ```
+   Replace `http` with `stdio` or use the release path if desired.
+
+Once these steps are complete, you are running on a completely clean install and can rerun the MCP tests with confidence.

crates/codegraph-mcp/src/agentic_orchestrator.rs

@@ -533,10 +533,13 @@ impl AgenticOrchestrator {
                 let name = tool_call
                     .get("tool_name")
                     .or_else(|| tool_call.get("name"))
+                    .or_else(|| tool_call.get("function"))
+                    .or_else(|| tool_call.get("tool"))
                     .and_then(|v| v.as_str());
                 let params = tool_call
                     .get("parameters")
                     .or_else(|| tool_call.get("arguments"))
+                    .or_else(|| tool_call.get("args"))
                     .cloned();
                 (name.map(|s| s.to_string()), params)
             } else {
@@ -660,4 +663,78 @@ mod tests {
         );
         assert!(!step.is_final);
     }
+
+    #[test]
+    fn test_parse_tool_call_with_args_field() {
+        let json_response = r#"{
+            "reasoning": "Trace call chain",
+            "tool_call": {
+                "tool_name": "trace_call_chain",
+                "args": {
+                    "from_node": "GraphToolExecutor",
+                    "max_depth": 4
+                }
+            },
+            "is_final": false
+        }"#;
+
+        let step = AgenticOrchestrator::parse_llm_response_internal(3, json_response)
+            .expect("Should parse args field");
+
+        assert_eq!(step.tool_name, Some("trace_call_chain".to_string()));
+        assert_eq!(
+            step.tool_params
+                .as_ref()
+                .and_then(|p| p["max_depth"].as_i64())
+                .unwrap_or_default(),
+            4
+        );
+    }
+
+    #[test]
+    fn test_parse_tool_call_with_function_field() {
+        let json_response = r#"{
+            "reasoning": "Check hubs",
+            "tool_call": {
+                "function": "get_hub_nodes",
+                "arguments": {
+                    "min_degree": 9
+                }
+            },
+            "is_final": false
+        }"#;
+
+        let step = AgenticOrchestrator::parse_llm_response_internal(4, json_response)
+            .expect("Should parse function field");
+
+        assert_eq!(step.tool_name, Some("get_hub_nodes".to_string()));
+        assert_eq!(
+            step.tool_params
+                .as_ref()
+                .and_then(|p| p["min_degree"].as_i64())
+                .unwrap_or_default(),
+            9
+        );
+    }
+
+    #[test]
+    fn test_parse_tool_call_with_tool_field() {
+        let json_response = r#"{
+            "reasoning": "Check dependencies",
+            "tool_call": {
+                "tool": "get_transitive_dependencies",
+                "parameters": {
+                    "node_id": "AgenticOrchestrator",
+                    "edge_type": "Imports",
+                    "depth": 2
+                }
+            },
+            "is_final": false
+        }"#;
+
+        let step = AgenticOrchestrator::parse_llm_response_internal(5, json_response)
+            .expect("Should parse tool field");
+
+        assert_eq!(step.tool_name, Some("get_transitive_dependencies".to_string()));
+    }
 }

crates/codegraph-mcp/src/autoagents/agent_builder.rs

@@ -222,9 +222,9 @@ struct CodeGraphLLMResponse {
 
 #[derive(Debug, Deserialize)]
 struct CodeGraphToolCall {
-    #[serde(alias = "name")]
+    #[serde(alias = "name", alias = "function", alias = "tool")]
     tool_name: String,
-    #[serde(alias = "arguments")]
+    #[serde(alias = "arguments", alias = "args")]
     parameters: serde_json::Value,
 }
 
@@ -637,6 +637,74 @@ mod tests {
         assert_eq!(tool_calls[0].function.arguments, "{\"min_degree\":4}");
     }
 
+    #[test]
+    fn test_tool_calls_accepts_args_field() {
+        let response = CodeGraphChatResponse {
+            content: r#"{
+                "reasoning": "Trace chain",
+                "tool_call": {
+                    "tool_name": "trace_call_chain",
+                    "args": {
+                        "from_node": "GraphToolExecutor",
+                        "max_depth": 4
+                    }
+                },
+                "is_final": false
+            }"#
+            .to_string(),
+            _total_tokens: 0,
+        };
+
+        let tool_calls = response.tool_calls().expect("tool call not parsed");
+        assert_eq!(tool_calls[0].function.name, "trace_call_chain");
+        assert_eq!(tool_calls[0].function.arguments, "{\"from_node\":\"GraphToolExecutor\",\"max_depth\":4}");
+    }
+
+    #[test]
+    fn test_tool_calls_accepts_function_field() {
+        let response = CodeGraphChatResponse {
+            content: r#"{
+                "reasoning": "Find hubs",
+                "tool_call": {
+                    "function": "get_hub_nodes",
+                    "arguments": {
+                        "min_degree": 6
+                    }
+                },
+                "is_final": false
+            }"#
+            .to_string(),
+            _total_tokens: 0,
+        };
+
+        let tool_calls = response.tool_calls().expect("tool call not parsed");
+        assert_eq!(tool_calls[0].function.name, "get_hub_nodes");
+        assert_eq!(tool_calls[0].function.arguments, "{\"min_degree\":6}");
+    }
+
+    #[test]
+    fn test_tool_calls_accepts_tool_field() {
+        let response = CodeGraphChatResponse {
+            content: r#"{
+                "reasoning": "Dependencies",
+                "tool_call": {
+                    "tool": "get_transitive_dependencies",
+                    "parameters": {
+                        "node_id": "AgenticOrchestrator",
+                        "edge_type": "Imports",
+                        "depth": 2
+                    }
+                },
+                "is_final": false
+            }"#
+            .to_string(),
+            _total_tokens: 0,
+        };
+
+        let tool_calls = response.tool_calls().expect("tool call not parsed");
+        assert_eq!(tool_calls[0].function.name, "get_transitive_dependencies");
+    }
+
     // Integration test for ChatProvider
     struct MockCodeGraphLLM;
 

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

@@ -2795,12 +2795,12 @@ fn optimize_for_memory(
         if embedding_provider == "ollama" {
             // Ollama models work better with smaller batches for stability
             match memory_gb {
-                128.. => 1024,   // 128GB+: Large but stable batch size
-                96..=127 => 768, // 96-127GB: Medium-large batch
-                64..=95 => 512,  // 64-95GB: Medium batch
-                32..=63 => 256,  // 32-63GB: Small batch
-                16..=31 => 128,  // 16-31GB: Very small batch
-                _ => 64,         // <16GB: Minimal batch
+                128.. => 64,    // 128GB+: Even high-memory boxes benefit from modest batches with Ollama
+                96..=127 => 64, // 96-127GB: Keep batches capped for GPU/CPU stability
+                64..=95 => 48,  // 64-95GB: Slightly leaner batch for steady throughput
+                32..=63 => 32,  // 32-63GB: Conservative batch to prevent throttling
+                16..=31 => 24,  // 16-31GB: Small batch keeps latency predictable
+                _ => 16,        // <16GB: Minimal batch on constrained systems
             }
         } else {
             // ONNX/OpenAI can handle much larger batches

crates/codegraph-vector/src/ollama_embedding_provider.rs

@@ -421,8 +421,18 @@ impl EmbeddingProvider for OllamaEmbeddingProvider {
         // Accumulate chunk embeddings for each node
         for (chunk_idx, chunk_embedding) in chunk_embeddings.into_iter().enumerate() {
             let node_idx = chunk_to_node[chunk_idx];
-            for (i, &val) in chunk_embedding.iter().enumerate() {
-                node_embeddings[node_idx][i] += val;
+            if chunk_embedding.len() != dimension {
+                warn!(
+                    "⚠️ Ollama embedding dimension mismatch: expected {}, got {}",
+                    dimension,
+                    chunk_embedding.len()
+                );
+            }
+            for (slot, value) in node_embeddings[node_idx]
+                .iter_mut()
+                .zip(chunk_embedding.iter())
+            {
+                *slot += *value;
             }
             node_chunk_counts[node_idx] += 1;
         }