neuro-vault-mcp 1.3.1 → 1.4.0

package/README.md

@@ -1,133 +1,272 @@
 # Neuro Vault MCP
 
-Neuro Vault MCP is a Model Context Protocol server for semantic search over an Obsidian vault that already has Smart Connections embeddings and note data on disk. It reads Smart Connections `.smart-env/multi/*.ajson` files, loads the corpus into memory, and exposes MCP tools over stdio so compatible clients can search the vault without extra infrastructure.
+**Semantic search over your Obsidian vault — right inside your AI assistant.**
 
-## Overview
+[![npm version](https://img.shields.io/npm/v/neuro-vault-mcp)](https://www.npmjs.com/package/neuro-vault-mcp)
+[![Node.js](https://img.shields.io/node/v/neuro-vault-mcp)](https://nodejs.org)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 
-The server is started by an MCP host or from the command line with an explicit vault path:
+> "What did I write about that idea last month?"
 
-```bash
-neuro-vault-mcp --vault /absolute/path/to/vault
-```
+Neuro Vault MCP connects your Obsidian vault to any MCP-compatible AI assistant. It reuses the embeddings already computed by [Smart Connections](https://github.com/brianpetro/obsidian-smart-connections) — no re-indexing, no extra infrastructure, no API keys.
+
+---
 
-The vault path must be absolute. Neuro Vault MCP expects Smart Connections data in:
+## How It Works
 
-```text
-<vault>/.smart-env/multi/*.ajson
 ```
+Your question
+     │
+     ▼
+ AI assistant
+     │ rewrites to keyword queries + picks mode
+     ▼
+ search_notes (MCP tool)
+     │
+     ├─ vector search over Smart Connections embeddings
+     ├─ block-level search (all modes)
+     └─ expansion via similar notes (deep mode)
+     │
+     ▼
+ Ranked results with note paths, similarity scores, section headings
+```
+
+The server loads `.smart-env/multi/*.ajson` into memory at startup and keeps it there. No background processes, no watchers, no database.
 
-On first run, the query embedding model is downloaded automatically. That initial model download may add noticeable startup latency.
+---
 
 ## Requirements
 
-- Node.js 20 or newer
-- An Obsidian vault on the local machine
-- Smart Connections data present in `<vault>/.smart-env/multi/*.ajson`
+- Node.js 20+
+- Obsidian vault with [Smart Connections](https://github.com/brianpetro/obsidian-smart-connections) plugin (embeddings must be generated)
+- Smart Connections data at `<vault>/.smart-env/multi/*.ajson`
 
-## Installation
+---
 
-Install globally:
+## Quick Start
+
+**1. Install**
 
 ```bash
 npm install -g neuro-vault-mcp
 ```
 
-Or run it on demand with `npx`:
+**2. Configure your MCP client**
 
-```bash
-npx -y neuro-vault-mcp --vault /absolute/path/to/vault
-```
+For Claude Code (`~/.claude/settings.json` or `.claude/settings.json` in your project):
 
-## MCP Configuration Example
+```json
+{
+  "mcpServers": {
+    "neuro-vault": {
+      "command": "neuro-vault-mcp",
+      "args": ["--vault", "/absolute/path/to/your/vault"]
+    }
+  }
+}
+```
 
-Most MCP hosts just need the binary and vault argument:
+For Cursor or Windsurf (`.cursor/mcp.json` / `.windsurf/mcp.json`):
 
 ```json
 {
-  "command": "neuro-vault-mcp",
-  "args": ["--vault", "/absolute/path/to/vault"]
+  "mcpServers": {
+    "neuro-vault": {
+      "command": "neuro-vault-mcp",
+      "args": ["--vault", "/absolute/path/to/your/vault"]
+    }
+  }
 }
 ```
 
-If your host uses a more explicit JSON configuration, the same launch command applies:
+Or run without installing using `npx`:
 
 ```json
 {
   "mcpServers": {
     "neuro-vault": {
-      "command": "neuro-vault-mcp",
-      "args": ["--vault", "/absolute/path/to/vault"]
+      "command": "npx",
+      "args": ["-y", "neuro-vault-mcp", "--vault", "/absolute/path/to/your/vault"]
     }
   }
 }
 ```
 
-## CLI Usage
+**3. Try it**
 
-After installing globally, launch the server directly from your shell:
+Ask your assistant:
 
-```bash
-neuro-vault-mcp --vault /absolute/path/to/vault
-```
+> "What did I write about building AI agents?"
+
+> "Find my notes on productivity systems"
+
+> "What are all my ideas related to embeddings?"
+
+On first run the embedding model downloads automatically (~40 MB). Subsequent starts are fast.
+
+---
+
+## Features
+
+### Mode-Based Search
+
+Every search picks a mode that controls retrieval depth:
+
+| Mode    | Use when                          | Limit | Threshold | Expansion |
+| ------- | --------------------------------- | ----- | --------- | --------- |
+| `quick` | Specific question, need 1-2 notes | 3     | 0.50      | off       |
+| `deep`  | Broad topic, need an overview     | 8     | 0.35      | on        |
+
+The AI assistant picks the mode automatically based on your question. You can also pass it explicitly.
+
+### Block-Level Results (Deep Mode)
 
-The process speaks MCP over stdio, so it is intended to be started by a compatible client or wrapper process rather than visited in a browser.
+In `deep` mode the server also searches by individual note sections (blocks), not just whole notes. This surfaces the exact paragraphs that are most relevant, not just the note they live in.
 
-## Available Tools
+### Expansion (Deep Mode)
+
+After finding top results, the server uses their embeddings to discover neighboring notes. This catches related notes that don't directly match your query but are semantically close to what you found.
+
+### Automatic Fallback
+
+When vector search returns nothing, the server retries with a lower similarity threshold (0.3). If still nothing — the AI assistant can search vault files using its own tools.
+
+---
+
+## Tools Reference
 
 ### `search_notes`
 
-Search the loaded corpus by semantic similarity.
+Search the vault by semantic similarity.
+
+```typescript
+search_notes({
+  query: string,               // short keyword query (1-4 words)
+  mode?: "quick" | "deep",    // default: "quick"
+  threshold?: number,          // override mode default (0–1)
+  expansion?: boolean,         // override mode default
+  expansion_limit?: number,    // how many top results to expand (default: 3)
+})
+```
+
+Returns `results` (ranked notes) and `blockResults` (ranked sections — scoped to matched notes in quick mode, all sources in deep mode).
+
+**Tips for better results:**
 
-Parameters:
+- Use short keyword queries (1–4 words), not full sentences
+- Call multiple times for synonyms and translations: `"embeddings"`, then `"векторний пошук"`, then `"vector search"`
+- Lower the threshold to `0.3` if nothing comes back
+- Use `deep` mode for exploratory questions
 
-- `query` `string` required
-- `limit` `number` optional, default `10`, must be a positive integer
-- `threshold` `number` optional, default `0.5`, must be between `0` and `1`
+---
 
 ### `get_similar_notes`
 
-Find notes similar to a vault-relative note path.
+Find notes similar to a given note path.
 
-Parameters:
+```typescript
+get_similar_notes({
+  note_path: string,  // vault-relative POSIX path, e.g. "Projects/neuro-vault.md"
+  limit?: number,     // default: 10
+  threshold?: number, // default: 0.5
+})
+```
+
+Use this after `search_notes` finds a relevant note — it discovers related content without needing a text query.
 
-- `note_path` `string` required, vault-relative and POSIX-style
-- `limit` `number` optional, default `10`, must be a positive integer
-- `threshold` `number` optional, default `0.5`, must be between `0` and `1`
+---
 
 ### `find_duplicates`
 
 Find note pairs with high embedding similarity.
 
-Parameters:
+```typescript
+find_duplicates({
+  threshold?: number, // default: 0.9
+})
+```
 
-- `threshold` `number` optional, default `0.9`, must be between `0` and `1`
+Useful for vault maintenance: identifies notes that cover the same topic and could be merged.
+
+---
 
 ### `get_stats`
 
-Report corpus and embedding statistics.
+Report loaded corpus statistics.
+
+Returns: `{ totalNotes, totalBlocks, embeddingDimension, modelKey }`
 
-Parameters:
+---
 
-- none
+## AGENTS.md / CLAUDE.md Snippet
 
-## Tool Output
+Add this to your `AGENTS.md` or `CLAUDE.md` to help the AI assistant use the vault effectively:
 
-All search-style tools return note paths relative to the vault, similarity scores, and the note blocks preserved from Smart Connections data. `get_stats` returns the loaded corpus size, block count, embedding dimension, and model key.
+```markdown
+## Vault search
 
-## Development Commands
+Use the `search_notes` MCP tool to search my Obsidian vault before answering questions about my notes, projects, or ideas.
+
+Search protocol:
+
+1. Choose mode: `quick` for specific questions, `deep` for broad topics
+2. Rewrite the query: extract 2-4 keywords, remove filler words
+3. Call search_notes once per concept — use separate calls for synonyms and UA↔EN translations
+
+Skip vault search for: general programming questions, translations, tasks with no personal knowledge component.
+```
+
+---
+
+## Configuration
+
+### CLI Arguments
+
+| Argument  | Required | Description                                   |
+| --------- | -------- | --------------------------------------------- |
+| `--vault` | yes      | Absolute path to the Obsidian vault directory |
+| `--help`  | no       | Show help                                     |
+
+### Startup Behavior
+
+- Smart Connections `.ajson` files are loaded into memory once at startup
+- The embedding model (`TaylorAI/bge-micro-v2`) is downloaded on first run and cached by `@xenova/transformers`
+- If the vault path is missing or Smart Connections data is absent, the server exits immediately with an error
+
+### Troubleshooting
+
+**"Smart Connections directory does not exist"** — make sure the Smart Connections plugin has run and generated embeddings. Open Obsidian, let Smart Connections finish indexing, then restart the MCP server.
+
+**First startup is slow** — the embedding model (~40 MB) is downloading. Subsequent starts use the cached model.
+
+**Search returns nothing** — try lowering the threshold: `threshold: 0.3`. Also check that `get_stats` shows a non-zero `totalNotes`.
+
+---
+
+## Development
 
 ```bash
-npm run build
-npm run lint
-npm run format
-npm run format:write
-npm run test
+npm run build       # compile TypeScript to dist/
+npm run test        # run tests with vitest
+npm run lint        # ESLint
+npm run format      # check formatting with Prettier
+npm run format:write  # fix formatting
 ```
 
-## Limitations for v1
+---
+
+## Limitations
 
 - Requires Smart Connections `.ajson` files already present in the vault
-- Uses in-memory search only, with no persistent index
-- Starts over stdio only, not HTTP or SSE
-- Loads the embedding model at startup, so the first run can be slow
-- Expects a local vault path and does not support remote vaults
+- In-memory search only — no persistent index, no background re-indexing
+- stdio transport only — not HTTP or SSE
+- Local vault path only — no remote vaults
+- Embedding model loaded at startup; first run can be slow
+
+---
+
+## License
+
+ISC — see [LICENSE](LICENSE).
+
+Changelog: [Releases](https://github.com/AlexMost/neuro-vault/releases)

package/dist/cli.d.ts

@@ -2,6 +2,11 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 
+interface RetrievalOutput {
+    results: SearchResult[];
+    blockResults?: BlockSearchResult[];
+}
+
 interface SmartBlock {
     key: string;
     heading: string;
@@ -13,14 +18,15 @@ interface SmartSource {
     embedding: number[];
     blocks: SmartBlock[];
 }
-interface SearchResultBlock {
+interface BlockSearchResult {
+    path: string;
     heading: string;
     lines: [number, number];
+    similarity: number;
 }
 interface SearchResult {
     path: string;
     similarity: number;
-    blocks: SearchResultBlock[];
 }
 interface DuplicatePair {
     note_a: string;
@@ -39,15 +45,25 @@ interface SearchEngine {
         limit?: number;
         excludePath?: string;
     }): SearchResult[];
+    findBlockNeighbors(args: {
+        queryVector: number[];
+        sources: Iterable<SmartSource>;
+        threshold: number;
+        limit?: number;
+    }): BlockSearchResult[];
     findDuplicates(args: {
         sources: Iterable<SmartSource>;
         threshold: number;
     }): DuplicatePair[];
 }
+type SearchMode = 'quick' | 'deep';
 interface SearchNotesInput {
     query: string;
+    mode?: SearchMode;
     limit?: number;
     threshold?: number;
+    expansion?: boolean;
+    expansion_limit?: number;
 }
 interface GetSimilarNotesInput {
     note_path: string;
@@ -72,7 +88,7 @@ interface ToolHandlerDependencies {
     modelKey: string;
 }
 interface ToolHandlers {
-    searchNotes(input: SearchNotesInput): Promise<SearchResult[]>;
+    searchNotes(input: SearchNotesInput): Promise<RetrievalOutput>;
     getSimilarNotes(input: GetSimilarNotesInput): Promise<SearchResult[]>;
     findDuplicates(input?: FindDuplicatesInput): Promise<DuplicatePair[]>;
     getStats(): Promise<ToolStats>;

package/dist/cli.js

@@ -14099,7 +14099,6 @@ function getEmbeddingDimension(sources) {
 }
 
 // src/search-engine.ts
-var MAX_BLOCKS_PER_RESULT = 5;
 function validateVector(vector, label) {
   if (vector.length === 0) {
     throw new Error(`${label} must not be empty`);
@@ -14154,14 +14153,7 @@ function toSearchResults(queryVector, sources, threshold, excludePath) {
     );
     const similarity = cosineSimilarity(queryVector, source.embedding);
     if (similarity >= threshold) {
-      results.push({
-        path: source.path,
-        similarity,
-        blocks: source.blocks.slice(0, MAX_BLOCKS_PER_RESULT).map(({ heading, lines }) => ({
-          heading,
-          lines
-        }))
-      });
+      results.push({ path: source.path, similarity });
     }
   }
   results.sort(compareSearchResults);
@@ -14177,6 +14169,41 @@ function findNeighbors({
   const results = toSearchResults(queryVector, sources, threshold, excludePath);
   return typeof limit === "number" ? results.slice(0, limit) : results;
 }
+function compareBlockSearchResults(left, right) {
+  return right.similarity - left.similarity || compareStrings(left.path, right.path);
+}
+function findBlockNeighbors({
+  queryVector,
+  sources,
+  threshold,
+  limit
+}) {
+  const results = [];
+  for (const source of sources) {
+    for (const block of source.blocks) {
+      if (block.embedding.length === 0) {
+        continue;
+      }
+      ensureSameDimensions(
+        queryVector,
+        block.embedding,
+        "Query vector",
+        `Block vector for ${block.key}`
+      );
+      const similarity = cosineSimilarity(queryVector, block.embedding);
+      if (similarity >= threshold) {
+        results.push({
+          path: source.path,
+          heading: block.heading,
+          lines: block.lines,
+          similarity
+        });
+      }
+    }
+  }
+  results.sort(compareBlockSearchResults);
+  return typeof limit === "number" ? results.slice(0, limit) : results;
+}
 function findDuplicates({
   sources,
   threshold
@@ -14213,6 +14240,86 @@ function findDuplicates({
 
 // src/tool-handlers.ts
 import path3 from "path";
+
+// src/retrieval-policy.ts
+var FALLBACK_THRESHOLD = 0.3;
+var QUICK_BLOCK_LIMIT = 5;
+var MODE_DEFAULTS = {
+  quick: { limit: 3, threshold: 0.5, expansion: false, expansionLimit: 0 },
+  deep: { limit: 8, threshold: 0.35, expansion: true, expansionLimit: 3 }
+};
+function deduplicateResults(results) {
+  const best = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = best.get(result.path);
+    if (!existing || result.similarity > existing.similarity) {
+      best.set(result.path, result);
+    }
+  }
+  return Array.from(best.values());
+}
+async function executeRetrieval(input) {
+  const { query, mode, sources, embeddingProvider, searchEngine } = input;
+  const modeConfig = MODE_DEFAULTS[mode];
+  const threshold = input.threshold ?? modeConfig.threshold;
+  const expansion = input.expansion ?? modeConfig.expansion;
+  const expansionLimit = input.expansionLimit ?? modeConfig.expansionLimit;
+  const limit = modeConfig.limit;
+  const queryVector = await embeddingProvider.embed(query);
+  let vectorResults = searchEngine.findNeighbors({
+    queryVector,
+    sources: sources.values(),
+    threshold,
+    limit
+  });
+  if (vectorResults.length === 0 && threshold > FALLBACK_THRESHOLD) {
+    vectorResults = searchEngine.findNeighbors({
+      queryVector,
+      sources: sources.values(),
+      threshold: FALLBACK_THRESHOLD,
+      limit
+    });
+  }
+  let blockResults;
+  if (mode === "deep") {
+    blockResults = searchEngine.findBlockNeighbors({
+      queryVector,
+      sources: sources.values(),
+      threshold,
+      limit
+    });
+  } else if (vectorResults.length > 0) {
+    const matchedPaths = new Set(vectorResults.map((r) => r.path));
+    const matchedSources = [...sources.values()].filter((s) => matchedPaths.has(s.path));
+    blockResults = searchEngine.findBlockNeighbors({
+      queryVector,
+      sources: matchedSources,
+      threshold: 0,
+      limit: QUICK_BLOCK_LIMIT
+    });
+  }
+  if (expansion && vectorResults.length > 0) {
+    const topResults = vectorResults.slice(0, expansionLimit);
+    for (const topResult of topResults) {
+      const source = sources.get(topResult.path);
+      if (!source || source.embedding.length === 0) continue;
+      const expansionNeighbors = searchEngine.findNeighbors({
+        queryVector: source.embedding,
+        sources: sources.values(),
+        threshold,
+        limit
+      });
+      vectorResults = deduplicateResults([...vectorResults, ...expansionNeighbors]);
+    }
+  }
+  vectorResults = vectorResults.slice(0, limit);
+  return {
+    results: vectorResults,
+    ...blockResults !== void 0 ? { blockResults } : {}
+  };
+}
+
+// src/tool-handlers.ts
 var DEFAULT_SEARCH_LIMIT = 10;
 var DEFAULT_SEARCH_THRESHOLD = 0.5;
 var DEFAULT_DUPLICATE_THRESHOLD = 0.9;
@@ -14263,7 +14370,7 @@ function normalizeNotePath(notePath) {
 }
 function normalizeQuery(query) {
   const normalized = query.trim();
-  if (!normalized) {
+  if (normalized.length === 0) {
     throw new ToolHandlerError("INVALID_ARGUMENT", "query must not be empty", {
       details: { field: "query" }
     });
@@ -14347,25 +14454,20 @@ function createToolHandlers({
   return {
     async searchNotes(input) {
       const query = normalizeQuery(input.query);
-      const limit = readPositiveInteger(input.limit, DEFAULT_SEARCH_LIMIT, "limit");
-      const threshold = readThreshold(input.threshold, DEFAULT_SEARCH_THRESHOLD, "threshold");
-      let queryVector;
-      try {
-        queryVector = await embeddingProvider.embed(query);
-      } catch (error48) {
-        throw wrapDependencyError(error48, "Failed to embed query text", {
-          modelKey,
-          operation: "search_notes"
-        });
-      }
+      const mode = input.mode ?? "quick";
+      const threshold = input.threshold !== void 0 ? readThreshold(input.threshold, input.threshold, "threshold") : void 0;
+      const expansionLimit = input.expansion_limit !== void 0 ? readPositiveInteger(input.expansion_limit, 3, "expansion_limit") : void 0;
       try {
-        return toSearchResults2(
-          searchEngine,
-          queryVector,
-          loader.sources.values(),
+        return await executeRetrieval({
+          query,
+          mode,
           threshold,
-          limit
-        );
+          expansion: input.expansion,
+          expansionLimit,
+          sources: loader.sources,
+          embeddingProvider,
+          searchEngine
+        });
       } catch (error48) {
         throw wrapDependencyError(error48, "Failed to search notes", {
           modelKey,
@@ -14434,8 +14536,11 @@ var require2 = createRequire(import.meta.url);
 var { name: SERVER_NAME, version: SERVER_VERSION } = require2("../package.json");
 var searchNotesSchema = external_exports.object({
   query: external_exports.string(),
+  mode: external_exports.enum(["quick", "deep"]).optional(),
   limit: external_exports.number().int().positive().optional(),
-  threshold: external_exports.number().min(0).max(1).optional()
+  threshold: external_exports.number().min(0).max(1).optional(),
+  expansion: external_exports.boolean().optional(),
+  expansion_limit: external_exports.number().int().positive().optional()
 });
 var getSimilarNotesSchema = external_exports.object({
   note_path: external_exports.string(),
@@ -14445,23 +14550,26 @@ var getSimilarNotesSchema = external_exports.object({
 var findDuplicatesSchema = external_exports.object({
   threshold: external_exports.number().min(0).max(1).optional()
 });
-var SERVER_INSTRUCTIONS = `This server provides semantic search over an Obsidian vault using Smart Connections embeddings.
-
-## Search strategy
+var SERVER_INSTRUCTIONS = `Semantic search over an Obsidian vault. Use when the user's vault may contain relevant context \u2014 their notes, projects, plans, tasks, learning materials, or ideas. This includes both direct requests ("find my notes on X") and questions where vault context would improve the answer ("what's on my agenda?", "what was I working on?").
 
-Semantic search works best with short, focused queries (1-4 words). Long sentences or full questions dilute the signal and often return no results.
+## How to search
 
-When looking for information:
-1. Extract the core nouns and concepts from the user's message \u2014 strip away filler words, verbs, and context. For example, from "remind me what I wanted to build with LLM agents" the key concepts are "LLM", "agents", "build" \u2014 not the full sentence.
-2. Start with several SHORT keyword queries rather than one long phrase. Search each key concept separately and in small combinations. For example, try: "LLM", "agents", "LLM agents", "AI projects".
+### 1. Write the query
+1. Extract the core nouns and concepts from the user's message \u2014 strip filler words and verbs. From "remind me what I wanted to build with LLM agents" the key concepts are "LLM", "agents", "build".
+2. Search each concept separately and in small combinations: "LLM", "agents", "LLM agents", "AI projects".
 3. Try synonyms and reformulations \u2014 the note may use different wording than the query.
-4. The vault may contain notes in multiple languages. Try queries in each language the user speaks (e.g. both Ukrainian and English).
+4. The vault may contain notes in multiple languages. Search in the language of the user's message + English.
 5. If a search returns no results, lower the threshold to 0.3 before giving up.
-6. Once you find a relevant note, use get_similar_notes to discover related content.
 
-## Reading results
+### 2. Choose mode
+- **quick** (default) \u2014 returns up to 3 notes, no expansion. Use for specific lookups.
+- **deep** \u2014 returns up to 8 notes + expands via similar notes. Use for broad topics.
+- Pass \`expansion: true\` in quick mode if you want expansion there too.
 
-Search results include block headings and line ranges \u2014 use these as pointers to read specific sections of the matched notes rather than reading entire files.
+### 3. Use the results
+- \`results\` \u2014 notes ranked by similarity; read the file by path
+- \`blockResults\` \u2014 sections ranked by relevance; use heading + line range to jump to the relevant part
+- After finding a relevant note, call get_similar_notes to discover related content
 `;
 function defaultServerFactory() {
   return new McpServer(
@@ -14545,7 +14653,7 @@ function createNeuroVaultServer({
     "search_notes",
     {
       title: "Search Notes",
-      description: "Search notes by semantic similarity. Use short keyword queries (1-4 words), not full sentences. Make multiple calls with different keywords, synonyms, and languages to get comprehensive results. Lower the threshold (e.g. 0.3) if no results are found.",
+      description: 'Search notes by semantic similarity. Pass a short keyword query (1-4 words). Choose mode: "quick" for specific lookups (1-2 notes), "deep" for broad topic overview with block-level search and expansion. Call multiple times with different queries for synonyms or multi-language searches.',
       inputSchema: searchNotesSchema
     },
     async (args) => invokeTool(() => handlers.searchNotes(args))
@@ -14586,7 +14694,7 @@ function ensureCorpusIsUsable(corpus) {
 async function startNeuroVaultServer(config2, deps = {}) {
   const loadCorpus = deps.loadCorpus ?? loadSmartConnectionsCorpus;
   const embeddingServiceFactory = deps.embeddingServiceFactory ?? ((modelId) => new EmbeddingService({ modelKey: modelId }));
-  const searchEngine = deps.searchEngine ?? { findNeighbors, findDuplicates };
+  const searchEngine = deps.searchEngine ?? { findNeighbors, findBlockNeighbors, findDuplicates };
   const serverFactory = deps.serverFactory ?? defaultServerFactory;
   const transportFactory = deps.transportFactory ?? defaultTransportFactory;
   const corpus = await loadCorpus(config2.smartEnvPath, config2.modelKey);