code-graph-context 2.10.3 → 2.10.5

package/README.md

@@ -191,6 +191,7 @@ If you prefer to edit the config files directly:
 | `NEO4J_PASSWORD` | No | `PASSWORD` | Neo4j password |
 | `EMBEDDING_MODEL` | No | `Qodo/Qodo-Embed-1-1.5B` | Local embedding model (see [Embedding Configuration](#embedding-configuration)) |
 | `EMBEDDING_SIDECAR_PORT` | No | `8787` | Port for local embedding server |
+| `EMBEDDING_FULL_PRECISION` | No | `false` | Set `true` for float32 (uses ~2x memory) |
 | `OPENAI_ENABLED` | No | `false` | Set `true` to use OpenAI instead of local |
 | `OPENAI_API_KEY` | No* | - | Required when `OPENAI_ENABLED=true` |
 
@@ -535,20 +536,24 @@ This enables queries like "find all hooks that use context" while maintaining AS
 
 Local embeddings are the default — **no API key needed**. The Python sidecar starts automatically on first use and runs a local model for high-quality code embeddings.
 
+The sidecar uses **float16 (half precision)** by default, which halves memory usage with no meaningful quality loss. It also auto-shuts down after 3 minutes of inactivity to free memory, and restarts lazily when needed (~15-20s).
+
+> **Full precision mode:** If you have 32+ GB RAM and want float32, set `EMBEDDING_FULL_PRECISION=true`.
+
 ### Available Models
 
 Set via the `EMBEDDING_MODEL` environment variable:
 
-| Model | Dimensions | RAM | Quality | Best For |
+| Model | Dimensions | RAM (fp16) | Quality | Best For |
 |-------|-----------|-----|---------|----------|
-| `Qodo/Qodo-Embed-1-1.5B` (default) | 1536 | ~9 GB | Best | Machines with 32+ GB RAM |
-| `BAAI/bge-base-en-v1.5` | 768 | ~500 MB | Good | General purpose, low RAM |
-| `sentence-transformers/all-MiniLM-L6-v2` | 384 | ~200 MB | OK | Minimal RAM, fast |
-| `nomic-ai/nomic-embed-text-v1.5` | 768 | ~600 MB | Good | Code + prose mixed |
-| `sentence-transformers/all-mpnet-base-v2` | 768 | ~500 MB | Good | Balanced quality/speed |
-| `BAAI/bge-small-en-v1.5` | 384 | ~130 MB | OK | Smallest footprint |
-
-**Example:** Use a lightweight model on a 16GB machine:
+| `Qodo/Qodo-Embed-1-1.5B` (default) | 1536 | ~4.5 GB | Best | Default, works on 16GB machines |
+| `BAAI/bge-base-en-v1.5` | 768 | ~250 MB | Good | General purpose, low RAM |
+| `sentence-transformers/all-MiniLM-L6-v2` | 384 | ~100 MB | OK | Minimal RAM, fast |
+| `nomic-ai/nomic-embed-text-v1.5` | 768 | ~300 MB | Good | Code + prose mixed |
+| `sentence-transformers/all-mpnet-base-v2` | 768 | ~250 MB | Good | Balanced quality/speed |
+| `BAAI/bge-small-en-v1.5` | 384 | ~65 MB | OK | Smallest footprint |
+
+**Example:** Use a lightweight model on a low-memory machine:
 ```bash
 claude mcp add --scope user code-graph-context \
   -e EMBEDDING_MODEL=BAAI/bge-base-en-v1.5 \

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

@@ -15,6 +15,7 @@ const DEFAULT_CONFIG = {
     model: process.env.EMBEDDING_MODEL ?? 'Qodo/Qodo-Embed-1-1.5B',
     startupTimeoutMs: 120_000, // 2 min — first run downloads the model
     requestTimeoutMs: 60_000,
+    idleTimeoutMs: 180_000, // 3 min — auto-shutdown after no requests
 };
 export class EmbeddingSidecar {
     process = null;
@@ -23,6 +24,7 @@ export class EmbeddingSidecar {
     _dimensions = null;
     stopping = false;
     _exitHandler = null;
+    _idleTimer = null;
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
@@ -205,6 +207,7 @@ export class EmbeddingSidecar {
             const data = (await res.json());
             if (data.dimensions)
                 this._dimensions = data.dimensions;
+            this.resetIdleTimer();
             return data.embeddings;
         }
         catch (err) {
@@ -251,7 +254,21 @@ export class EmbeddingSidecar {
         }
         this.cleanup();
     }
+    resetIdleTimer() {
+        if (this._idleTimer)
+            clearTimeout(this._idleTimer);
+        this._idleTimer = setTimeout(() => {
+            console.error(`[embedding-sidecar] Idle for ${this.config.idleTimeoutMs / 1000}s, shutting down to free memory`);
+            this.stop();
+        }, this.config.idleTimeoutMs);
+        // Don't let the timer prevent Node from exiting
+        this._idleTimer.unref();
+    }
     cleanup() {
+        if (this._idleTimer) {
+            clearTimeout(this._idleTimer);
+            this._idleTimer = null;
+        }
         if (this._exitHandler) {
             process.removeListener('exit', this._exitHandler);
             this._exitHandler = null;

package/dist/mcp/tools/parse-typescript-project.tool.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from 'url';
 import { Worker } from 'worker_threads';
 import { z } from 'zod';
 import { CORE_TYPESCRIPT_SCHEMA } from '../../core/config/schema.js';
+import { stopEmbeddingSidecar } from '../../core/embeddings/embedding-sidecar.js';
 import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
 import { ParserFactory } from '../../core/parsers/parser-factory.js';
 import { detectChangedFiles } from '../../core/utils/file-change-detection.js';
@@ -165,6 +166,7 @@ export const createParseTypescriptProjectTool = (server) => {
                     const job = jobManager.getJob(jobId);
                     if (job && job.status === 'running') {
                         jobManager.failJob(jobId, `Worker timed out after ${PARSING.workerTimeoutMs / 60000} minutes`);
+                        await stopEmbeddingSidecar();
                         await terminateWorker('timeout');
                     }
                 }, PARSING.workerTimeoutMs);
@@ -183,6 +185,7 @@ export const createParseTypescriptProjectTool = (server) => {
                         clearTimeout(timeoutId);
                         jobManager.failJob(jobId, msg.error);
                         debugLog('Async parsing failed', { jobId, error: msg.error });
+                        stopEmbeddingSidecar();
                         terminateWorker('error');
                     }
                 });
@@ -191,6 +194,7 @@ export const createParseTypescriptProjectTool = (server) => {
                     clearTimeout(timeoutId);
                     jobManager.failJob(jobId, err.message ?? String(err));
                     console.error('Worker thread error:', err);
+                    stopEmbeddingSidecar();
                     terminateWorker('worker-error');
                 });
                 // Handle worker exit
@@ -371,12 +375,16 @@ export const createParseTypescriptProjectTool = (server) => {
                     edgeCount: 0,
                 });
                 await debugLog('Project status updated to failed', { projectId: finalProjectId });
+                // Stop sidecar to free memory (restarts lazily on next embed request)
+                await stopEmbeddingSidecar();
                 return createSuccessResponse(formatParsePartialSuccess(nodes.length, edges.length, outputPath, neo4jError.message));
             }
         }
         catch (error) {
             console.error('Parse tool error:', error);
             await debugLog('Parse tool error', { projectPath, tsconfigPath, error });
+            // Stop sidecar to free memory (restarts lazily on next embed request)
+            await stopEmbeddingSidecar();
             return createErrorResponse(error);
         }
     });

package/package.json

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

package/sidecar/embedding_server.py

@@ -9,6 +9,8 @@ import os
 import sys
 import signal
 import logging
+import threading
+import time
 
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
@@ -20,6 +22,8 @@ logging.basicConfig(
 )
 logger = logging.getLogger("embedding-sidecar")
 
+logger.info(f"Sidecar process starting (pid={os.getpid()})")
+
 app = FastAPI(title="code-graph-context embedding sidecar")
 
 model = None
@@ -46,15 +50,25 @@ def load_model():
 
         device = "mps" if torch.backends.mps.is_available() else "cpu"
         logger.info(f"Loading {model_name} on {device}...")
+        logger.info(f"PyTorch version: {torch.__version__}, MPS available: {torch.backends.mps.is_available()}")
+
+        use_half = os.environ.get("EMBEDDING_FULL_PRECISION", "").lower() != "true"
         model = SentenceTransformer(model_name, device=device)
+        if use_half:
+            model.half()
+            logger.info(f"Model loaded in float16 (half precision)")
+        else:
+            logger.info(f"Model loaded in float32 (full precision)")
+        logger.info(f"Running warmup...")
 
         # Warm up with a test embedding
         with torch.no_grad():
             test = model.encode(["warmup"], show_progress_bar=False)
         dims = len(test[0])
-        logger.info(f"Model loaded: {dims} dimensions, device={device}")
+        logger.info(f"Warmup complete: {dims} dimensions, device={device}")
+        logger.info(f"Sidecar ready (pid={os.getpid()})")
     except Exception as e:
-        logger.error(f"Failed to load model: {e}")
+        logger.error(f"Failed to load model: {e}", exc_info=True)
         raise
 
 
@@ -79,16 +93,21 @@ async def embed(req: EmbedRequest):
     if not req.texts:
         return EmbedResponse(embeddings=[], dimensions=0, model=model_name)
 
+    logger.info(f"Embed request: {len(req.texts)} texts, batch_size={req.batch_size}")
+    start = time.time()
+
     try:
         embeddings = _encode_with_oom_fallback(req.texts, req.batch_size)
         dims = len(embeddings[0])
+        elapsed = time.time() - start
+        logger.info(f"Embed complete: {len(embeddings)} embeddings in {elapsed:.2f}s")
         return EmbedResponse(
             embeddings=embeddings,
             dimensions=dims,
             model=model_name,
         )
     except Exception as e:
-        logger.error(f"Embedding error: {e}")
+        logger.error(f"Embedding error: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e))
 
 
@@ -125,6 +144,7 @@ def _encode_with_oom_fallback(texts: list[str], batch_size: int) -> list[list[fl
         # Fall back to CPU for this request
         original_device = model.device
         model.to("cpu")
+        logger.info("Model moved to CPU for fallback encoding")
 
         try:
             # Use smaller batches on CPU
@@ -136,17 +156,19 @@ def _encode_with_oom_fallback(texts: list[str], batch_size: int) -> list[list[fl
                     show_progress_bar=False,
                     normalize_embeddings=True,
                 )
+            logger.info(f"CPU fallback encoding complete ({len(texts)} texts)")
             return result.tolist()
         finally:
             # Move back to MPS for future requests
             try:
                 model.to(original_device)
+                logger.info(f"Model moved back to {original_device}")
             except Exception:
                 logger.warning("Could not move model back to MPS, staying on CPU")
 
 
 def handle_signal(sig, _frame):
-    logger.info(f"Received signal {sig}, shutting down")
+    logger.info(f"Received signal {sig}, shutting down (pid={os.getpid()})")
     sys.exit(0)
 
 
@@ -159,14 +181,18 @@ def _watch_stdin():
     the pipe breaks and stdin closes. This is our most reliable way to detect
     parent death and self-terminate instead of becoming an orphan.
     """
-    import threading
 
     def _watcher():
+        logger.info("Stdin watcher thread started")
         try:
             # Blocks until stdin is closed (parent died)
-            sys.stdin.read()
-        except Exception:
-            pass
+            while True:
+                data = sys.stdin.read(1)
+                if not data:
+                    # EOF — parent closed the pipe
+                    break
+        except Exception as e:
+            logger.info(f"Stdin watcher exception: {e}")
         logger.info("Parent process died (stdin closed), shutting down")
         os._exit(0)
 
@@ -174,4 +200,8 @@ def _watch_stdin():
     t.start()
 
 
-_watch_stdin()
+# Only watch stdin if it's a pipe (not a TTY) — avoids issues when run manually
+if not sys.stdin.isatty():
+    _watch_stdin()
+else:
+    logger.info("Running in terminal mode, stdin watcher disabled")