codesearch-mcp 0.0.18-alpha → 0.2.0-alpha

package/dist/src/setup.d.ts

@@ -1,2 +1,45 @@
+import { type EmbeddingProvider } from './constants';
+import { Config } from './config';
+import { type ProvisioningDeps } from './services/infinity-provisioning';
 import type { LoggerService } from './services/LoggerService';
+type SetupStep = {
+    q: string;
+    a: string;
+};
+/** Providers the wizard offers, in prompt order; the first is the preselected default. Exported for unit testing. */
+export declare const EMBEDDING_PROVIDER_CHOICES: readonly EmbeddingProvider[];
+/**
+ * Default answer for the "start Docker containers?" prompt: no only when both
+ * the database and the embedding backend are already reachable. Pure — exported
+ * for unit testing.
+ */
+export declare function dockerPromptDefault(dbReachable: boolean, embReachable: boolean): 'y' | 'n';
+interface DbDockerOpts {
+    dbPort: string;
+    dbUser: string;
+    dbPass: string;
+    /** Bring up the local db container (skip when a remote db is already reachable). */
+    startDb: boolean;
+    logger?: LoggerService;
+    steps?: SetupStep[];
+}
+/**
+ * Regenerate `CONFIG_DIR/docker-compose.yml` from the shipped template
+ * (carrying over an existing literal `INFINITY_MODEL_ID`, written atomically),
+ * copy the GPU override, and start the DB container when requested. Runs
+ * BEFORE the config file is written — its failure aborts setup unsaved,
+ * matching the existing "abort without saving" behavior of the DB step. Does
+ * NOT touch Infinity provisioning (moved after `writeConfigJson` — see D6a).
+ */
+export declare function prepareComposeAndStartDb(opts: DbDockerOpts): Promise<void>;
+/**
+ * Infinity provisioning (D6a) — runs AFTER the config file is written, so no
+ * outcome here can leave the config unsaved. `savedConfig` is a fresh read of
+ * the just-written file (never the process's own startup config). Exit-status
+ * rules: 0 for served / timeout (warning) / external instructions / declined
+ * Docker; 1 for any other provisioning failure — the cause is printed and the
+ * remaining setup steps (DB schema init) still run.
+ */
+export declare function provisionInfinity(savedConfig: Config, startDocker: boolean, logger?: LoggerService, deps?: ProvisioningDeps, composePathOverride?: string): Promise<void>;
 export declare function runSetup(logger?: LoggerService): Promise<void>;
+export {};

package/dist/src/setup.js

