@esankhan3/code-search-mcp 0.4.11 → 1.0.0

package/README.md

@@ -245,10 +245,11 @@ Every index call lands in a 50-entry FIFO history with start
 timestamp, success / error, last duration. Available at
 `GET /status`.
 
-### Streamable HTTP sessions
-Per-session `StreamableHTTPServerTransport`, max 100 concurrent
-sessions, 30 min TTL. The remote proxy captures `mcp-session-id`
-for continuity. SSE transport available as a fallback.
+### Stateless Streamable HTTP
+Every `/mcp` request is served statelessly by a fresh Server
+instance: modern (2026-07-28) clients negotiate via
+`server/discover`; 2025-era clients are answered by the SDK's
+per-request legacy fallback. No session map, no TTL.
 
 ### Admin index endpoint
 `POST /index` with `{ project, dirPath?, opts? }` triggers a
@@ -374,9 +375,9 @@ the same router, retries, and cost ledger as the rest of Anvil.
 **Three modes, one binary.** Remote proxy for hosted, local for
 solo, serve for teams. The dispatcher is `src/index.ts:argv`.
 
-**Stateless sessions.** HTTP sessions are in-memory by design.
-Restart drops them; clients re-init on first request. No persistent
-session store to maintain.
+**Stateless serving.** Every `/mcp` request is an independent
+exchange — no session state at all, so restarts and per-request
+proxies (cluster workers) are free.
 
 **Security defaults that don't bite.** Default bind is `127.0.0.1`
 when auth is `none`. API keys compared timing-safe. JWT

package/dist/__tests__/http-stateless.test.js

@@ -0,0 +1,57 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { Server } from "@modelcontextprotocol/server";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { startHttpTransport } from "../transports/http-transport.js";
+function makeMcpServer() {
+  const server = new Server(
+    { name: "stateless-test", version: "0.0.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler("tools/list", async () => ({
+    tools: [{ name: "ping", description: "test tool", inputSchema: { type: "object" } }]
+  }));
+  return server;
+}
+const config = {
+  port: 0,
+  host: "127.0.0.1",
+  transport: "streamable-http",
+  authEnabled: false,
+  authMode: "none",
+  authApiKeys: []
+};
+describe("http transport \u2014 stateless mode (cluster workers)", () => {
+  it("serves initialize + tools/list as independent sessionless requests", async () => {
+    const httpServer = await startHttpTransport({
+      config,
+      createMcpServer: async () => ({ server: makeMcpServer() })
+    });
+    const base = `http://127.0.0.1:${httpServer.address().port}`;
+    try {
+      const client = new Client({ name: "test-client", version: "1.0.0" });
+      const transport = new StreamableHTTPClientTransport(new URL(`${base}/mcp`));
+      await client.connect(transport);
+      const tools = await client.listTools();
+      assert.equal(tools.tools[0]?.name, "ping");
+      assert.equal(transport.sessionId, void 0, "stateless server must not assign a session");
+      assert.equal(client.getProtocolEra(), "legacy");
+      await client.close();
+      const modern = new Client(
+        { name: "modern-client", version: "1.0.0" },
+        { versionNegotiation: { mode: "auto" } }
+      );
+      await modern.connect(new StreamableHTTPClientTransport(new URL(`${base}/mcp`)));
+      assert.equal(modern.getProtocolEra(), "modern");
+      assert.equal(modern.getNegotiatedProtocolVersion(), "2026-07-28");
+      assert.equal((await modern.listTools()).tools[0]?.name, "ping");
+      await modern.close();
+      const get = await fetch(`${base}/mcp`, { method: "GET" });
+      assert.equal(get.status, 405);
+      const del = await fetch(`${base}/mcp`, { method: "DELETE" });
+      assert.equal(del.status, 405);
+    } finally {
+      httpServer.close();
+    }
+  });
+});

package/dist/cli/index.js

