code-graph-context 2.12.8 → 2.13.0

package/dist/core/embeddings/embedding-sidecar.js

@@ -184,16 +184,19 @@ export class EmbeddingSidecar {
     /**
      * Embed an array of texts. Lazily starts the sidecar if not running.
      */
-    async embed(texts) {
+    async embed(texts, gpuBatchSize) {
         await this.start();
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
         const startTime = Date.now();
         try {
+            const body = { texts };
+            if (gpuBatchSize)
+                body.batch_size = gpuBatchSize;
             const res = await fetch(`${this.baseUrl}/embed`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ texts }),
+                body: JSON.stringify(body),
                 signal: controller.signal,
             });
             if (!res.ok) {

package/dist/core/embeddings/local-embeddings.service.js

@@ -19,33 +19,25 @@ export class LocalEmbeddingsService {
         const sidecar = getEmbeddingSidecar();
         return sidecar.embed(texts);
     }
-    async embedTextsInBatches(texts, batchSize = BATCH_CONFIG.maxBatchSize) {
-        // Cap batch size — callers (e.g. graph-generator) may pass 100 which OOMs the local model
-        const safeBatchSize = Math.min(batchSize, BATCH_CONFIG.maxBatchSize);
-        await debugLog('Batch embedding started', { provider: 'local', textCount: texts.length });
+    async embedTextsInBatches(texts, _batchSize) {
+        if (texts.length === 0)
+            return [];
+        // GPU batch size controls how many texts the model processes at once (memory-bound).
+        // We send ALL texts in a single HTTP request and let the sidecar handle GPU batching
+        // internally via model.encode(batch_size=N). This eliminates HTTP round-trip overhead.
+        const gpuBatchSize = BATCH_CONFIG.maxBatchSize;
+        const gpuBatches = Math.ceil(texts.length / gpuBatchSize);
+        console.error(`[embedding] Sending ${texts.length} texts in 1 request (gpu_batch_size=${gpuBatchSize}, ~${gpuBatches} GPU batches)`);
+        await debugLog('Batch embedding started', { provider: 'local', textCount: texts.length, gpuBatchSize });
         const sidecar = getEmbeddingSidecar();
-        const results = [];
-        const totalBatches = Math.ceil(texts.length / safeBatchSize);
-        for (let i = 0; i < texts.length; i += safeBatchSize) {
-            const batch = texts.slice(i, i + safeBatchSize);
-            const batchIndex = Math.floor(i / safeBatchSize) + 1;
-            console.error(`[embedding] Batch ${batchIndex}/${totalBatches} (${batch.length} texts)`);
-            await debugLog('Embedding batch progress', {
-                provider: 'local',
-                batchIndex,
-                totalBatches,
-                batchSize: batch.length,
-            });
-            try {
-                const batchResults = await sidecar.embed(batch);
-                results.push(...batchResults);
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                console.error(`[embedding] Batch ${batchIndex}/${totalBatches} FAILED (${batch.length} texts, batchSize=${safeBatchSize}): ${msg}`);
-                throw error;
-            }
+        try {
+            const results = await sidecar.embed(texts, gpuBatchSize);
+            return results;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(`[embedding] FAILED (${texts.length} texts, gpuBatchSize=${gpuBatchSize}): ${msg}`);
+            throw error;
         }
-        return results;
     }
 }

package/dist/mcp/constants.js

@@ -380,11 +380,11 @@ export const DEFAULTS = {
 // Parsing Configuration
 export const PARSING = {
     /** File count threshold to trigger parallel parsing with worker pool */
-    parallelThreshold: 500,
+    parallelThreshold: 250,
     /** File count threshold to trigger streaming import */
     streamingThreshold: 100,
     /** Default number of files per chunk */
-    defaultChunkSize: 100,
+    defaultChunkSize: 75,
     /** Worker timeout in milliseconds (30 minutes) */
     workerTimeoutMs: 30 * 60 * 1000,
 };

package/dist/mcp/handlers/graph-generator.handler.js

@@ -24,19 +24,31 @@ export class GraphGeneratorHandler {
     }
     async generateGraph(graphJsonPath, batchSize = DEFAULTS.batchSize, clearExisting = true) {
         console.error(`Generating graph from JSON file: ${graphJsonPath}`);
-        await debugLog('Starting graph generation', { graphJsonPath, batchSize, clearExisting, projectId: this.projectId });
+        const graphData = await this.loadGraphData(graphJsonPath);
+        return this.generateGraphFromData(graphData.nodes, graphData.edges, batchSize, clearExisting, graphData.metadata);
+    }
+    /**
+     * Import nodes and edges directly from in-memory data.
+     * Skips the file read/write round-trip used by generateGraph.
+     *
+     * @param skipIndexes - When true, skips index creation (caller manages indexes).
+     *   Use this for chunked imports where indexes are created once before/after all chunks.
+     */
+    async generateGraphFromData(nodes, edges, batchSize = DEFAULTS.batchSize, clearExisting = true, metadata = {}, skipIndexes = false) {
+        await debugLog('Starting graph generation', { nodeCount: nodes.length, edgeCount: edges.length, batchSize, clearExisting, skipIndexes, projectId: this.projectId });
         try {
-            const graphData = await this.loadGraphData(graphJsonPath);
-            const { nodes, edges, metadata } = graphData;
             console.error(`Generating graph with ${nodes.length} nodes and ${edges.length} edges`);
-            await debugLog('Graph data loaded', { nodeCount: nodes.length, edgeCount: edges.length });
             if (clearExisting) {
                 await this.clearExistingData();
             }
-            await this.createProjectIndexes();
+            if (!skipIndexes) {
+                await this.createProjectIndexes();
+            }
             await this.importNodes(nodes, batchSize);
             await this.importEdges(edges, batchSize);
-            await this.createVectorIndexes();
+            if (!skipIndexes) {
+                await this.createVectorIndexes();
+            }
             const result = {
                 nodesImported: nodes.length,
                 edgesImported: edges.length,
@@ -51,6 +63,13 @@ export class GraphGeneratorHandler {
             throw error;
         }
     }
+    /**
+     * Create all indexes. Call once before chunked imports start.
+     */
+    async ensureIndexes() {
+        await this.createProjectIndexes();
+        await this.createVectorIndexes();
+    }
     async loadGraphData(graphJsonPath) {
         const fileContent = await fs.readFile(graphJsonPath, 'utf-8');
         return JSON.parse(fileContent);
@@ -81,17 +100,26 @@ export class GraphGeneratorHandler {
     }
     async importNodes(nodes, batchSize) {
         console.error(`Importing ${nodes.length} nodes with embeddings...`);
+        // Pipelined: write batch N to Neo4j while embedding batch N+1.
+        // This overlaps GPU work with Neo4j I/O.
+        let pendingWrite = null;
         for (let i = 0; i < nodes.length; i += batchSize) {
+            // Embed this batch (GPU-bound, the slow part)
             const batch = await this.processNodeBatch(nodes.slice(i, i + batchSize));
-            const result = await this.neo4jService.run(QUERIES.CREATE_NODE, { nodes: batch });
+            // Wait for previous Neo4j write before starting next
+            if (pendingWrite)
+                await pendingWrite;
+            const batchStart = i + 1;
             const batchEnd = Math.min(i + batchSize, nodes.length);
-            console.error(`Created ${result[0].created} nodes in batch ${i + 1}-${batchEnd}`);
-            await debugLog('Node batch imported', {
-                batchStart: i + 1,
-                batchEnd,
-                created: result[0].created,
+            // Start Neo4j write — don't await, overlap with next batch's embedding
+            pendingWrite = this.neo4jService.run(QUERIES.CREATE_NODE, { nodes: batch }).then(async (result) => {
+                console.error(`Created ${result[0].created} nodes in batch ${batchStart}-${batchEnd}`);
+                await debugLog('Node batch imported', { batchStart, batchEnd, created: result[0].created });
             });
         }
+        // Wait for the final write to complete
+        if (pendingWrite)
+            await pendingWrite;
     }
     /**
      * Process a batch of nodes with batched embedding calls.

package/dist/mcp/handlers/parallel-import.handler.js

@@ -3,7 +3,6 @@
  * Orchestrates parallel chunk parsing using a worker pool with pipelined import.
  * Used for large codebases (>= PARSING.parallelThreshold files).
  */
-import { join } from 'path';
 import { ProgressReporter } from '../../core/utils/progress-reporter.js';
 import { debugLog } from '../utils.js';
 import { ChunkWorkerPool } from '../workers/chunk-worker-pool.js';
@@ -41,6 +40,8 @@ export class ParallelImportHandler {
             projectId: config.projectId,
             projectType: config.projectType,
         });
+        // Create indexes once before chunked imports start
+        await this.graphGeneratorHandler.ensureIndexes();
         // Pipelined: import starts as soon as each chunk completes parsing
         const poolResult = await pool.processChunks(chunks, async (result, stats) => {
             await this.importToNeo4j(result.nodes, result.edges);
@@ -116,21 +117,6 @@ export class ParallelImportHandler {
     async importToNeo4j(nodes, edges) {
         if (nodes.length === 0 && edges.length === 0)
             return;
-        const fs = await import('fs/promises');
-        const { randomBytes } = await import('crypto');
-        const { tmpdir } = await import('os');
-        const tempPath = join(tmpdir(), `chunk-${Date.now()}-${randomBytes(8).toString('hex')}.json`);
-        try {
-            await fs.writeFile(tempPath, JSON.stringify({ nodes, edges, metadata: { parallel: true } }));
-            await this.graphGeneratorHandler.generateGraph(tempPath, 100, false);
-        }
-        finally {
-            try {
-                await fs.unlink(tempPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
+        await this.graphGeneratorHandler.generateGraphFromData(nodes, edges, 100, false, {}, true);
     }
 }

package/dist/mcp/handlers/streaming-import.handler.js

@@ -2,20 +2,9 @@
  * Streaming Import Handler
  * Orchestrates chunked parsing and import for large codebases
  */
-import { randomBytes } from 'crypto';
-import { tmpdir } from 'os';
-import { join } from 'path';
 import { ProgressReporter } from '../../core/utils/progress-reporter.js';
 import { DEFAULTS } from '../constants.js';
 import { debugLog } from '../utils.js';
-/**
- * Generate a secure temporary file path using crypto random bytes
- * to avoid race conditions and predictable filenames
- */
-const generateTempPath = (prefix) => {
-    const randomSuffix = randomBytes(16).toString('hex');
-    return join(tmpdir(), `${prefix}-${Date.now()}-${randomSuffix}.json`);
-};
 export class StreamingImportHandler {
     graphGeneratorHandler;
     progressReporter;
@@ -50,6 +39,8 @@ export class StreamingImportHandler {
         }
         let totalNodesImported = 0;
         let totalEdgesImported = 0;
+        // Create indexes once before chunked imports start
+        await this.graphGeneratorHandler.ensureIndexes();
         for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
             const chunk = chunks[chunkIndex];
             const filesProcessed = chunkIndex * config.chunkSize + chunk.length;
@@ -129,37 +120,11 @@ export class StreamingImportHandler {
         return result;
     }
     async importChunkToNeo4j(nodes, edges) {
-        const tempPath = generateTempPath('chunk');
-        const fs = await import('fs/promises');
-        try {
-            await fs.writeFile(tempPath, JSON.stringify({ nodes, edges, metadata: { chunked: true } }));
-            await this.graphGeneratorHandler.generateGraph(tempPath, DEFAULTS.batchSize, false);
-        }
-        finally {
-            try {
-                await fs.unlink(tempPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
+        await this.graphGeneratorHandler.generateGraphFromData(nodes, edges, DEFAULTS.batchSize, false, {}, true);
     }
     async importEdgesToNeo4j(edges) {
         if (edges.length === 0)
             return;
-        const tempPath = generateTempPath('edges');
-        const fs = await import('fs/promises');
-        try {
-            await fs.writeFile(tempPath, JSON.stringify({ nodes: [], edges, metadata: { edgesOnly: true } }));
-            await this.graphGeneratorHandler.generateGraph(tempPath, DEFAULTS.batchSize, false);
-        }
-        finally {
-            try {
-                await fs.unlink(tempPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
+        await this.graphGeneratorHandler.generateGraphFromData([], edges, DEFAULTS.batchSize, false, {}, true);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "2.12.8",
+  "version": "2.13.0",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
   "homepage": "https://github.com/drewdrewH/code-graph-context#readme",