@@ -33,21 +33,27 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMBEDDING_PROVIDER_CHOICES = void 0;
+exports.dockerPromptDefault = dockerPromptDefault;
+exports.prepareComposeAndStartDb = prepareComposeAndStartDb;
+exports.provisionInfinity = provisionInfinity;
 exports.runSetup = runSetup;
 const readline = __importStar(require("readline"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
-const constants_1 = require("./constants");
 const config_store_1 = require("./config-store");
 const config_1 = require("./config");
+const infinity_provisioning_1 = require("./services/infinity-provisioning");
 const DEFAULT_LOG_DIR = path.join(config_store_1.CONFIG_DIR, 'logs');
 const _projectRoot = fs.existsSync(path.join(__dirname, '..', 'package.json'))
     ? path.join(__dirname, '..')
     : path.join(__dirname, '..', '..');
 const DOCKER_COMPOSE_SRC = path.join(_projectRoot, 'docker', 'docker-compose.yml');
 const DOCKER_COMPOSE_DST = path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
+const DOCKER_GPU_OVERRIDE_SRC = path.join(_projectRoot, 'docker', 'docker-compose.infinity-gpu.yml');
+const DOCKER_GPU_OVERRIDE_DST = path.join(config_store_1.CONFIG_DIR, 'docker-compose.infinity-gpu.yml');
 function ask(rl, question) {
     return new Promise(resolve => rl.question(question, resolve));
 }
@@ -60,6 +66,54 @@ function expandHome(p) {
         return path.join(os.homedir(), p.slice(2));
     return p;
 }
+const PROVIDER_DEFAULTS = {
+    'openai-compatible': { baseURL: 'https://api.openai.com/v1', model: 'text-embedding-3-small', envVar: 'OPENAI_API_KEY' },
+    'voyage': { baseURL: 'https://api.voyageai.com/v1', model: 'voyage-code-3', envVar: 'VOYAGE_API_KEY' },
+    'infinity': { baseURL: 'http://localhost:7997', model: 'jinaai/jina-embeddings-v2-base-code', envVar: '' },
+};
+/** Providers the wizard offers, in prompt order; the first is the preselected default. Exported for unit testing. */
+exports.EMBEDDING_PROVIDER_CHOICES = ['infinity', 'openai-compatible', 'voyage'];
+/** Providers that run a local inference backend we can probe / provision. */
+function isLocalBackend(p) {
+    return p === 'infinity';
+}
+/**
+ * Probe whether the embedding backend is already reachable, so the "start
+ * Docker?" prompt can default to no (mirrors the DB `checkRemoteDb` flow).
+ * Cloud providers have no local backend → always "reachable" (nothing to start).
+ */
+async function checkEmbeddingBackend(provider, baseURL) {
+    if (!isLocalBackend(provider))
+        return true;
+    return (0, infinity_provisioning_1.probeInfinityHealth)(baseURL);
+}
+/**
+ * Default answer for the "start Docker containers?" prompt: no only when both
+ * the database and the embedding backend are already reachable. Pure — exported
+ * for unit testing.
+ */
+function dockerPromptDefault(dbReachable, embReachable) {
+    return (dbReachable && embReachable) ? 'n' : 'y';
+}
+/**
+ * Write (or replace) a single `KEY=VALUE` line in `~/.config/codesearch-mcp/.env`,
+ * chmod 600. API keys live here — never in config.json — referenced as `env:KEY`.
+ */
+function writeEnvKey(name, value) {
+    fs.mkdirSync(config_store_1.CONFIG_DIR, { recursive: true });
+    let existing = '';
+    try {
+        existing = fs.readFileSync(config_store_1.ENV_FILE, 'utf-8');
+    }
+    catch { /* absent */ }
+    const kept = existing.split(/\r?\n/).filter(l => l.trim() && !l.trim().startsWith(`${name}=`));
+    kept.push(`${name}=${value}`);
+    fs.writeFileSync(config_store_1.ENV_FILE, kept.join('\n') + '\n', { mode: 0o600 });
+    try {
+        fs.chmodSync(config_store_1.ENV_FILE, 0o600);
+    }
+    catch { /* best effort */ }
+}
 async function waitForDb(host, port, user, pass, db, maxWaitSec = 60, logger, steps) {
     const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
     const deadline = Date.now() + maxWaitSec * 1000;
@@ -82,33 +136,6 @@ async function waitForDb(host, port, user, pass, db, maxWaitSec = 60, logger, st
     logger?.error('waitForDb: timeout', { reason, steps: JSON.stringify(steps) });
     process.exit(1);
 }
-async function waitForOllama(host, maxWaitSec = 60, logger, steps) {
-    const deadline = Date.now() + maxWaitSec * 1000;
-    process.stdout.write('Waiting for Ollama to be ready');
-    while (Date.now() < deadline) {
-        try {
-            const http = await Promise.resolve().then(() => __importStar(require('http')));
-            await new Promise((resolve, reject) => {
-                const req = http.get(`${host}/api/tags`, res => {
-                    res.resume();
-                    res.statusCode === 200 ? resolve() : reject(new Error(`status ${res.statusCode}`));
-                });
-                req.on('error', reject);
-                req.setTimeout(2000, () => { req.destroy(); reject(new Error('timeout')); });
-            });
-            console.log(' ready.');
-            return;
-        }
-        catch {
-            process.stdout.write('.');
-            await new Promise(r => setTimeout(r, 2000));
-        }
-    }
-    const reason = 'Ollama did not become ready in time.';
-    console.error(`\n${reason}`);
-    logger?.error('waitForOllama: timeout', { reason, steps: JSON.stringify(steps) });
-    process.exit(1);
-}
 async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
     try {
         const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
@@ -124,7 +151,16 @@ async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
         return false;
     }
 }
-async function startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger, steps) {
+/**
+ * Regenerate `CONFIG_DIR/docker-compose.yml` from the shipped template
+ * (carrying over an existing literal `INFINITY_MODEL_ID`, written atomically),
+ * copy the GPU override, and start the DB container when requested. Runs
+ * BEFORE the config file is written — its failure aborts setup unsaved,
+ * matching the existing "abort without saving" behavior of the DB step. Does
+ * NOT touch Infinity provisioning (moved after `writeConfigJson` — see D6a).
+ */
+async function prepareComposeAndStartDb(opts) {
+    const { dbPort, dbUser, dbPass, startDb, logger, steps } = opts;
     console.log('\nWriting docker-compose.yml to', DOCKER_COMPOSE_DST);
     const yamlQuote = (s) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
     let composeContent = fs.readFileSync(DOCKER_COMPOSE_SRC, 'utf-8');
@@ -132,35 +168,106 @@ async function startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger,
         .replace('POSTGRES_USER: dev', `POSTGRES_USER: ${yamlQuote(dbUser)}`)
         .replace('POSTGRES_PASSWORD: dev', `POSTGRES_PASSWORD: ${yamlQuote(dbPass)}`)
         .replace('"5433:5432"', `"${dbPort}:5432"`);
+    // Carry over an existing literal INFINITY_MODEL_ID — never the set of the
+    // config still being entered — so a setup that aborts before the config is
+    // written leaves a file consistent with the previously saved config.
+    let existingModelId = null;
+    try {
+        existingModelId = (0, infinity_provisioning_1.extractModelIdValue)(fs.readFileSync(DOCKER_COMPOSE_DST, 'utf-8'));
+    }
+    catch { /* no prior file */ }
+    if (existingModelId) {
+        composeContent = composeContent.replace(/INFINITY_MODEL_ID:\s*"[^"]*"/, `INFINITY_MODEL_ID: "${existingModelId}"`);
+    }
     fs.mkdirSync(config_store_1.CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(DOCKER_COMPOSE_DST, composeContent, 'utf-8');
-    console.log('\nStarting Docker containers...');
-    const upResult = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'up', '-d'], { stdio: 'inherit' });
-    if (upResult.status !== 0) {
-        const reason = 'Failed to start Docker containers. Make sure Docker is running.';
-        console.error(reason);
-        logger?.error('startDockerContainers: docker startup failed', { reason, steps: JSON.stringify(steps) });
+    let existingMode = 0o600;
+    try {
+        existingMode = fs.statSync(DOCKER_COMPOSE_DST).mode;
+    }
+    catch { /* first-ever write */ }
+    (0, infinity_provisioning_1.atomicWriteFile)(DOCKER_COMPOSE_DST, composeContent, existingMode);
+    // The GPU override is copied verbatim so the managed Infinity path can layer it.
+    try {
+        fs.copyFileSync(DOCKER_GPU_OVERRIDE_SRC, DOCKER_GPU_OVERRIDE_DST);
+    }
+    catch { /* absent → CPU only */ }
+    if (!startDb)
+        return;
+    console.log('\nStarting the database container...');
+    const r = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'up', '-d', 'db'], { stdio: 'inherit' });
+    if (r.status !== 0) {
+        console.error('Failed to start the database container. Make sure Docker is running.');
+        logger?.error('prepareComposeAndStartDb: docker startup failed', { steps: JSON.stringify(steps) });
         process.exit(1);
     }
     await waitForDb('localhost', parseInt(dbPort), dbUser, dbPass, 'postgres', 60, logger, steps);
-    await waitForOllama(ollamaHost, 60, logger, steps);
-    const ollamaId = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'ps', '-q', 'ollama'], { encoding: 'utf-8' })
-        .stdout?.trim();
-    if (!ollamaId) {
-        const reason = 'Could not resolve ollama container ID from compose. Pull the model manually:';
-        console.error(reason);
-        console.error(`  docker exec <ollama-container> ollama pull ${constants_1.DEFAULT_EMBED_MODEL}`);
-        logger?.error('startDockerContainers: ollama container not found', { reason, steps: JSON.stringify(steps) });
-        process.exit(1);
+}
+/**
+ * Infinity provisioning (D6a) — runs AFTER the config file is written, so no
+ * outcome here can leave the config unsaved. `savedConfig` is a fresh read of
+ * the just-written file (never the process's own startup config). Exit-status
+ * rules: 0 for served / timeout (warning) / external instructions / declined
+ * Docker; 1 for any other provisioning failure — the cause is printed and the
+ * remaining setup steps (DB schema init) still run.
+ */
+async function provisionInfinity(savedConfig, startDocker, logger, deps = {}, composePathOverride) {
+    const composePath = composePathOverride ?? DOCKER_COMPOSE_DST;
+    const baseURL = savedConfig.embedding.baseURL;
+    const base = (0, infinity_provisioning_1.serverRoot)(baseURL);
+    const set = (0, infinity_provisioning_1.requiredModelSet)(savedConfig);
+    const managed = (0, infinity_provisioning_1.isManagedInfinity)(baseURL, composePath);
+    // Targeted write happens for a managed backend regardless of what follows
+    // (yes/no, served/missing), so the compose file always matches the saved
+    // config — even when the running container already serves the set.
+    if (managed) {
+        try {
+            (0, infinity_provisioning_1.writeComposeModelSet)(composePath, set);
+        }
+        catch (err) {
+            console.error(`\nFailed to write the managed compose file: ${err.message}`);
+            logger?.error('provisionInfinity: compose write failed', { reason: err.message });
+            process.exitCode = 1;
+        }
+    }
+    if (startDocker) {
+        try {
+            await (0, infinity_provisioning_1.ensureModelSetServed)(baseURL, composePath, set, deps);
+            console.log(`\nInfinity is serving the configured model set: ${set.join(';')}`);
+        }
+        catch (err) {
+            const msg = err.message;
+            if (/did not become ready within/.test(msg)) {
+                console.warn(`\nWarning: ${msg}`);
+                console.warn('The container is running and likely still warming up. Check again once /health responds, then run: rag-index');
+                logger?.warn('provisionInfinity: readiness timeout (non-fatal)', { reason: msg });
+            }
+            else {
+                console.error(`\nInfinity provisioning failed: ${msg}`);
+                logger?.error('provisionInfinity: failed', { reason: msg });
+                process.exitCode = 1;
+            }
+        }
+        return;
+    }
+    // Docker declined — no Docker command; print what would apply the set.
+    const evaluation = await (0, infinity_provisioning_1.evaluateBackend)(baseURL, composePath, set, deps);
+    if (evaluation.action === 'served')
+        return;
+    if (evaluation.managed) {
+        const files = (0, infinity_provisioning_1.composeFileArgs)(composePath);
+        console.log(`\nInfinity does not yet serve the required model set (${set.join(';')}).`);
+        console.log('Run this to apply it:');
+        console.log(`  docker compose ${files.join(' ')} up -d --force-recreate infinity`);
+    }
+    else {
+        console.log(`\n${(0, infinity_provisioning_1.manualInstructionMessage)(evaluation, base, set)}`);
     }
-    console.log(`Pulling ${constants_1.DEFAULT_EMBED_MODEL} model (this may take a while)...`);
-    (0, child_process_1.spawnSync)('docker', ['exec', ollamaId, 'ollama', 'pull', constants_1.DEFAULT_EMBED_MODEL], { stdio: 'inherit' });
 }
 async function runSetup(logger) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const steps = [];
     function logStep(q, raw) {
-        const a = /password/i.test(q) ? '***' : raw.trim();
+        const a = /password|key|secret|token/i.test(q) ? '***' : raw.trim();
         logger?.debug('setup: prompt', { q, a });
         steps.push({ q, a });
     }