@@ -180,6 +180,9 @@ async function cmdStatus(rest) {
   const indexer = new KnowledgeIndexer();
   const stats = await indexer.getStats(project);
   const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
+  const profilesAvailable = await Promise.all(
+    stats.repos.map(async (r) => ({ name: r.name, hasProfile: !!await loadProfile(project, r.name) }))
+  );
   process.stdout.write(JSON.stringify({
     project,
     dataDir: cfg.storage.dataDir,
@@ -189,10 +192,7 @@ async function cmdStatus(rest) {
     embeddingProvider: stats.embeddingProvider,
     lastIndexedAt: stats.lastIndexed || null,
     repos: stats.repos,
-    profilesAvailable: stats.repos.map((r) => ({
-      name: r.name,
-      hasProfile: !!loadProfile(project, r.name)
-    }))
+    profilesAvailable
   }, null, 2) + "\n");
 }
 async function cmdReset(rest) {

package/dist/core/config.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 function defaultDataDir() {
   return process.env.CODE_SEARCH_DATA_DIR ?? join(homedir(), ".code-search", "index");
 }
@@ -168,6 +168,43 @@ function parseReindexMs(raw) {
   }
   return m[2] === "h" ? parseInt(m[1], 10) * 60 * 6e4 : parseInt(m[1], 10) * 6e4;
 }
+function envStorageBackends(env) {
+  const blobBackend = env("STORAGE_BLOB_BACKEND");
+  const mongoUri = env("STORAGE_MONGO_URI");
+  const mongoDb = env("STORAGE_MONGO_DB");
+  const vectorUri = env("STORAGE_VECTOR_URI");
+  const s3Endpoint = env("STORAGE_S3_ENDPOINT");
+  const s3Region = env("STORAGE_S3_REGION");
+  const s3AllowHttp = env("STORAGE_S3_ALLOW_HTTP");
+  const cacheMaxBytes = env("STORAGE_CACHE_MAX_BYTES");
+  const cacheDir = env("STORAGE_CACHE_DIR");
+  if (!blobBackend && !mongoUri && !vectorUri && !cacheMaxBytes && !cacheDir) return void 0;
+  const out = {};
+  if (blobBackend || mongoUri) {
+    out.blob = {
+      ...blobBackend ? { backend: blobBackend } : {},
+      ...mongoUri && mongoDb ? { mongo: { uri: mongoUri, db: mongoDb } } : {}
+    };
+  }
+  if (vectorUri) {
+    const s3 = s3Endpoint || s3Region || s3AllowHttp ? {
+      ...s3Endpoint ? { endpoint: s3Endpoint } : {},
+      ...s3Region ? { region: s3Region } : {},
+      ...s3AllowHttp ? { allowHttp: s3AllowHttp === "true" || s3AllowHttp === "1" } : {},
+      virtualHostedStyle: false
+      // MinIO is path-style
+    } : void 0;
+    out.vector = { lancedb: { uri: vectorUri, ...s3 ? { s3 } : {} } };
+  }
+  const max = cacheMaxBytes ? parseInt(cacheMaxBytes, 10) : NaN;
+  if (cacheDir || Number.isFinite(max) && max > 0) {
+    out.cache = {
+      dir: cacheDir ?? join(tmpdir(), "code-search-cache"),
+      ...Number.isFinite(max) && max > 0 ? { maxBytes: max, mode: "ram" } : {}
+    };
+  }
+  return out;
+}
 function envLayer() {
   const env = (k) => process.env[`CODE_SEARCH_${k}`];
   const authMode = env("AUTH_MODE");
@@ -193,7 +230,8 @@ function envLayer() {
       rateLimitPerMinute: rateLimit ? parseInt(rateLimit, 10) : void 0
     },
     storage: {
-      dataDir: env("DATA_DIR")
+      dataDir: env("DATA_DIR"),
+      backends: envStorageBackends(env)
     },
     embedding: {
       provider: env("EMBEDDING_PROVIDER"),
@@ -331,7 +369,8 @@ function toKnowledgeConfig(c) {
       hybridWeights: { ...c.retrieval.hybridWeights },
       reranker: { ...c.reranker }
     },
-    autoIndex: c.indexing.autoIndex
+    autoIndex: c.indexing.autoIndex,
+    ...c.storage.backends ? { storage: c.storage.backends } : {}
   };
 }
 const SECRET_KEYS = /* @__PURE__ */ new Set([

package/dist/core/env-config.js

@@ -1,7 +1,8 @@
 import { execSync as _execSync } from "node:child_process";
 import {
   resolveCodeSearchConfig,
-  parseCliFlags
+  parseCliFlags,
+  toKnowledgeConfig
 } from "./config.js";
 import { normalizeRerankerConfig } from "@esankhan3/anvil-knowledge-core";
 let _config = null;
@@ -26,6 +27,9 @@ function resolveLlmMode(explicit, apiKey, claudeBin) {
   );
   return "none";
 }
+function resolvedKnowledgeConfig() {
+  return toKnowledgeConfig(loadServerConfig().__unified);
+}
 function loadServerConfig(opts) {
   if (_config) return _config;
   const cli = opts?.argv ? parseCliFlags(opts.argv).patch : void 0;
@@ -84,5 +88,6 @@ function resetServerConfig() {
 }
 export {
   loadServerConfig,
-  resetServerConfig
+  resetServerConfig,
+  resolvedKnowledgeConfig
 };

package/dist/resources/resources.js

@@ -1,7 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { getKnowledgeBasePath, openSystemGraphStore } from "@esankhan3/anvil-knowledge-core";
+import { getBlobStore, getGraphStore } from "@esankhan3/anvil-knowledge-core";
 import { loadAllProfiles } from "@esankhan3/anvil-knowledge-core";
+import { resolvedKnowledgeConfig } from "../core/env-config.js";
 import { loadProfile } from "@esankhan3/anvil-knowledge-core";
 function registerResources(ctx) {
   return [
@@ -21,9 +20,8 @@ function registerResources(ctx) {
 }
 async function handleResource(uri, ctx) {
   try {
-    const kbPath = getKnowledgeBasePath(ctx.projectName);
     if (uri === "code-search://repos") {
-      const profiles = loadAllProfiles(ctx.projectName);
+      const profiles = await loadAllProfiles(ctx.projectName, resolvedKnowledgeConfig());
       return {
         contents: [{
           uri,
@@ -33,30 +31,26 @@ async function handleResource(uri, ctx) {
       };
     }
     if (uri === "code-search://system-graph") {
-      const store = await openSystemGraphStore(kbPath);
+      const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
       if (!store) {
         return { contents: [{ uri, mimeType: "application/json", text: '{"nodes":[],"crossRepoEdges":[],"totals":{"nodes":0,"crossRepoEdges":0}}' }] };
       }
-      try {
-        const NODE_LIMIT = 200;
-        const EDGE_LIMIT = 200;
-        const { rows: nodes, total: nodeTotal } = store.searchNodes({ minDegree: 0 }, NODE_LIMIT);
-        const { edges: crossRepoEdges, total: edgeTotal } = store.crossRepoEdges(void 0, EDGE_LIMIT);
-        const payload = {
-          nodes,
-          crossRepoEdges,
-          totals: { nodes: nodeTotal, crossRepoEdges: edgeTotal },
-          truncated: nodeTotal > nodes.length || edgeTotal > crossRepoEdges.length,
-          note: "Bounded overview (top nodes by degree + cross-repo edges). Use the graph tools for full traversal."
-        };
-        return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(payload, null, 2) }] };
-      } finally {
-        store.close();
-      }
+      const NODE_LIMIT = 200;
+      const EDGE_LIMIT = 200;
+      const { rows: nodes, total: nodeTotal } = store.searchNodes({ minDegree: 0 }, NODE_LIMIT);
+      const { edges: crossRepoEdges, total: edgeTotal } = store.crossRepoEdges(void 0, EDGE_LIMIT);
+      const payload = {
+        nodes,
+        crossRepoEdges,
+        totals: { nodes: nodeTotal, crossRepoEdges: edgeTotal },
+        truncated: nodeTotal > nodes.length || edgeTotal > crossRepoEdges.length,
+        note: "Bounded overview (top nodes by degree + cross-repo edges). Use the graph tools for full traversal."
+      };
+      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(payload, null, 2) }] };
     }
     const profileMatch = uri.match(/^code-search:\/\/repo\/([^/]+)\/profile$/);
     if (profileMatch) {
-      const profile = loadProfile(ctx.projectName, profileMatch[1]);
+      const profile = await loadProfile(ctx.projectName, profileMatch[1], resolvedKnowledgeConfig());
       return {
         contents: [{
           uri,
@@ -67,12 +61,12 @@ async function handleResource(uri, ctx) {
     }
     const graphMatch = uri.match(/^code-search:\/\/repo\/([^/]+)\/graph$/);
     if (graphMatch) {
-      const graphPath = join(kbPath, graphMatch[1], "graph.json");
+      const graphJson = await getBlobStore(ctx.projectName, resolvedKnowledgeConfig()).getText(`${graphMatch[1]}/graph.json`);
       return {
         contents: [{
           uri,
           mimeType: "application/json",
-          text: existsSync(graphPath) ? readFileSync(graphPath, "utf-8") : '{"nodes":[],"links":[]}'
+          text: graphJson ?? '{"nodes":[],"links":[]}'
         }]
       };
     }

package/dist/server.js

@@ -1,26 +1,21 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { resolve } from "node:path";
+import cluster from "node:cluster";
 import { registerSearchTools, handleSearchTool } from "./tools/search.js";
 import { registerGraphTools, handleGraphTool } from "./tools/graph.js";
 import { registerProfileTools, handleProfileTool } from "./tools/profile.js";
 import { registerIndexTools, handleIndexTool } from "./tools/index-tools.js";
 import { registerResources, handleResource } from "./resources/resources.js";
-import { getKnowledgeBasePath } from "@esankhan3/anvil-knowledge-core";
+import { getBlobStore } from "@esankhan3/anvil-knowledge-core";
 import { indexFromPath, invalidateRetriever } from "@esankhan3/anvil-knowledge-core";
 import { loadServerConfig } from "./core/env-config.js";
 import { toKnowledgeConfig } from "./core/config.js";
 import { startHttpTransport } from "./transports/http-transport.js";
 function createMcpServerInstance(ctx) {
   const server = new Server(
-    { name: "code-search-mcp", version: "0.4.0" },
+    { name: "code-search-mcp", version: "1.0.0" },
     { capabilities: { tools: {}, resources: {} } }
   );
   const allTools = [
@@ -29,10 +24,10 @@ function createMcpServerInstance(ctx) {
     ...registerProfileTools(),
     ...registerIndexTools()
   ];
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  server.setRequestHandler("tools/list", async () => ({
     tools: allTools
   }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler("tools/call", async (request) => {
     const name = request.params.name;
     const args = request.params.arguments ?? {};
     const searchResult = await handleSearchTool(name, args, ctx);
@@ -46,10 +41,10 @@ function createMcpServerInstance(ctx) {
     return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
   });
   const allResources = registerResources(ctx);
-  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  server.setRequestHandler("resources/list", async () => ({
     resources: allResources
   }));
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  server.setRequestHandler("resources/read", async (request) => {
     return handleResource(request.params.uri, ctx);
   });
   return server;
@@ -75,17 +70,25 @@ async function startServer(projectName, directoryPath) {
   };
   const llmInfo = config.llmMode === "none" ? "disabled (profiling + service mesh skipped)" : config.llmMode === "api" ? `api \u2192 ${config.llmProvider}/${config.llmModel}${config.llmApiKey ? "" : " (WARNING: no API key!)"}` : `cli \u2192 ${config.claudeBin}`;
   console.error(`[code-search-mcp] LLM: ${llmInfo}`);
-  await autoIndex(ctx);
+  await autoIndex(ctx, { readOnly: cluster.isWorker });
   if (config.transport === "stdio") {
     const server = createMcpServerInstance(ctx);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error(`[code-search-mcp] Server running for "${projectName}" (stdio)`);
   } else {
+    const workerCount = parseWorkerCount();
+    if (workerCount > 1 && cluster.isPrimary) {
+      armScheduledReindex(ctx, () => broadcastInvalidate(ctx));
+      runClusterPrimary(ctx, workerCount);
+      return;
+    }
     if (config.authMode === "none" && config.host !== "127.0.0.1" && config.host !== "localhost") {
       console.error(`[code-search-mcp] WARNING: Auth is disabled but server binds to ${config.host}. Any machine on the network can access your code search API.`);
       console.error(`[code-search-mcp] Set CODE_SEARCH_AUTH_MODE=api-key or CODE_SEARCH_HOST=127.0.0.1 for security.`);
     }
+    const isReadOnlyWorker = cluster.isWorker;
+    if (isReadOnlyWorker) registerWorkerIpc(ctx);
     await startHttpTransport({
       config,
       createMcpServer: async () => ({
@@ -116,35 +119,12 @@ async function startServer(projectName, directoryPath) {
           elapsedMs: ctx.indexing.startedAt ? Date.now() - ctx.indexing.startedAt : null
         }
       }),
-      onIndex: async (body) => {
-        const { resolve } = await import("node:path");
-        const { existsSync: existsSync2 } = await import("node:fs");
-        const dirPath = resolve(body.path);
-        if (!existsSync2(dirPath)) {
-          throw new Error(`Path does not exist: ${dirPath}`);
-        }
-        if (ctx.indexing.status === "indexing") {
-          throw new Error(`Indexing already in progress (phase: ${ctx.indexing.phase}). Wait for it to complete or check GET /status.`);
-        }
-        const project = body.project || dirPath.split("/").filter(Boolean).pop() || "project";
-        const stats = await trackedIndex(ctx, project, dirPath, {
-          force: body.force,
-          label: "admin-index"
-        });
-        ctx.projectName = project;
-        ctx.directoryPath = dirPath;
-        return {
-          status: "ok",
-          project,
-          path: dirPath,
-          chunks: stats.totalChunks,
-          repos: stats.repos.length,
-          crossRepoEdges: stats.crossRepoEdges,
-          durationMs: stats.indexDurationMs
-        };
-      }
+      onIndex: (body) => isReadOnlyWorker ? forwardIndexToPrimary(body) : runAdminIndex(ctx, body)
     });
   }
+  if (!cluster.isWorker) armScheduledReindex(ctx);
+}
+function armScheduledReindex(ctx, onSuccess) {
   const reindexIntervalMs = parseReindexInterval();
   if (reindexIntervalMs > 0 && ctx.directoryPath) {
     console.error(`[code-search-mcp] Auto-reindex every ${Math.round(reindexIntervalMs / 6e4)}m`);
@@ -152,12 +132,128 @@ async function startServer(projectName, directoryPath) {
       if (!ctx.directoryPath || ctx.indexing.status === "indexing") return;
       try {
         await trackedIndex(ctx, ctx.projectName, ctx.directoryPath, { label: "auto-reindex" });
+        onSuccess?.();
       } catch (err) {
         console.error(`[auto-reindex] Failed:`, err);
       }
     }, reindexIntervalMs).unref();
   }
 }
+async function runAdminIndex(ctx, body) {
+  const dirPath = resolve(body.path);
+  if (!existsSync(dirPath)) {
+    throw new Error(`Path does not exist: ${dirPath}`);
+  }
+  if (ctx.indexing.status === "indexing") {
+    throw new Error(`Indexing already in progress (phase: ${ctx.indexing.phase}). Wait for it to complete or check GET /status.`);
+  }
+  const project = body.project || dirPath.split("/").filter(Boolean).pop() || "project";
+  const stats = await trackedIndex(ctx, project, dirPath, {
+    force: body.force,
+    label: "admin-index"
+  });
+  ctx.projectName = project;
+  ctx.directoryPath = dirPath;
+  return {
+    status: "ok",
+    project,
+    path: dirPath,
+    chunks: stats.totalChunks,
+    repos: stats.repos.length,
+    crossRepoEdges: stats.crossRepoEdges,
+    durationMs: stats.indexDurationMs
+  };
+}
+function broadcastInvalidate(ctx) {
+  const msg = { type: "csm:invalidate", project: ctx.projectName, directoryPath: ctx.directoryPath };
+  for (const w of Object.values(cluster.workers ?? {})) {
+    try {
+      w?.send(msg);
+    } catch {
+    }
+  }
+}
+function parseWorkerCount() {
+  const n = parseInt(process.env.CODE_SEARCH_WORKERS ?? "", 10);
+  return Number.isFinite(n) && n > 1 ? Math.min(n, 16) : 1;
+}
+function runClusterPrimary(ctx, workerCount) {
+  console.error(`[code-search-mcp] Cluster primary ${process.pid}: forking ${workerCount} read-only workers (stateless MCP)`);
+  let shuttingDown = false;
+  const send = (w, msg) => {
+    try {
+      w?.send(msg);
+    } catch {
+    }
+  };
+  cluster.on("message", (worker, msg) => {
+    if (msg?.type !== "csm:index") return;
+    void (async () => {
+      try {
+        const result = await runAdminIndex(ctx, msg.body);
+        broadcastInvalidate(ctx);
+        send(worker, { type: "csm:index-result", id: msg.id, ok: true, result });
+      } catch (err) {
+        send(worker, {
+          type: "csm:index-result",
+          id: msg.id,
+          ok: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    })();
+  });
+  cluster.on("exit", (worker, code, signal) => {
+    if (shuttingDown) return;
+    console.error(`[code-search-mcp] Worker ${worker.process.pid} exited (${signal ?? code}) \u2014 respawning`);
+    cluster.fork();
+  });
+  const shutdown = (sig) => {
+    shuttingDown = true;
+    for (const w of Object.values(cluster.workers ?? {})) {
+      try {
+        w?.kill(sig);
+      } catch {
+      }
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  for (let i = 0; i < workerCount; i++) cluster.fork();
+}
+let ipcSeq = 0;
+const pendingIndexRequests = /* @__PURE__ */ new Map();
+function forwardIndexToPrimary(body) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    if (!process.send) {
+      rejectPromise(new Error("IPC channel unavailable \u2014 not a cluster worker"));
+      return;
+    }
+    const id = ++ipcSeq;
+    pendingIndexRequests.set(id, { resolve: resolvePromise, reject: rejectPromise });
+    const msg = { type: "csm:index", id, body };
+    process.send(msg);
+  });
+}
+function registerWorkerIpc(ctx) {
+  process.on("message", (msg) => {
+    if (msg?.type === "csm:index-result") {
+      const pending = pendingIndexRequests.get(msg.id);
+      if (!pending) return;
+      pendingIndexRequests.delete(msg.id);
+      if (msg.ok) pending.resolve(msg.result ?? {});
+      else pending.reject(new Error(msg.error ?? "Index failed"));
+    } else if (msg?.type === "csm:invalidate") {
+      void invalidateRetriever(msg.project).catch(() => {
+      });
+      ctx.projectName = msg.project;
+      if (msg.directoryPath) ctx.directoryPath = msg.directoryPath;
+      ctx.indexReady = true;
+    }
+  });
+  process.on("disconnect", () => process.exit(0));
+}
 function parseReindexInterval() {
   const raw = process.env.CODE_SEARCH_REINDEX_INTERVAL?.trim();
   if (!raw || raw === "0" || raw === "none") return 0;
@@ -224,16 +320,22 @@ async function trackedIndex(ctx, project, dirPath, opts) {
     throw err;
   }
 }
-async function autoIndex(ctx) {
+async function autoIndex(ctx, opts) {
   try {
-    const kbPath = getKnowledgeBasePath(ctx.projectName);
-    const hasLanceDB = existsSync(join(kbPath, "lancedb"));
-    const hasGraph = existsSync(join(kbPath, "system_graph.sqlite")) || existsSync(join(kbPath, "system_graph_v2.json"));
-    if (hasLanceDB && hasGraph) {
+    const blobs = getBlobStore(ctx.projectName, toKnowledgeConfig(loadServerConfig().__unified));
+    const stats = await blobs.getJson("index_stats.json");
+    const statsReady = !!stats && stats.embeddingProvider !== "pending";
+    const hasLanceDB = await blobs.exists("lancedb");
+    const hasGraph = await blobs.exists("system_graph.sqlite") || await blobs.exists("system_graph_v2.json");
+    if (statsReady || hasLanceDB && hasGraph) {
       ctx.indexReady = true;
       console.error(`[code-search-mcp] Index loaded for "${ctx.projectName}"`);
       return;
     }
+    if (opts?.readOnly) {
+      console.error(`[code-search-mcp] No index yet \u2014 read-only worker waiting for the writer`);
+      return;
+    }
     if (!ctx.directoryPath) {
       console.error(`[code-search-mcp] No index found and no directory path \u2014 tools will return empty results`);
       return;

package/dist/tools/graph.js

@@ -1,13 +1,14 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import {
-  getKnowledgeBasePath,
+  getBlobStore,
+  getGraphStore,
   loadAllProfiles,
   loadProfile,
   getAllChanges,
-  getChangedFilesList,
-  openSystemGraphStore
+  getChangedFilesList
 } from "@esankhan3/anvil-knowledge-core";
+import { resolvedKnowledgeConfig } from "../core/env-config.js";
 const GRAPH_TOOL_NAMES = [
   "get_repo_graph",
   "get_cross_repo_edges",
@@ -199,12 +200,11 @@ async function handleGraphTool(name, args, ctx) {
   const text = (t) => ({ content: [{ type: "text", text: t }] });
   const NO_GRAPH = "No system graph found. Build KB first.";
   try {
-    const kbPath = getKnowledgeBasePath(ctx.projectName);
+    const blobs = getBlobStore(ctx.projectName, resolvedKnowledgeConfig());
     if (name === "get_repo_graph") {
       const repo = args.repo;
-      const graphPath = join(kbPath, repo, "graph.json");
-      if (!existsSync(graphPath)) return text(`No graph found for repo "${repo}"`);
-      const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
+      const graph = await blobs.getJson(`${repo}/graph.json`);
+      if (!graph) return text(`No graph found for repo "${repo}"`);
       const summary = `# ${repo} AST Graph
 
 - **Nodes:** ${graph.nodes?.length ?? 0}
@@ -217,130 +217,113 @@ ${graph.nodes?.length > 50 ? `... and ${graph.nodes.length - 50} more` : ""}`;
       return text(summary);
     }
     if (name === "get_cross_repo_edges") {
-      const store = await openSystemGraphStore(kbPath);
+      const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
       if (!store) return text(NO_GRAPH);
-      try {
-        const repo = args.repo;
-        const { edges, total } = store.crossRepoEdges(repo, 50);
-        if (total === 0) return text(repo ? `No cross-repo edges found for "${repo}"` : "No cross-repo edges found");
-        const body = edges.map((e) => `- ${repoOf(e.source)} \u2192 ${repoOf(e.target)} (${e.type ?? "edge"})`).join("\n");
-        return text(`# Cross-Repo Edges${repo ? ` for ${repo}` : ""}
+      const repo = args.repo;
+      const { edges, total } = store.crossRepoEdges(repo, 50);
+      if (total === 0) return text(repo ? `No cross-repo edges found for "${repo}"` : "No cross-repo edges found");
+      const body = edges.map((e) => `- ${repoOf(e.source)} \u2192 ${repoOf(e.target)} (${e.type ?? "edge"})`).join("\n");
+      return text(`# Cross-Repo Edges${repo ? ` for ${repo}` : ""}
 
 ${total} edges found:
 
 ${body}${total > edges.length ? `
 
 ... and ${total - edges.length} more` : ""}`);
-      } finally {
-        store.close();
-      }
     }
     if (name === "find_callers" || name === "find_dependencies") {
-      const store = await openSystemGraphStore(kbPath);
+      const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
       if (!store) return text("No system graph found.");
-      try {
-        const funcName = args.function;
-        const repoFilter = args.repo;
-        const fuzzy = args.fuzzy === true;
-        const matched = store.resolveNodes(funcName, repoFilter, fuzzy);
-        if (matched.length === 0) {
-          return text(`No entity found matching "${funcName}"${repoFilter ? ` in ${repoFilter}` : ""}. Try fuzzy:true for substring matching.`);
-        }
-        const keys = matched.map((m) => m.key);
-        const unique = name === "find_callers" ? store.callers(keys, 30) : store.dependencies(keys, 30);
-        const direction = name === "find_callers" ? "Callers of" : "Dependencies of";
-        if (unique.length === 0) {
-          return text(`# ${direction} "${funcName}"
+      const funcName = args.function;
+      const repoFilter = args.repo;
+      const fuzzy = args.fuzzy === true;
+      const matched = store.resolveNodes(funcName, repoFilter, fuzzy);
+      if (matched.length === 0) {
+        return text(`No entity found matching "${funcName}"${repoFilter ? ` in ${repoFilter}` : ""}. Try fuzzy:true for substring matching.`);
+      }
+      const keys = matched.map((m) => m.key);
+      const unique = name === "find_callers" ? store.callers(keys, 30) : store.dependencies(keys, 30);
+      const direction = name === "find_callers" ? "Callers of" : "Dependencies of";
+      if (unique.length === 0) {
+        return text(`# ${direction} "${funcName}"
 
 Matched ${matched.length} entit${matched.length === 1 ? "y" : "ies"}, but no ${name === "find_callers" ? "callers" : "dependencies"} found.`);
-        }
-        return text(`# ${direction} "${funcName}"
+      }
+      return text(`# ${direction} "${funcName}"
 
 ${unique.length} found:
 ${unique.map((r) => `- \`${r}\``).join("\n")}`);
-      } finally {
-        store.close();
-      }
     }
     if (name === "impact_analysis") {
-      const store = await openSystemGraphStore(kbPath);
+      const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
       if (!store) return text("No system graph found.");
-      try {
-        const file = args.file;
-        const repo = args.repo;
-        const entity = args.entity;
-        const fileKeys = store.nodesInFiles(repo, [file], entity);
-        const { edges: dependents, total, repos } = store.dependents(fileKeys, 30);
-        const body = [
-          `# Impact Analysis: ${repo}/${file}${entity ? `::${entity}` : ""}`,
-          "",
-          `## Entities in scope: ${fileKeys.length}`,
-          ...fileKeys.slice(0, 20).map((k) => `- \`${k}\``),
-          "",
-          `## Dependents: ${total} edges from ${repos.length} repos`,
-          ...dependents.map((e) => `- \`${e.source}\` \u2192 \`${e.target}\` (${e.type ?? "edge"})`),
-          total > dependents.length ? `
+      const file = args.file;
+      const repo = args.repo;
+      const entity = args.entity;
+      const fileKeys = store.nodesInFiles(repo, [file], entity);
+      const { edges: dependents, total, repos } = store.dependents(fileKeys, 30);
+      const body = [
+        `# Impact Analysis: ${repo}/${file}${entity ? `::${entity}` : ""}`,
+        "",
+        `## Entities in scope: ${fileKeys.length}`,
+        ...fileKeys.slice(0, 20).map((k) => `- \`${k}\``),
+        "",
+        `## Dependents: ${total} edges from ${repos.length} repos`,
+        ...dependents.map((e) => `- \`${e.source}\` \u2192 \`${e.target}\` (${e.type ?? "edge"})`),
+        total > dependents.length ? `
 ... and ${total - dependents.length} more` : "",
-          "",
-          `## Affected repos: ${repos.join(", ") || "none"}`
-        ].join("\n");
-        return text(body);
-      } finally {
-        store.close();
-      }
+        "",
+        `## Affected repos: ${repos.join(", ") || "none"}`
+      ].join("\n");
+      return text(body);
     }
     if (name === "trace_path") {
-      const store = await openSystemGraphStore(kbPath);
+      const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
       if (!store) return text("No system graph found.");
-      try {
-        const from = args.from;
-        const to = args.to;
-        const repo = args.repo;
-        const fuzzy = args.fuzzy === true;
-        const direction = args.direction ?? "callees";
-        const maxDepth = Math.max(1, Math.min(10, args.maxDepth || 4));
-        const fromKeys = store.resolveNodes(from, repo, fuzzy).map((m) => m.key);
-        if (fromKeys.length === 0) return text(`No entity found matching "${from}". Try fuzzy:true.`);
-        const getNeighbors = makeNeighborGetter(store, direction);
-        if (to) {
-          const toKeys = new Set(store.resolveNodes(to, repo, fuzzy).map((m) => m.key));
-          if (toKeys.size === 0) return text(`No entity found matching target "${to}". Try fuzzy:true.`);
-          const path = shortestPath(getNeighbors, fromKeys, toKeys, maxDepth);
-          if (!path) return text(`No path from "${from}" to "${to}" within ${maxDepth} hops (direction: ${direction}).`);
-          const labelOf2 = store.labelsOf(path);
-          const arrow = direction === "callers" ? " \u2190 " : " \u2192 ";
-          const rendered = path.map((k) => labelOf2.get(k) ?? k).join(arrow);
-          return text(`# Path (${path.length - 1} hops)
+      const from = args.from;
+      const to = args.to;
+      const repo = args.repo;
+      const fuzzy = args.fuzzy === true;
+      const direction = args.direction ?? "callees";
+      const maxDepth = Math.max(1, Math.min(10, args.maxDepth || 4));
+      const fromKeys = store.resolveNodes(from, repo, fuzzy).map((m) => m.key);
+      if (fromKeys.length === 0) return text(`No entity found matching "${from}". Try fuzzy:true.`);
+      const getNeighbors = makeNeighborGetter(store, direction);
+      if (to) {
+        const toKeys = new Set(store.resolveNodes(to, repo, fuzzy).map((m) => m.key));
+        if (toKeys.size === 0) return text(`No entity found matching target "${to}". Try fuzzy:true.`);
+        const path = shortestPath(getNeighbors, fromKeys, toKeys, maxDepth);
+        if (!path) return text(`No path from "${from}" to "${to}" within ${maxDepth} hops (direction: ${direction}).`);
+        const labelOf2 = store.labelsOf(path);
+        const arrow = direction === "callers" ? " \u2190 " : " \u2192 ";
+        const rendered = path.map((k) => labelOf2.get(k) ?? k).join(arrow);
+        return text(`# Path (${path.length - 1} hops)
 
 ${rendered}
 
 ${path.map((k) => `- \`${k}\``).join("\n")}`);
-        }
-        const nodes = reachable(getNeighbors, fromKeys, maxDepth);
-        if (nodes.length === 0) return text(`No ${direction} reachable from "${from}" within ${maxDepth} hops.`);
-        const labelOf = store.labelsOf(nodes.map((n) => n.key));
-        const byDepth = /* @__PURE__ */ new Map();
-        for (const { key, depth } of nodes) {
-          if (!byDepth.has(depth)) byDepth.set(depth, []);
-          byDepth.get(depth).push(`\`${labelOf.get(key) ?? key}\` (${key})`);
-        }
-        const sections = [...byDepth.entries()].sort((a, b) => a[0] - b[0]).map(([d, ks]) => `## Depth ${d}
+      }
+      const nodes = reachable(getNeighbors, fromKeys, maxDepth);
+      if (nodes.length === 0) return text(`No ${direction} reachable from "${from}" within ${maxDepth} hops.`);
+      const labelOf = store.labelsOf(nodes.map((n) => n.key));
+      const byDepth = /* @__PURE__ */ new Map();
+      for (const { key, depth } of nodes) {
+        if (!byDepth.has(depth)) byDepth.set(depth, []);
+        byDepth.get(depth).push(`\`${labelOf.get(key) ?? key}\` (${key})`);
+      }
+      const sections = [...byDepth.entries()].sort((a, b) => a[0] - b[0]).map(([d, ks]) => `## Depth ${d}
 ${ks.map((k) => `- ${k}`).join("\n")}`).join("\n\n");
-        return text(`# Reachable from "${from}" (${direction}, \u2264${maxDepth} hops)
+      return text(`# Reachable from "${from}" (${direction}, \u2264${maxDepth} hops)
 
 ${nodes.length} nodes:
 
 ${sections}`);
-      } finally {
-        store.close();
-      }
     }
     if (name === "find_dead_code") {
       const repo = args.repo;
       const limit = args.limit || 50;
-      const graphPath = join(kbPath, repo, "graph.json");
-      if (!existsSync(graphPath)) return text(`No graph found for repo "${repo}"`);
-      const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
+      const graph = await blobs.getJson(`${repo}/graph.json`);
+      if (!graph) return text(`No graph found for repo "${repo}"`);
       const ENTITY_TYPES = /* @__PURE__ */ new Set(["function", "method", "class", "struct", "enum", "trait"]);
       const inDegree = /* @__PURE__ */ new Map();
       for (const l of graph.links ?? []) {
@@ -365,7 +348,7 @@ _Note: exported APIs, reflection, and dynamic dispatch can cause false positives
     if (name === "get_architecture") {
       const repo = args.repo;
       if (repo) {
-        const profile = loadProfile(ctx.projectName, repo);
+        const profile = await loadProfile(ctx.projectName, repo, resolvedKnowledgeConfig());
         if (!profile) return text(`No profile for "${repo}". Run profiling (requires LLM) to generate one.`);
         const ep = (xs) => xs?.length ? xs.map((e) => `  - ${e.type}: ${e.identifier} \u2014 ${e.description}`).join("\n") : "  - (none)";
         const body = [
@@ -384,8 +367,7 @@ _Note: exported APIs, reflection, and dynamic dispatch can cause false positives
         ].join("\n");
         return text(body);
       }
-      const pgPath = join(kbPath, "PROJECT_GRAPH.json");
-      const pg = existsSync(pgPath) ? JSON.parse(readFileSync(pgPath, "utf-8")) : null;
+      const pg = await blobs.getJson("PROJECT_GRAPH.json");
       if (pg) {
         const lines = ["# Project Architecture", "", pg.architectureSummary ?? ""];
         if (pg.repoRoles && Object.keys(pg.repoRoles).length) {
@@ -407,9 +389,9 @@ _Note: exported APIs, reflection, and dynamic dispatch can cause false positives
         }
         return text(lines.join("\n"));
       }
-      const summaryPath = join(kbPath, "PROJECT_SUMMARY.md");
-      if (existsSync(summaryPath)) return text(readFileSync(summaryPath, "utf-8"));
-      const profiles = loadAllProfiles(ctx.projectName);
+      const summaryText = await blobs.getText("PROJECT_SUMMARY.md");
+      if (summaryText !== null) return text(summaryText);
+      const profiles = await loadAllProfiles(ctx.projectName, resolvedKnowledgeConfig());
       if (profiles.length) {
         return text(`# Project Repos
 
@@ -420,26 +402,22 @@ _Run project-graph generation (requires LLM) for a full architecture view._`);
       return text("No architecture data yet. Index the project, then run profiling / project-graph generation (requires an LLM) for an architecture overview.");
     }
     if (name === "search_graph") {
-      const store = await openSystemGraphStore(kbPath);
+      const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
       if (!store) return text(NO_GRAPH);
-      try {
-        const { rows, total } = store.searchNodes({
-          name: args.name,
-          type: args.type,
-          file: args.file,
-          repo: args.repo,
-          minDegree: args.minDegree ?? 0
-        }, args.limit || 50);
-        if (total === 0) return text("No entities match the given filters.");
-        const body = rows.map((m) => `- \`${m.label}\` (${m.type}, ${m.file}) \u2014 degree ${m.degree}  \`${m.key}\``).join("\n");
-        return text(`# search_graph \u2014 ${total} match${total === 1 ? "" : "es"}
+      const { rows, total } = store.searchNodes({
+        name: args.name,
+        type: args.type,
+        file: args.file,
+        repo: args.repo,
+        minDegree: args.minDegree ?? 0
+      }, args.limit || 50);
+      if (total === 0) return text("No entities match the given filters.");
+      const body = rows.map((m) => `- \`${m.label}\` (${m.type}, ${m.file}) \u2014 degree ${m.degree}  \`${m.key}\``).join("\n");
+      return text(`# search_graph \u2014 ${total} match${total === 1 ? "" : "es"}
 
 ${body}${total > rows.length ? `
 
 ... and ${total - rows.length} more` : ""}`);
-      } finally {
-        store.close();
-      }
     }
     if (name === "detect_changes") {
       const repo = args.repo;
@@ -452,12 +430,10 @@ ${body}${total > rows.length ? `
       if (!existsSync(repoPath)) return text(`Repo path not found: ${repoPath}`);
       let baseSha = args.baseSha;
       if (!baseSha) {
-        const metaPath = join(kbPath, repo, "index_meta.json");
-        if (existsSync(metaPath)) {
-          try {
-            baseSha = JSON.parse(readFileSync(metaPath, "utf-8")).lastIndexedSha;
-          } catch {
-          }
+        try {
+          const meta = await blobs.getJson(`${repo}/index_meta.json`);
+          baseSha = meta?.lastIndexedSha;
+        } catch {
         }
       }
       if (!baseSha) return text("No base commit available. Pass baseSha, or index the repo first so a last-indexed SHA exists.");
@@ -465,21 +441,17 @@ ${body}${total > rows.length ? `
       if (diff.fallbackToFull) return text(`git diff against ${baseSha.slice(0, 7)} failed or is too large to map incrementally. Check the base SHA.`);
       const changedFiles = getChangedFilesList(diff);
       if (changedFiles.length === 0 && diff.deleted.length === 0) return text(`No source changes since ${baseSha.slice(0, 7)}.`);
-      const store = await openSystemGraphStore(kbPath);
+      const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
       let changedKeys = [];
       let dependents = [];
       let depTotal = 0;
       let depRepos = [];
       if (store) {
-        try {
-          changedKeys = store.nodesInFiles(repo, changedFiles);
-          const d = store.dependents(changedKeys, limit);
-          dependents = d.edges;
-          depTotal = d.total;
-          depRepos = d.repos;
-        } finally {
-          store.close();
-        }
+        changedKeys = store.nodesInFiles(repo, changedFiles);
+        const d = store.dependents(changedKeys, limit);
+        dependents = d.edges;
+        depTotal = d.total;
+        depRepos = d.repos;
       }
       const lines = [
         `# Changes since ${baseSha.slice(0, 7)} \u2014 ${repo}`,

package/dist/tools/index-tools.js

@@ -1,3 +1,4 @@
+import { resolvedKnowledgeConfig } from "../core/env-config.js";
 import { KnowledgeIndexer } from "@esankhan3/anvil-knowledge-core";
 const TOOL_NAMES = ["index_status"];
 function registerIndexTools() {
@@ -17,7 +18,7 @@ async function handleIndexTool(name, args, ctx) {
   try {
     if (name === "index_status") {
       const indexer = new KnowledgeIndexer();
-      const stats = await indexer.getStats(ctx.projectName);
+      const stats = await indexer.getStats(ctx.projectName, resolvedKnowledgeConfig());
       const lines = [
         `# Index Status: ${ctx.projectName}`,
         "",

package/dist/tools/profile.js

@@ -1,4 +1,5 @@
 import { loadAllProfiles, loadProfile } from "@esankhan3/anvil-knowledge-core";
+import { resolvedKnowledgeConfig } from "../core/env-config.js";
 import { discoverRepos } from "@esankhan3/anvil-knowledge-core";
 function registerProfileTools() {
   return [
@@ -27,7 +28,7 @@ async function handleProfileTool(name, args, ctx) {
   if (!["list_repos", "get_repo_profile"].includes(name)) return null;
   try {
     if (name === "list_repos") {
-      const profiles = loadAllProfiles(ctx.projectName);
+      const profiles = await loadAllProfiles(ctx.projectName, resolvedKnowledgeConfig());
       if (profiles.length === 0) {
         if (ctx.directoryPath) {
           const repos = discoverRepos(ctx.directoryPath);
@@ -47,7 +48,7 @@ ${text}` }] };
     }
     if (name === "get_repo_profile") {
       const repo = args.repo;
-      const profile = loadProfile(ctx.projectName, repo);
+      const profile = await loadProfile(ctx.projectName, repo, resolvedKnowledgeConfig());
       if (!profile) {
         return { content: [{ type: "text", text: `No profile found for "${repo}". Run reindex to generate profiles.` }] };
       }

package/dist/tools/search.js

@@ -1,6 +1,5 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { getRetriever, getKnowledgeBasePath, findChunksInFile } from "@esankhan3/anvil-knowledge-core";
+import { getRetriever, getBlobStore, findChunksInProject } from "@esankhan3/anvil-knowledge-core";
+import { resolvedKnowledgeConfig } from "../core/env-config.js";
 function registerSearchTools() {
   return [
     {
@@ -62,7 +61,7 @@ async function handleSearchTool(name, args, ctx) {
     return { content: [{ type: "text", text: "Index not ready. Run reindex tool or wait for auto-indexing to complete." }] };
   }
   try {
-    const retriever = await getRetriever(ctx.projectName);
+    const retriever = await getRetriever(ctx.projectName, resolvedKnowledgeConfig());
     const query = args.query;
     const maxResults = args.maxResults || 10;
     const repos = args.repos;
@@ -116,18 +115,30 @@ async function handleGetCodeSnippet(args, ctx) {
   if (!repo || !file) {
     return { content: [{ type: "text", text: 'Provide id="repo::file::entity" or repo + file (entity optional).' }] };
   }
-  const chunksPath = join(getKnowledgeBasePath(ctx.projectName), "chunks.json");
-  if (!existsSync(chunksPath)) {
-    return { content: [{ type: "text", text: "No index found \u2014 chunks.json missing. Index the project first." }] };
-  }
   try {
-    let matches = await findChunksInFile(
-      chunksPath,
-      (c) => c.repoName === repo && c.filePath === file && (!entity || c.entityName === entity),
-      5
-    );
-    if (matches.length === 0 && entity) {
-      matches = await findChunksInFile(chunksPath, (c) => c.repoName === repo && c.entityName === entity, 5);
+    const esc = (v) => v.replace(/'/g, "''");
+    let matches = [];
+    try {
+      const store = (await getRetriever(ctx.projectName, resolvedKnowledgeConfig())).vectorStore;
+      let scored = await store.getChunksByEntity([
+        { repoName: repo, filePath: file, ...entity ? { entityName: entity } : {} }
+      ]);
+      if (scored.length === 0 && entity) {
+        scored = await store.searchByEntityName([entity], 5, `repoName = '${esc(repo)}'`);
+      }
+      matches = scored.slice(0, 5).map((sc) => sc.chunk);
+    } catch {
+    }
+    if (matches.length === 0 && await getBlobStore(ctx.projectName, resolvedKnowledgeConfig()).exists("chunks.json")) {
+      matches = await findChunksInProject(
+        ctx.projectName,
+        (c) => c.repoName === repo && c.filePath === file && (!entity || c.entityName === entity),
+        5,
+        resolvedKnowledgeConfig()
+      );
+      if (matches.length === 0 && entity) {
+        matches = await findChunksInProject(ctx.projectName, (c) => c.repoName === repo && c.entityName === entity, 5, resolvedKnowledgeConfig());
+      }
     }
     if (matches.length === 0) {
       return { content: [{ type: "text", text: `No snippet found for ${repo}::${file}${entity ? `::${entity}` : ""}` }] };

package/dist/transports/http-transport.js

@@ -1,25 +1,17 @@
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { toNodeHandler } from "@modelcontextprotocol/node";
 import { createAuthMiddleware } from "../middleware/auth.js";
 import { registry, metrics } from "../observability/metrics.js";
 async function startHttpTransport(opts) {
   const { config, createMcpServer, onReady, getHealth } = opts;
   const authenticate = createAuthMiddleware(config);
   const startedAt = Date.now();
-  const sessions = /* @__PURE__ */ new Map();
-  const ttlMin = parseInt(process.env.CODE_SEARCH_SESSION_TTL_MINUTES ?? "", 10);
-  const SESSION_TTL_MS = (Number.isFinite(ttlMin) && ttlMin > 0 ? ttlMin : 120) * 60 * 1e3;
-  const maxEnv = parseInt(process.env.CODE_SEARCH_MAX_SESSIONS ?? "", 10);
-  const MAX_SESSIONS = Number.isFinite(maxEnv) && maxEnv > 0 ? maxEnv : 100;
-  setInterval(() => {
-    const now = Date.now();
-    for (const [id, session] of sessions) {
-      if (now - session.lastActivity > SESSION_TTL_MS) {
-        sessions.delete(id);
-      }
-    }
-  }, 5 * 60 * 1e3).unref();
+  const mcpHandler = createMcpHandler(async () => (await createMcpServer()).server, {
+    onerror: (err) => console.error(`[code-search-mcp] MCP handler error: ${err.message}`)
+  });
+  const handleMcp = toNodeHandler(mcpHandler);
   const httpServer = createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
     const path = url.pathname;
@@ -30,7 +22,6 @@ async function startHttpTransport(opts) {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({
         status: "ok",
-        activeSessions: sessions.size,
         ...health
       }));
       return;
@@ -45,7 +36,7 @@ async function startHttpTransport(opts) {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({
         name: "code-search-mcp",
-        version: "0.1.0",
+        version: "1.0.0",
         node: process.version,
         platform: process.platform
       }));
@@ -70,9 +61,8 @@ async function startHttpTransport(opts) {
       const status = opts.getStatus?.() ?? {};
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({
-        version: "0.1.0",
+        version: "1.0.0",
         uptime: Math.floor((Date.now() - startedAt) / 1e3),
-        sessions: sessions.size,
         ...status
       }, null, 2));
       return;
@@ -117,74 +107,7 @@ async function startHttpTransport(opts) {
         const identity = authenticate(req, res);
         if (!identity) return;
       }
-      if (req.method === "POST") {
-        const sessionId = req.headers["mcp-session-id"];
-        if (sessionId && sessions.has(sessionId)) {
-          sessions.get(sessionId).lastActivity = Date.now();
-          await sessions.get(sessionId).transport.handleRequest(req, res);
-          return;
-        }
-        if (sessionId && !sessions.has(sessionId)) {
-          res.writeHead(404, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Session expired or unknown \u2014 reinitialize." }));
-          return;
-        }
-        if (sessions.size >= MAX_SESSIONS) {
-          res.writeHead(503, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Too many active sessions. Try again later." }));
-          return;
-        }
-        try {
-          const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => randomUUID()
-          });
-          const { server: mcpServer } = await createMcpServer();
-          await mcpServer.connect(transport);
-          transport.onclose = () => {
-            for (const [id, s] of sessions) {
-              if (s.transport === transport) {
-                sessions.delete(id);
-                break;
-              }
-            }
-          };
-          await transport.handleRequest(req, res);
-          const newSessionId = res.getHeader("mcp-session-id");
-          if (newSessionId) {
-            sessions.set(newSessionId, { transport, lastActivity: Date.now() });
-          }
-        } catch (err) {
-          if (!res.headersSent) {
-            res.writeHead(500, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Failed to create session" }));
-          }
-        }
-        return;
-      }
-      if (req.method === "GET") {
-        const sessionId = req.headers["mcp-session-id"];
-        if (sessionId && sessions.has(sessionId)) {
-          sessions.get(sessionId).lastActivity = Date.now();
-          await sessions.get(sessionId).transport.handleRequest(req, res);
-          return;
-        }
-        res.writeHead(sessionId ? 404 : 400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: sessionId ? "Session expired or unknown \u2014 reinitialize." : "Session ID required for GET requests" }));
-        return;
-      }
-      if (req.method === "DELETE") {
-        const sessionId = req.headers["mcp-session-id"];
-        if (sessionId && sessions.has(sessionId)) {
-          await sessions.get(sessionId).transport.handleRequest(req, res);
-          sessions.delete(sessionId);
-          return;
-        }
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Invalid session ID" }));
-        return;
-      }
-      res.writeHead(405, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Method not allowed" }));
+      await handleMcp(req, res);
       return;
     }
     res.writeHead(404, { "Content-Type": "application/json" });
@@ -194,7 +117,7 @@ async function startHttpTransport(opts) {
     httpServer.listen(config.port, config.host, () => {
       const url = `http://${config.host === "0.0.0.0" ? "localhost" : config.host}:${config.port}`;
       onReady?.(url);
-      resolve();
+      resolve(httpServer);
     });
   });
 }

package/dist/transports/remote-proxy.js

@@ -1,11 +1,5 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 class RemoteConnection {
   serverUrl;
   apiKey;
@@ -70,7 +64,7 @@ class RemoteConnection {
     return this.request("initialize", {
       protocolVersion: "2024-11-05",
       capabilities: {},
-      clientInfo: { name: "code-search-mcp-proxy", version: "0.1.0" }
+      clientInfo: { name: "code-search-mcp-proxy", version: "1.0.0" }
     });
   }
   /** Check remote server health */
@@ -97,10 +91,10 @@ async function startRemoteProxy(config) {
     console.error(`[code-search-mcp] WARNING: Session init failed: ${err.message}. Will retry on first request.`);
   }
   const server = new Server(
-    { name: "code-search-mcp", version: "0.1.0" },
+    { name: "code-search-mcp", version: "1.0.0" },
     { capabilities: { tools: {}, resources: {} } }
   );
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
+  server.setRequestHandler("tools/list", async () => {
     try {
       const response = await remote.request("tools/list");
       return response.result ?? { tools: [] };
@@ -109,7 +103,7 @@ async function startRemoteProxy(config) {
       return { tools: [] };
     }
   });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler("tools/call", async (request) => {
     try {
       const response = await remote.request("tools/call", {
         name: request.params.name,
@@ -126,7 +120,7 @@ async function startRemoteProxy(config) {
       };
     }
   });
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  server.setRequestHandler("resources/list", async () => {
     try {
       const response = await remote.request("resources/list");
       return response.result ?? { resources: [] };
@@ -134,7 +128,7 @@ async function startRemoteProxy(config) {
       return { resources: [] };
     }
   });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  server.setRequestHandler("resources/read", async (request) => {
     try {
       const response = await remote.request("resources/read", {
         uri: request.params.uri

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@esankhan3/code-search-mcp",
-  "version": "0.4.11",
-  "description": "MCP server for multi-repo code search — GitHub org or local path, zero config",
+  "version": "1.0.0",
+  "description": "MCP server for multi-repo code search \u2014 GitHub org or local path, zero config",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -23,9 +23,10 @@
     "smoke": "bash scripts/smoke/run-smoke.sh"
   },
   "dependencies": {
-    "@esankhan3/anvil-agent-core": "^0.4.0",
-    "@esankhan3/anvil-knowledge-core": "^0.3.1",
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@esankhan3/anvil-agent-core": "^0.5.0",
+    "@esankhan3/anvil-knowledge-core": "^0.4.0",
+    "@modelcontextprotocol/node": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0"
   },
   "optionalDependencies": {
     "@lancedb/lancedb-darwin-arm64": "0.27.2",
@@ -35,6 +36,7 @@
     "@lancedb/lancedb-win32-x64-msvc": "0.27.2"
   },
   "devDependencies": {
+    "@modelcontextprotocol/client": "^2.0.0",
     "@types/node": "^22.15.2"
   },
   "repository": {