sift-light 1.0.0 → 1.0.1

package/src/concept-inference.ts

@@ -21,7 +21,9 @@ export interface ConceptEmbeddingCallbacks {
   ) => void | Promise<void>;
 }
 
-const INFERENCE_BATCH_SIZE = 16;
+// Bound each ONNX call to four model windows. Larger native batches raised peak
+// RSS without a useful cold-start gain on the measured workload.
+const INFERENCE_BATCH_SIZE = 4;
 
 /** Snap a candidate UTF-16 index so it never splits a surrogate pair. */
 export function safeUtf16End(text: string, end: number): number {
@@ -62,6 +64,10 @@ export function maximumTokenSafeEnd(
   text: string,
   start: number,
 ): number {
+  // Most source passages already fit the model window. Avoid repeatedly
+  // tokenizing prefixes of the same passage in the binary-search path.
+  if (tokenCount(extractor, `${prefix}${text.slice(start)}`) <= CONCEPT_MODEL_TOKENS)
+    return text.length;
   let low = start + 1;
   let high = text.length;
   let accepted = start;
@@ -142,30 +148,56 @@ export async function embedConceptInputs(
 ): Promise<CachedConceptEmbedding[]> {
   const layouts = pending.map((item) => tokenSafeWindows(extractor, item));
   const inputs = layouts.flatMap((windows) => windows.map((window) => window.input));
-  const vectors: number[][] = [];
+  const vectors: (number[] | undefined)[] = Array(inputs.length);
   const layoutEnds: number[] = [];
+  const remainingWindows = layouts.map((windows) => windows.length);
   let layoutEnd = 0;
   for (const windows of layouts) {
     layoutEnd += windows.length;
     layoutEnds.push(layoutEnd);
   }
+  const orderedInputs = inputs
+    .map((input, index) => ({ input, index, tokens: tokenCount(extractor, input) }))
+    // Start with the largest shapes so the native arena can reuse allocations
+    // for smaller batches instead of retaining a growing sequence of arenas.
+    .toSorted((left, right) => right.tokens - left.tokens || left.index - right.index);
+  const vectorFor = (index: number): number[] => {
+    const vector = vectors[index];
+    if (!vector) throw new Error("Missing concept embedding vector");
+    return vector;
+  };
+  const ownerOf = (index: number): number => {
+    let low = 0;
+    let high = layoutEnds.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (index < layoutEnds[middle]!) high = middle;
+      else low = middle + 1;
+    }
+    return low;
+  };
   let completedEmbedding = 0;
-  for (let offset = 0; offset < inputs.length; offset += INFERENCE_BATCH_SIZE) {
-    const batch = inputs.slice(offset, offset + INFERENCE_BATCH_SIZE);
+  let completedWindows = 0;
+  for (let offset = 0; offset < orderedInputs.length;) {
+    const orderedBatch = orderedInputs.slice(offset, offset + INFERENCE_BATCH_SIZE);
+    const batch = orderedBatch.map((item) => item.input);
     // oxlint-disable-next-line no-await-in-loop -- bounded batches cap native tensor memory.
     const tensor = await extractor(batch, { pooling: "mean", normalize: true });
     if (tensor.data.length !== batch.length * CONCEPT_EMBEDDING_DIMENSIONS)
       throw new Error("Unexpected concept embedding dimensions");
     for (let index = 0; index < batch.length; index += 1) {
       const start = index * CONCEPT_EMBEDDING_DIMENSIONS;
-      vectors.push(
-        Array.from(tensor.data.slice(start, start + CONCEPT_EMBEDDING_DIMENSIONS), Number),
+      const inputIndex = orderedBatch[index]!.index;
+      vectors[inputIndex] = Array.from(
+        tensor.data.slice(start, start + CONCEPT_EMBEDDING_DIMENSIONS),
+        Number,
       );
+      remainingWindows[ownerOf(inputIndex)]!--;
     }
-    const completedWindows = Math.min(offset + batch.length, inputs.length);
+    completedWindows += batch.length;
     while (
-      layoutEnds[completedEmbedding] !== undefined &&
-      layoutEnds[completedEmbedding]! <= completedWindows
+      remainingWindows[completedEmbedding] !== undefined &&
+      remainingWindows[completedEmbedding] === 0
     ) {
       const start = completedEmbedding === 0 ? 0 : layoutEnds[completedEmbedding - 1]!;
       const item = pending[completedEmbedding];
@@ -177,7 +209,7 @@ export async function embedConceptInputs(
           windows: (layouts[completedEmbedding] ?? []).map((window, index) => ({
             start: window.start,
             end: window.end,
-            vector: vectors[start + index] ?? [],
+            vector: vectorFor(start + index),
           })),
         },
         completedEmbedding + 1,
@@ -186,6 +218,7 @@ export async function embedConceptInputs(
       completedEmbedding += 1;
     }
     callbacks.onBatch?.(completedWindows, inputs.length);
+    offset += batch.length;
   }
   let vectorIndex = 0;
   return pending.map((item, index) => ({
@@ -193,7 +226,7 @@ export async function embedConceptInputs(
     windows: (layouts[index] ?? []).map((window) => ({
       start: window.start,
       end: window.end,
-      vector: vectors[vectorIndex++] ?? [],
+      vector: vectorFor(vectorIndex++),
     })),
   }));
 }

package/src/concept-model.ts

@@ -8,10 +8,10 @@ export const CONCEPT_MODEL = "Xenova/multilingual-e5-small";
 export const CONCEPT_REVISION = "761b726dd34fb83930e26aab4e9ac3899aa1fa78";
 export const MAX_CONCEPT_CHARS = 1_000;
 export const CONCEPT_PASSAGE_OVERLAP_CHARS = 160;
-export const CONCEPT_MODEL_TOKENS = 512;
+export const CONCEPT_MODEL_TOKENS = 256;
 export const CONCEPT_WINDOW_OVERLAP_TOKENS = 64;
 export const CONCEPT_EMBEDDING_DIMENSIONS = 384;
-export const CONCEPT_CACHE_VERSION = 1;
+export const CONCEPT_CACHE_VERSION = 2;
 export const CONCEPT_CACHE_MAX_BYTES = 512 * 1024 * 1024;
 export const CONCEPT_TIMEOUT_MS = 10 * 60_000;
 export const MIN_CONCEPT_TIMEOUT_MS = 1_000;

package/src/concept-search.ts

@@ -86,6 +86,14 @@ function scoreProfile(scores: readonly number[]): ConceptScoreProfile {
   };
 }
 
+/** E5 cosine scores favor very short, generic passages in close races. Keep the
+ * raw cosine as evidence and apply a bounded length correction only to rank. */
+export function conceptRankingScore(cosine: number, passageLength: number): number {
+  const referenceLength = 500;
+  const maximumCorrection = 0.02;
+  return cosine - maximumCorrection * (1 - Math.sqrt(Math.min(passageLength / referenceLength, 1)));
+}
+
 function passage(document: SourceDocument, start: number): { value: Passage; next: number } {
   let end = Math.min(document.text.length, start + MAX_CONCEPT_CHARS);
   if (end < document.text.length) {
@@ -433,6 +441,7 @@ async function runConceptSearch(
     const batchItems = passages.map((item, index) => {
       const similarity = inferred.scores[index];
       if (similarity === undefined) throw new Error("Missing concept similarity");
+      const rankingScore = conceptRankingScore(similarity, item.text.length);
       const evidence = rangeEvidence(item.document, item.range);
       return {
         path: item.document.path,
@@ -445,8 +454,9 @@ async function runConceptSearch(
           kind: "concept-candidate",
           certainty: "candidate",
           score: similarity,
+          rankingScore,
           rankingReason:
-            "local multilingual E5 cosine similarity; relevance candidate, no binding or execution claim",
+            "local multilingual E5 cosine similarity with bounded short-passage rank correction; relevance candidate, no binding or execution claim",
           model: CONCEPT_MODEL,
           revision: CONCEPT_REVISION,
           tokenTruncated: false,
@@ -457,7 +467,7 @@ async function runConceptSearch(
     });
     const ranked = [...result.items, ...batchItems].toSorted(
       (a, b) =>
-        Number(b.details?.score) - Number(a.details?.score) ||
+        Number(b.details?.rankingScore) - Number(a.details?.rankingScore) ||
         a.path.localeCompare(b.path) ||
         a.line - b.line,
     );

package/src/concept-worker.mjs

@@ -27,10 +27,10 @@ class SiftLightError extends Error {
 var CONCEPT_MODEL = "Xenova/multilingual-e5-small";
 var CONCEPT_REVISION = "761b726dd34fb83930e26aab4e9ac3899aa1fa78";
 var MAX_CONCEPT_CHARS = 1000;
-var CONCEPT_MODEL_TOKENS = 512;
+var CONCEPT_MODEL_TOKENS = 256;
 var CONCEPT_WINDOW_OVERLAP_TOKENS = 64;
 var CONCEPT_EMBEDDING_DIMENSIONS = 384;
-var CONCEPT_CACHE_VERSION = 1;
+var CONCEPT_CACHE_VERSION = 2;
 var CONCEPT_CACHE_MAX_BYTES = 512 * 1024 * 1024;
 var CONCEPT_TIMEOUT_MS = 10 * 60000;
 var MAX_CONCEPT_TIMEOUT_MS = 60 * 60000;
@@ -222,7 +222,7 @@ async function enforceConceptCacheLimit(root, maximumBytes = CONCEPT_CACHE_MAX_B
 }
 
 // src/concept-inference.ts
-var INFERENCE_BATCH_SIZE = 16;
+var INFERENCE_BATCH_SIZE = 4;
 function safeUtf16End(text, end) {
   if (end <= 0 || end >= text.length)
     return end;
@@ -247,6 +247,8 @@ function binarySearchBudget(span) {
   return 2 * Math.max(span, 1) + 32;
 }
 function maximumTokenSafeEnd(extractor, prefix, text, start) {
+  if (tokenCount(extractor, `${prefix}${text.slice(start)}`) <= CONCEPT_MODEL_TOKENS)
+    return text.length;
   let low = start + 1;
   let high = text.length;
   let accepted = start;
@@ -312,25 +314,49 @@ function tokenSafeWindows(extractor, pending) {
 async function embedConceptInputs(extractor, pending, callbacks = {}) {
   const layouts = pending.map((item) => tokenSafeWindows(extractor, item));
   const inputs = layouts.flatMap((windows) => windows.map((window) => window.input));
-  const vectors = [];
+  const vectors = Array(inputs.length);
   const layoutEnds = [];
+  const remainingWindows = layouts.map((windows) => windows.length);
   let layoutEnd = 0;
   for (const windows of layouts) {
     layoutEnd += windows.length;
     layoutEnds.push(layoutEnd);
   }
+  const orderedInputs = inputs.map((input, index) => ({ input, index, tokens: tokenCount(extractor, input) })).toSorted((left, right) => right.tokens - left.tokens || left.index - right.index);
+  const vectorFor = (index) => {
+    const vector = vectors[index];
+    if (!vector)
+      throw new Error("Missing concept embedding vector");
+    return vector;
+  };
+  const ownerOf = (index) => {
+    let low = 0;
+    let high = layoutEnds.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (index < layoutEnds[middle])
+        high = middle;
+      else
+        low = middle + 1;
+    }
+    return low;
+  };
   let completedEmbedding = 0;
-  for (let offset = 0;offset < inputs.length; offset += INFERENCE_BATCH_SIZE) {
-    const batch = inputs.slice(offset, offset + INFERENCE_BATCH_SIZE);
+  let completedWindows = 0;
+  for (let offset = 0;offset < orderedInputs.length; ) {
+    const orderedBatch = orderedInputs.slice(offset, offset + INFERENCE_BATCH_SIZE);
+    const batch = orderedBatch.map((item) => item.input);
     const tensor = await extractor(batch, { pooling: "mean", normalize: true });
     if (tensor.data.length !== batch.length * CONCEPT_EMBEDDING_DIMENSIONS)
       throw new Error("Unexpected concept embedding dimensions");
     for (let index = 0;index < batch.length; index += 1) {
       const start = index * CONCEPT_EMBEDDING_DIMENSIONS;
-      vectors.push(Array.from(tensor.data.slice(start, start + CONCEPT_EMBEDDING_DIMENSIONS), Number));
+      const inputIndex = orderedBatch[index].index;
+      vectors[inputIndex] = Array.from(tensor.data.slice(start, start + CONCEPT_EMBEDDING_DIMENSIONS), Number);
+      remainingWindows[ownerOf(inputIndex)]--;
     }
-    const completedWindows = Math.min(offset + batch.length, inputs.length);
-    while (layoutEnds[completedEmbedding] !== undefined && layoutEnds[completedEmbedding] <= completedWindows) {
+    completedWindows += batch.length;
+    while (remainingWindows[completedEmbedding] !== undefined && remainingWindows[completedEmbedding] === 0) {
       const start = completedEmbedding === 0 ? 0 : layoutEnds[completedEmbedding - 1];
       const item = pending[completedEmbedding];
       if (!item)
@@ -340,12 +366,13 @@ async function embedConceptInputs(extractor, pending, callbacks = {}) {
         windows: (layouts[completedEmbedding] ?? []).map((window, index) => ({
           start: window.start,
           end: window.end,
-          vector: vectors[start + index] ?? []
+          vector: vectorFor(start + index)
         }))
       }, completedEmbedding + 1, pending.length);
       completedEmbedding += 1;
     }
     callbacks.onBatch?.(completedWindows, inputs.length);
+    offset += batch.length;
   }
   let vectorIndex = 0;
   return pending.map((item, index) => ({
@@ -353,7 +380,7 @@ async function embedConceptInputs(extractor, pending, callbacks = {}) {
     windows: (layouts[index] ?? []).map((window) => ({
       start: window.start,
       end: window.end,
-      vector: vectors[vectorIndex++] ?? []
+      vector: vectorFor(vectorIndex++)
     }))
   }));
 }
@@ -504,7 +531,7 @@ async function search() {
       local_files_only: true,
       dtype: "q8",
       device: "cpu",
-      session_options: { intraOpNumThreads: 2, interOpNumThreads: 1 }
+      session_options: { intraOpNumThreads: 4, interOpNumThreads: 1 }
     });
     try {
       created = await embedConceptInputs(extractor, missing, {

package/src/concept-worker.ts

@@ -140,7 +140,7 @@ async function search(): Promise<void> {
       local_files_only: true,
       dtype: "q8",
       device: "cpu",
-      session_options: { intraOpNumThreads: 2, interOpNumThreads: 1 },
+      session_options: { intraOpNumThreads: 4, interOpNumThreads: 1 },
     });
     try {
       created = await embedConceptInputs(extractor, missing, {

package/src/config-reader.ts

@@ -12,6 +12,7 @@ export const SIFT_LIGHT_ENFORCEMENT_ENV = "SIFT_LIGHT_ENFORCE_SEARCH";
 export interface SiftLightConfig {
   locale: SiftLightLocale;
   enforceSearch?: SearchEnforcementMode;
+  vectorSearchEnabled?: boolean;
   semanticJudge?: SemanticJudgeConfig;
 }
 
@@ -44,12 +45,14 @@ export const DEFAULT_SEMANTIC_JUDGE_CONFIG: Readonly<SemanticJudgeConfig> = {
 export const DEFAULT_SIFT_LIGHT_CONFIG: Readonly<SiftLightConfig> = {
   locale: "en",
   enforceSearch: "hard",
+  vectorSearchEnabled: false,
   semanticJudge: DEFAULT_SEMANTIC_JUDGE_CONFIG,
 };
 
 interface RawSiftLightConfig {
   locale?: unknown;
   enforceSearch?: unknown;
+  vectorSearchEnabled?: unknown;
   semanticJudge?: unknown;
 }
 
@@ -221,21 +224,26 @@ function parseConfig(value: unknown, path: string): SiftLightConfig {
     throw new Error(`Invalid sift-light config at ${path}: expected a JSON object`);
   }
   const unknown = Object.keys(value).filter(
-    (key) => !["locale", "enforceSearch", "semanticJudge"].includes(key),
+    (key) => !["locale", "enforceSearch", "vectorSearchEnabled", "semanticJudge"].includes(key),
   );
   if (unknown.length > 0) {
     throw new Error(
-      `Invalid sift-light config at ${path}: unsupported configuration fields; only locale, enforceSearch and semanticJudge are accepted`,
+      `Invalid sift-light config at ${path}: unsupported configuration fields; only locale, enforceSearch, vectorSearchEnabled and semanticJudge are accepted`,
     );
   }
-  const { locale, enforceSearch } = value;
+  const { locale, enforceSearch, vectorSearchEnabled } = value;
   if (locale !== undefined && locale !== "en" && locale !== "zh-CN") {
     throw new Error(`Invalid sift-light config at ${path}: locale must be "en" or "zh-CN"`);
   }
+  if (vectorSearchEnabled !== undefined && typeof vectorSearchEnabled !== "boolean") {
+    throw new Error(`Invalid sift-light config at ${path}: vectorSearchEnabled must be a boolean`);
+  }
   const enforcement = normalizeSearchEnforcement(enforceSearch, `config at ${path}`);
   return {
     locale: locale ?? DEFAULT_SIFT_LIGHT_CONFIG.locale,
     enforceSearch: enforcement,
+    vectorSearchEnabled:
+      vectorSearchEnabled ?? DEFAULT_SIFT_LIGHT_CONFIG.vectorSearchEnabled ?? false,
     semanticJudge: parseSemanticJudge(value.semanticJudge, path),
   };
 }

package/src/hybrid-search.ts

@@ -274,6 +274,14 @@ export async function combineHybridSearch(
   const selectionReason = conceptCandidatesOmitted
     ? `Hybrid concept limit retained the top ${String(selectedConcept.length)} of ${String(eligibleConcept.length)} non-overlapping semantic candidates`
     : undefined;
+  const firstScore = Number(
+    eligibleConcept[0]?.details?.rankingScore ?? eligibleConcept[0]?.details?.score,
+  );
+  const secondScore = Number(
+    eligibleConcept[1]?.details?.rankingScore ?? eligibleConcept[1]?.details?.score,
+  );
+  const closeRanking =
+    Number.isFinite(firstScore) && Number.isFinite(secondScore) && firstScore - secondScore < 0.01;
   return {
     kind: "hybrid",
     unit: "evidence-items",
@@ -285,6 +293,11 @@ export async function combineHybridSearch(
       ...literal.reasons,
       ...execution.sourceGeneration.reasons,
       ...(selectionReason ? [selectionReason] : []),
+      ...(closeRanking
+        ? [
+            "Semantic ranks are close; verify the leading candidates with source inspection or literal terms.",
+          ]
+        : []),
       ...(judgedConcept.semanticJudge?.reason ? [judgedConcept.semanticJudge.reason] : []),
     ],
     filesRead: (concept.filesRead ?? 0) + access.filesRead,

package/src/index.ts

@@ -1,11 +1,6 @@
 import { SIFT_LIGHT_DESCRIPTION, siftLightSchema } from "./tool-schema.js";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import {
-  normalizeSearchEnforcement,
-  readSiftLightConfig,
-  DEFAULT_SEMANTIC_JUDGE_CONFIG,
-  type SiftLightConfig,
-} from "./config.js";
+import { normalizeSearchEnforcement, readSiftLightConfig, type SiftLightConfig } from "./config.js";
 import { resolveContextBudget } from "./context-budget.js";
 import { createRipgrepRunner } from "./rg.js";
 import { createCtagsStructureProvider } from "./structure.js";
@@ -17,7 +12,7 @@ import type { SiftLightDetails } from "./types.js";
 import { renderSiftLightCall, renderSiftLightResult } from "./tui/renderers.js";
 import { registerPiSearchPolicy } from "./pi-search-policy.js";
 import { modelErrorText } from "./model-error.js";
-import { createSemanticJudgeIntegration } from "./semantic-judge.js";
+import { createConfiguredSemanticJudgeIntegration } from "./semantic-judge.js";
 
 const SIFT_LIGHT_LABEL = "sift-light";
 
@@ -27,13 +22,12 @@ export async function registerSiftLightExtension(
   pi: ExtensionAPI,
   config: SiftLightConfig,
 ): Promise<void> {
-  const semanticJudge = createSemanticJudgeIntegration(
-    config.semanticJudge ?? DEFAULT_SEMANTIC_JUDGE_CONFIG,
-  );
+  const semanticJudge = createConfiguredSemanticJudgeIntegration(config);
   const runtime = new SiftLightRuntime(
     new SiftLightService({
       runRipgrep: createRipgrepRunner(),
       structure: createCtagsStructureProvider(),
+      vectorSearchEnabled: config.vectorSearchEnabled === true,
       semanticJudge,
     }),
   );

package/src/mcp-model-output.ts

@@ -7,7 +7,48 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function compactSemanticMetadata(details: SiftLightDetails, analysis: AnalysisDetails): string[] {
+  const counts = analysis.counts;
+  const stats = analysis.stats;
+  const judge = analysis.semanticJudge;
+  const coverage = analysis.coverage;
+  return [
+    ...(counts || stats
+      ? [
+          `Search: ${String(counts?.filesAdmitted ?? stats?.filesAdmitted ?? 0)} files, ${String(stats?.passagesRanked ?? counts?.passagesQueued ?? 0)} passages; ${String(stats?.elapsedMs ?? 0)} ms; peak inference RSS ${String(stats?.inferencePeakRssBytes ?? 0)} bytes; cache ${String(stats?.conceptCacheHits ?? 0)} hits/${String(stats?.conceptCacheMisses ?? 0)} misses.`,
+        ]
+      : []),
+    ...(coverage
+      ? [
+          `Coverage: ${Object.entries(coverage)
+            .map(([name, status]) => `${name}=${status}`)
+            .join(", ")}.`,
+        ]
+      : []),
+    ...(analysis.scope
+      ? [`Scope: ${analysis.scope.path}; ignore=${analysis.scope.ignorePolicy}.`]
+      : []),
+    ...(analysis.sourceGeneration
+      ? [
+          `Source: ${analysis.sourceGeneration.verification}; ${String(analysis.sourceGeneration.filesUnavailable)} unavailable.`,
+        ]
+      : []),
+    ...(judge
+      ? [
+          `Semantic judge: ${judge.status}; ${String(judge.judgedCandidates)}/${String(judge.candidatesConsidered)} judged, ${String(judge.candidatesUnjudged)} unjudged; batches ${String(judge.batchesCompleted)}/${String(judge.batchesAttempted)} completed; classes ${JSON.stringify(judge.classificationCounts)}${judge.reason ? `; ${judge.reason}` : ""}.`,
+        ]
+      : []),
+    ...(details.operation
+      ? [`Operation: ${details.operation.state}; id=${details.operation.id}.`]
+      : []),
+    ...analysis.reasons.map((reason) => `[${reason}]`),
+    ...(details.redactionApplied ? ["[Display redaction applied.]"] : []),
+  ];
+}
+
 function compactMetadata(details: SiftLightDetails, analysis: AnalysisDetails): string[] {
+  if (analysis.kind === "concept" || analysis.kind === "hybrid")
+    return compactSemanticMetadata(details, analysis);
   return [
     ...(analysis.statistics ? formatStatistics(analysis.statistics) : []),
     analysis.counts ? `Counts: ${JSON.stringify(analysis.counts)}` : undefined,

package/src/mcp-semantic-judge.ts

@@ -1,11 +1,12 @@
 import {
+  DEFAULT_SIFT_LIGHT_CONFIG,
   DEFAULT_SEMANTIC_JUDGE_CONFIG,
   readSiftLightConfigFile,
   SIFT_LIGHT_CONFIG_ENV,
 } from "./config-reader.js";
 import {
   createDisabledSemanticJudgeIntegration,
-  createSemanticJudgeIntegration,
+  createConfiguredSemanticJudgeIntegration,
   type SemanticJudgeIntegration,
 } from "./semantic-judge.js";
 
@@ -19,17 +20,27 @@ function configuredPath(environment: NodeJS.ProcessEnv): string | undefined {
  * The MCP process must receive the same config path explicitly in its own host
  * environment; an absent path remains an observable, local-only disabled state.
  */
-export async function createMcpSemanticJudgeIntegration(
+export async function createMcpSearchFeatures(
   environment: NodeJS.ProcessEnv = process.env,
-): Promise<SemanticJudgeIntegration> {
+): Promise<{ semanticJudge: SemanticJudgeIntegration; vectorSearchEnabled: boolean }> {
   const path = configuredPath(environment);
-  if (!path) return createDisabledSemanticJudgeIntegration(DEFAULT_SEMANTIC_JUDGE_CONFIG);
+  if (!path)
+    return {
+      semanticJudge: createDisabledSemanticJudgeIntegration(DEFAULT_SEMANTIC_JUDGE_CONFIG),
+      vectorSearchEnabled: DEFAULT_SIFT_LIGHT_CONFIG.vectorSearchEnabled === true,
+    };
 
   const config = await readSiftLightConfigFile(path, { missing: "error" });
-  return createSemanticJudgeIntegration(
-    config.semanticJudge ?? DEFAULT_SEMANTIC_JUDGE_CONFIG,
-    environment,
-  );
+  return {
+    semanticJudge: createConfiguredSemanticJudgeIntegration(config, environment),
+    vectorSearchEnabled: config.vectorSearchEnabled === true,
+  };
+}
+
+export async function createMcpSemanticJudgeIntegration(
+  environment: NodeJS.ProcessEnv = process.env,
+): Promise<SemanticJudgeIntegration> {
+  return (await createMcpSearchFeatures(environment)).semanticJudge;
 }
 
 export function mcpSemanticJudgeConfigSource(