@@ -191,23 +298,68 @@ async function runSetup(logger) {
             console.log('  Path is required.');
     } while (!workspaceInput.trim());
     const workspaceRoot = expandHome(workspaceInput.trim());
-    const ollamaHost = await loggedPrompt('Ollama API URL', 'http://localhost:11434');
+    console.log('\n--- Embedding backend ---');
+    console.log('  infinity          — local, one container serves embeddings + reranking (GPU/CPU) (default)');
+    console.log('  openai-compatible — OpenAI cloud, or a local Infinity/TEI/vLLM/Ollama (via its /v1 endpoint) server');
+    console.log('  voyage            — Voyage AI cloud');
+    let embProvider;
+    do {
+        embProvider = (await loggedPrompt('Provider (infinity/openai-compatible/voyage)', exports.EMBEDDING_PROVIDER_CHOICES[0]));
+        if (!exports.EMBEDDING_PROVIDER_CHOICES.includes(embProvider))
+            console.log(`  Invalid provider. Choose: ${exports.EMBEDDING_PROVIDER_CHOICES.join(', ')}`);
+    } while (!exports.EMBEDDING_PROVIDER_CHOICES.includes(embProvider));
+    const pd = PROVIDER_DEFAULTS[embProvider];
+    const embBaseURL = await loggedPrompt('Base URL', pd.baseURL);
+    const embModel = await loggedPrompt('Embedding model', pd.model);
+    // Infinity serves a reranker from the same container — offer to provision one.
+    let rerankModel = '';
+    if (embProvider === 'infinity') {
+        rerankModel = (await loggedPrompt(`Reranker model (served by the same Infinity container; blank to disable)`, config_store_1.CONFIG_DEFAULTS['reranker.model'])).trim();
+    }
+    // API keys go into .env (chmod 600); config.json only stores the env: reference.
+    let apiKeyRef = '';
+    if (!isLocalBackend(embProvider)) {
+        const key = (await loggedAsk(`API key (stored in ${config_store_1.ENV_FILE}, leave blank to set later): `)).trim();
+        if (key) {
+            writeEnvKey(pd.envVar, key);
+            apiKeyRef = `env:${pd.envVar}`;
+            console.log(`  Saved API key to ${config_store_1.ENV_FILE} as ${pd.envVar} (config references env:${pd.envVar}).`);
+        }
+        else {
+            apiKeyRef = `env:${pd.envVar}`;
+            console.log(`  No key entered — set it later: echo '${pd.envVar}=sk-…' >> ${config_store_1.ENV_FILE}`);
+        }
+    }
     console.log('\n--- Database ---');
     const dbHost = await loggedPrompt('DB host', 'localhost');
     const dbPort = await loggedPrompt('DB port', '5433');
     const dbUser = await loggedPrompt('DB user', 'dev');
     const dbPass = await loggedPrompt('DB password', 'dev');
     process.stdout.write('\nTesting connection...');
