code-graph-context 2.12.7 → 2.13.0

package/README.md

@@ -190,7 +190,7 @@ If you prefer to edit the config files directly:
 | `NEO4J_USER` | No | `neo4j` | Neo4j username |
 | `NEO4J_PASSWORD` | No | `PASSWORD` | Neo4j password |
 | `EMBEDDING_MODEL` | No | `codesage/codesage-base-v2` | Local embedding model (see [Embedding Configuration](#embedding-configuration)) |
-| `EMBEDDING_BATCH_SIZE` | No | `16` | Texts per embedding batch (lower = less memory, higher = faster) |
+| `EMBEDDING_BATCH_SIZE` | No | `8` | Texts per embedding batch (lower = less memory, higher = faster) |
 | `EMBEDDING_SIDECAR_PORT` | No | `8787` | Port for local embedding server |
 | `EMBEDDING_DEVICE` | No | auto (`mps`/`cpu`) | Device for embeddings. Auto-detects MPS on Apple Silicon |
 | `EMBEDDING_HALF_PRECISION` | No | `false` | Set `true` for float16 (uses ~0.5x memory) |

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

@@ -175,22 +175,28 @@ export class EmbeddingSidecar {
             }
             return false;
         }
-        catch {
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[embedding-sidecar] Health check failed: ${msg}`);
             return false;
         }
     }
     /**
      * 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) {
@@ -202,21 +208,24 @@ export class EmbeddingSidecar {
                     console.error('[embedding-sidecar] OOM detected, restarting sidecar to reclaim GPU memory');
                     await this.stop();
                 }
+                console.error(`[embedding-sidecar] Embed failed after ${Date.now() - startTime}ms: status=${res.status}, texts=${texts.length}, oom=${isOOM}, detail=${detail}`);
                 throw new Error(`Sidecar embed failed (${res.status}): ${detail}`);
             }
             const data = (await res.json());
             if (data.dimensions)
                 this._dimensions = data.dimensions;
+            console.error(`[embedding-sidecar] Embedded ${texts.length} texts in ${Date.now() - startTime}ms (dims=${data.dimensions})`);
             this.resetIdleTimer();
             return data.embeddings;
         }
         catch (err) {
             if (err instanceof Error && err.name === 'AbortError') {
-                // Timeout likely means the sidecar is stuck — kill it
-                console.error('[embedding-sidecar] Request timed out, restarting sidecar');
+                console.error(`[embedding-sidecar] Request timed out after ${Date.now() - startTime}ms (limit=${this.config.requestTimeoutMs}ms, texts=${texts.length}), restarting sidecar`);
                 await this.stop();
                 throw new Error(`Embedding request timed out after ${this.config.requestTimeoutMs}ms`);
             }
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[embedding-sidecar] Embed error after ${Date.now() - startTime}ms: ${msg} (url=${this.baseUrl}, running=${this.isRunning}, texts=${texts.length})`);
             throw err;
         }
         finally {

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

@@ -6,7 +6,7 @@
 import { debugLog } from '../../mcp/utils.js';
 import { getEmbeddingSidecar } from './embedding-sidecar.js';
 const BATCH_CONFIG = {
-    maxBatchSize: parseInt(process.env.EMBEDDING_BATCH_SIZE ?? '', 10) || 16,
+    maxBatchSize: parseInt(process.env.EMBEDDING_BATCH_SIZE ?? '', 10) || 8,
 };
 export class LocalEmbeddingsService {
     async embedText(text) {
@@ -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: ${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.
@@ -132,8 +160,9 @@ export class GraphGeneratorHandler {
         // Batch embed all texts that need it
         if (nodesNeedingEmbedding.length > 0) {
             const texts = nodesNeedingEmbedding.map((n) => n.text);
-            const totalBatches = Math.ceil(texts.length / EMBEDDING_BATCH_CONFIG.maxBatchSize);
-            console.error(`[embedding] Starting ${texts.length} texts in ${totalBatches} batches (batch_size=${EMBEDDING_BATCH_CONFIG.maxBatchSize})`);
+            const effectiveBatchSize = parseInt(process.env.EMBEDDING_BATCH_SIZE ?? '', 10) || EMBEDDING_BATCH_CONFIG.maxBatchSize;
+            const totalBatches = Math.ceil(texts.length / effectiveBatchSize);
+            console.error(`[embedding] Starting ${texts.length} texts in ~${totalBatches} batches (effective_batch_size=${effectiveBatchSize}, config_max=${EMBEDDING_BATCH_CONFIG.maxBatchSize})`);
             try {
                 const embeddings = await this.embeddingsService.embedTextsInBatches(texts, EMBEDDING_BATCH_CONFIG.maxBatchSize);
                 // Map embeddings back to their nodes

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.7",
+  "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",