-    const alreadyConnected = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
-    if (alreadyConnected)
+    const dbReachable = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
+    if (dbReachable)
         console.log('  Database is already reachable.');
-    const dockerDefault = alreadyConnected ? 'n' : 'y';
+    // Symmetric to the DB probe: a reachable embedding backend defaults "start
+    // Docker?" to no. Cloud providers have no local backend to start.
+    process.stdout.write('Checking embedding backend...');
+    const embReachable = await checkEmbeddingBackend(embProvider, embBaseURL);
+    if (isLocalBackend(embProvider)) {
+        console.log(embReachable ? `  ${embProvider} is already reachable.` : `  ${embProvider} is not reachable — it can be started via Docker.`);
+    }
+    else {
+        console.log('  cloud provider (no local backend to start).');
+    }
+    const dockerDefault = dockerPromptDefault(dbReachable, embReachable);
     const startDockerRaw = await loggedAsk(`Start Docker containers automatically? (y/n) (${dockerDefault}): `);
     const startDocker = (startDockerRaw.trim().toLowerCase() || dockerDefault) === 'y';
     if (startDocker) {
-        await startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger, steps);
+        await prepareComposeAndStartDb({
+            dbPort, dbUser, dbPass,
+            startDb: !dbReachable,
+            logger, steps,
+        });
     }
-    else if (!alreadyConnected) {
+    else if (!dbReachable) {
         while (true) {
             console.log('\nTesting connection...');
             const ok = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
@@ -242,15 +394,35 @@ async function runSetup(logger) {
             user: dbVars.user,
             password: dbVars.password,
         },
-        ollama: { host: ollamaHost },
+        embedding: {
+            provider: embProvider,
+            baseURL: embBaseURL,
+            model: embModel,
+            ...(apiKeyRef ? { apiKey: apiKeyRef } : {}),
+        },
         logging: { level: logLevel },
         workspaceRoot,
     };
+    // Infinity serves the reranker from the same container — auto-wire reranker.*
+    // to that server. `url` derives from provider + baseURL in the Config constructor.
+    if (embProvider === 'infinity' && rerankModel) {
+        cfg.reranker = {
+            enabled: true,
+            provider: 'openai-compatible',
+            baseURL: embBaseURL,
+            model: rerankModel,
+        };
+    }
     if (logDir)
         cfg.logging.dir = logDir;
     (0, config_store_1.writeConfigJson)(cfg);
     console.log(`\nConfig saved to ${config_store_1.CONFIG_FILE}`);
     rl.close();
+    // Infinity provisioning happens only now — after the config is safely on
+    // disk — so a provisioning failure never leaves the wizard's answers unsaved.
+    if (embProvider === 'infinity') {
+        await provisionInfinity(new config_1.Config(), startDocker, logger);
+    }
     console.log('\nInitializing database schema...');
     const { DatabaseService } = await Promise.resolve().then(() => __importStar(require('./services/DatabaseService')));
     const dbService = new DatabaseService(new config_1.Config());

package/dist/src/tools/SearchCodebaseTool.js

@@ -18,7 +18,7 @@ class SearchCodebaseTool {
     definition() {
         return {
             name: 'search_codebase',
-            description: 'Search local project codebase by semantic similarity',
+            description: 'Search local project codebase by semantic similarity. Each result shows File, Project, an optional Symbol breadcrumb (owning declaration, e.g. `IndexerService.ingestFile`), Line, the code, and Relevance.',
             inputSchema: {
                 type: 'object',
                 properties: {

package/dist/src/tools/format-helpers.js

@@ -13,7 +13,8 @@ function errorResponse(text) {
     return { isError: true, content: [{ type: 'text', text }] };
 }
 function formatChunk(r, label) {
-    return `${label ? `*(${label})*\n` : ''}**File:** ${r.filePath}\n**Project:** ${r.serviceName}\n**Line:** ${r.startLine}\n\`\`\`\n${r.content}\n\`\`\``;
+    const symbolLine = r.ownerPath ? `**Symbol:** ${r.ownerPath}\n` : '';
+    return `${label ? `*(${label})*\n` : ''}**File:** ${r.filePath}\n**Project:** ${r.serviceName}\n${symbolLine}**Line:** ${r.startLine}\n\`\`\`\n${r.content}\n\`\`\``;
 }
 function formatGraphContext(ctx) {
     const parts = [];

package/dist/src/web/dashboard.js

@@ -176,7 +176,9 @@ function renderDashboardHtml() {
     const isNum = spec.type === 'number' || spec.type === 'integer';
     inp.dataset.key = key;
     inp.dataset.type = isNum ? 'number' : 'string';
+    const isEnvRef = typeof value === 'string' && value.startsWith('env:');
     if (key === 'db.password') inp.type = 'password';
+    else if (key.endsWith('.apiKey')) inp.type = isEnvRef ? 'text' : 'password';
     else if (isNum) {
       inp.type = 'number';
       // Only apply small, meaningful bounds (skip zod's safe-integer noise).
@@ -197,6 +199,9 @@ function renderDashboardHtml() {
     const label = document.createElement('label');
     let html = key.split('.').pop();
     if (spec.description) html += '<span class="desc">' + spec.description + '</span>';
+    if (key.endsWith('.apiKey') && typeof value === 'string' && value.startsWith('env:')) {
+      html += '<span class="defval using">✔ set via ' + value.slice(4) + '</span>';
+    }
     if (def !== undefined) {
       html += '<span class="defval' + (isUnset ? ' using' : '') + '">'
         + (isUnset ? '↪ using default: ' : 'default: ') + fmtDefault(def) + '</span>';

package/docker/docker-compose.infinity-gpu.yml

@@ -0,0 +1,19 @@
+# GPU override for the Infinity service. Layered on top of docker-compose.yml
+# (docker compose -f docker-compose.yml -f docker-compose.infinity-gpu.yml …)
+# only when an NVIDIA GPU + container runtime is detected. Kept separate because
+# a `deploy.reservations.devices` GPU request aborts startup on GPU-less hosts;
+# the base file therefore stays CPU-only and always starts.
+services:
+  infinity:
+    # Warmup is cheap on GPU (seconds) — re-enable it so the first real request
+    # is already fast. On CPU (base file only) it stays off.
+    environment:
+      INFINITY_MODEL_WARMUP: "true"
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities:
+                - gpu

package/docker/docker-compose.yml

@@ -12,13 +12,28 @@ services:
     volumes:
       - pgdata:/var/lib/postgresql/data
 
-  ollama:
-    image: ollama/ollama
+  # One Infinity container serves both /embeddings and /rerank. The model set is
+  # bound at startup via INFINITY_MODEL_ID (";"-separated for multiple models,
+  # e.g. "BAAI/bge-m3;BAAI/bge-reranker-v2-m3") and rewritten in place by the app
+  # (a literal, not an env interpolation) so a plain `docker compose up -d`
+  # always serves the configured set. Defaults to CPU so it starts on any host;
+  # GPU is opt-in via docker-compose.infinity-gpu.yml (see rag-setup).
+  # Model warmup defaults OFF here: on CPU it runs multi-minute benchmark
+  # batches at every boot (a pure perf measurement, not required to serve). The
+  # GPU override turns it back on, where it costs seconds.
+  infinity:
+    image: michaelf34/infinity:latest
+    restart: unless-stopped
     ports:
-      - "11434:11434"
+      - "7997:7997"
+    environment:
+      INFINITY_MODEL_ID: "jinaai/jina-embeddings-v2-base-code;mixedbread-ai/mxbai-rerank-xsmall-v1"
+      INFINITY_MODEL_WARMUP: ${INFINITY_MODEL_WARMUP:-false}
+      INFINITY_PORT: "7997"
+    command: ["v2"]
     volumes:
-      - ollama_data:/root/.ollama
+      - infinity_cache:/app/.cache
 
 volumes:
   pgdata:
-  ollama_data:
+  infinity_cache:

package/docs/web-dashboard.md

@@ -49,7 +49,7 @@ can only reach the dashboard while the process is alive.
   `rag-config edit` (CLI) instead.
 - A failed **DB** connection is non-fatal: the config editor still works; the
   Projects and Graph tabs show an in-page error.
-- A failed **Ollama** connection only affects model suggestions (see
+- A failed **embedding backend** connection only affects model suggestions (see
   *Field options*); everything else works.
 
 ---
@@ -105,16 +105,15 @@ Some settings have a constrained set of valid values, so the form offers a list
 rather than free text. `GET /api/field-options` returns
 `{ [dottedKey]: { values: string[], strict: boolean } }`:
 
-- **`ollama.model` — strict.** The embedding model is tied to the vector column
-  dimension (`bge-m3` → 1024). Values come from `SUPPORTED_EMBED_MODELS`
-  (`src/constants.ts`); the dropdown does **not** allow free text, so a
-  dimension-incompatible model cannot be set. To add a model, confirm its
-  dimension matches and append it to `SUPPORTED_EMBED_MODELS`.
-- **`search.translateModel`, `reranker.model` — non-strict.** Suggestions are the
-  user's installed Ollama models (`ollama.list()`), but free text is allowed
-  because these are not dimension-bound and the user may pull a new model later.
-  If Ollama is unreachable the list is empty and the field degrades to plain
-  text.
+- **`embedding.model`, `reranker.model` — non-strict.** `embedding.model`
+  suggests `MODEL_REGISTRY` (`src/constants.ts`) entries plus any model the
+  backend currently serves; `reranker.model` suggests only served models. Both
+  allow free text — a model outside the registry still works (its dimension is
+  probed at index time). Served models come from `IEmbedder.listModels()`,
+  implemented only by `InfinityEmbedder` (2-second-limited `/models` listing);
+  if the backend is unreachable, or the provider doesn't implement `listModels`
+  (`openai-compatible`, `voyage`), the served-model list is empty and the field
+  degrades to registry suggestions only (or plain text for `reranker.model`).
 
 A strict `<select>` preserves an unknown current value as an extra option, so
 saving never silently drops a value that isn't in the list.
@@ -132,19 +131,39 @@ All routes are served from `127.0.0.1:<port>`.
 | `GET`  | `/api/defaults` | `CONFIG_DEFAULTS` — dotted key → default value |
 | `GET`  | `/api/field-options` | dotted key → `{ values, strict }` |
 | `GET`  | `/api/config` | Current config, `db.password` masked |
-| `PUT`  | `/api/config` | Save. Body = config JSON. `200 {ok:true}` or `400 {error}` |
+| `PUT`  | `/api/config` | Save. Body = config JSON. `200 {ok:true, backend:{action,message}}` or `400 {error}`. For `embedding.provider: infinity`, `backend.action` reports whether the Infinity container needed a background recreate (`started`/`already-running`/`not-needed`/`manual-required`/`failed`) — see *Infinity backend recreate* below |
+| `GET`  | `/api/backend-status` | `{ state, message, startedAt, finishedAt }` — progress of the most recent background Infinity recreate this server process started |
 | `GET`  | `/api/projects` | `SearcherService.listProjects()` |
 | `GET`  | `/api/graph` | `{ nodes, edges }` JSON (`buildGraphData()`) |
 | `GET`  | `/graph` | Full interactive graph page (`buildHtml()`), embedded by the Graph tab's iframe |
 
 ---
 
+## Infinity backend recreate
+
+When a save's `embedding.provider` is `infinity`, the server computes the
+required model set from the **saved** config (freshly re-read from disk, not
+the embedder the process started with) and compares it against what the
+backend currently serves. If a managed container needs to be started or
+recreated to serve the new set, that runs as an in-process background task —
+the `PUT` responds immediately (`action: "started"`) without waiting for it.
+Poll `GET /api/backend-status` for progress (`state: "recreating"` →
+`"ready"`/`"failed"`). Only one `docker compose` run is active at a time; a
+save that arrives while a recreate is already in flight for a managed backend
+responds `already-running`, and at most one follow-up run applies the latest
+such save once the in-flight one finishes. An external (unmanaged) backend
+missing a required model never triggers Docker — the response's `message`
+carries manual `--model-id`/launch instructions instead.
+
+---
+
 ## Architecture
 
 | File | Responsibility |
 |---|---|
 | `src/commands/WebCommand.ts` | CLI entry. `db.initDb()`, starts the server, keeps `execute()` pending until `SIGINT`/`SIGTERM` (mirrors `McpCommand`), then `server.stop()`. Parses `--port` (default `4319`). |
-| `src/services/WebServerService.ts` | `WebServer(searcher, config, logger)` — `node:http` server, routing, and the API handlers. Exports the pure `mergeConfigForSave()` and the `FieldOption` type. |
+| `src/services/WebServerService.ts` | `WebServer(searcher, config, logger, embedder, deps?)` — `node:http` server, routing, the API handlers, and the background Infinity recreate + `/api/backend-status` state. Exports the pure `mergeConfigForSave()` and the `FieldOption` type. |
+| `src/services/infinity-provisioning.ts` | The readiness/recreate primitive the background task delegates to (shared with `InfinityEmbedder` and `rag-setup`) — classification, compose-file rewrite, `docker compose` invocation, readiness polling. |
 | `src/web/dashboard.ts` | `renderDashboardHtml()` — the entire page (HTML + CSS + JS) as one self-contained string, mirroring `graph.ts:buildHtml`. |
 
 Reused primitives (no duplication):
@@ -153,7 +172,8 @@ Reused primitives (no duplication):
   `CONFIG_DEFAULTS` — `src/config-store.ts`
 - `buildGraphData` — `src/graph.ts`
 - `listProjects` — `src/services/SearcherService.ts`
-- `SUPPORTED_EMBED_MODELS` — `src/constants.ts`
+- `MODEL_REGISTRY` — `src/constants.ts`
+- `evaluateBackend` / `ensureModelSetServed` / `requiredModelSet` — `src/services/infinity-provisioning.ts`
 
 Wiring: `app.ts` detects the `web` mode and dispatches
 `new WebCommand(container, effectiveArgs)`. The command uses the shared
@@ -182,6 +202,5 @@ changes were needed.
   `.default(...)` calls, so the runtime default and the dashboard-displayed
   default cannot diverge — no manual sync needed. (A unit test still asserts
   every key is a valid config key.)
-- `SUPPORTED_EMBED_MODELS` (`constants.ts`) must contain only models whose
-  embedding dimension matches the `vector(...)` column — this one is still a
-  manual invariant, guarded only at the membership level by a unit test.
+- `MODEL_REGISTRY` (`constants.ts`) is advisory, not exhaustive — a model
+  outside it still works via the runtime dimension probe at index time.