codesearch-mcp 0.1.0-alpha → 0.2.0-alpha

package/dist/src/setup.js

@@ -33,17 +33,19 @@ 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 InfinityEmbedder_1 = require("./services/InfinityEmbedder");
+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, '..')
@@ -52,7 +54,6 @@ 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');
-const DEFAULT_INFINITY_RERANK_MODEL = 'Alibaba-NLP/gte-reranker-modernbert-base';
 function ask(rl, question) {
     return new Promise(resolve => rl.question(question, resolve));
 }
@@ -66,14 +67,15 @@ function expandHome(p) {
     return p;
 }
 const PROVIDER_DEFAULTS = {
-    'ollama': { baseURL: 'http://localhost:11434', model: constants_1.DEFAULT_EMBED_MODEL, envVar: '' },
     '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 === 'ollama' || p === 'infinity';
+    return p === 'infinity';
 }
 /**
  * Probe whether the embedding backend is already reachable, so the "start
@@ -83,24 +85,7 @@ function isLocalBackend(p) {
 async function checkEmbeddingBackend(provider, baseURL) {
     if (!isLocalBackend(provider))
         return true;
-    if (provider === 'infinity')
-        return (0, InfinityEmbedder_1.probeInfinityHealth)(baseURL);
-    // ollama — probe /api/tags
-    try {
-        const http = await Promise.resolve().then(() => __importStar(require('http')));
-        await new Promise((resolve, reject) => {
-            const req = http.get(`${baseURL.replace(/\/+$/, '')}/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')); });
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return (0, infinity_provisioning_1.probeInfinityHealth)(baseURL);
 }
 /**
  * Default answer for the "start Docker containers?" prompt: no only when both
@@ -110,15 +95,6 @@ async function checkEmbeddingBackend(provider, baseURL) {
 function dockerPromptDefault(dbReachable, embReachable) {
     return (dbReachable && embReachable) ? 'n' : 'y';
 }
-/** True when an NVIDIA GPU + `nvidia-smi` is available on this host. */
-function hasNvidiaGpu() {
-    try {
-        return (0, child_process_1.spawnSync)('nvidia-smi', ['-L'], { stdio: 'ignore' }).status === 0;
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * 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`.
@@ -160,58 +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);
-}
-/**
- * Poll Infinity's `/health` until ready. Unlike the DB/Ollama waiters this is
- * NON-fatal: on CPU the first boot downloads the model set AND runs a lengthy
- * per-model warmup (a reranker warmup batch alone can take minutes), so a
- * timeout here does not mean failure — the container is usually just still
- * warming up. Returns whether it became ready; the caller keeps going and
- * writes the (valid) config either way. Generous default (30 min) for CPU.
- */
-async function waitForInfinity(baseURL, maxWaitSec = 1800, logger, steps) {
-    const deadline = Date.now() + maxWaitSec * 1000;
-    process.stdout.write('Waiting for Infinity to be ready (first boot downloads + warms up the model set, this can take several minutes on CPU)');
-    while (Date.now() < deadline) {
-        if (await (0, InfinityEmbedder_1.probeInfinityHealth)(baseURL)) {
-            console.log(' ready.');
-            return true;
-        }
-        process.stdout.write('.');
-        await new Promise(r => setTimeout(r, 3000));
-    }
-    const reason = 'Infinity did not answer /health in time — it is likely still warming up.';
-    console.warn(`\n${reason}`);
-    console.warn(`  The container is running; check "docker logs codesearch-mcp-infinity-1" and, once /health responds, run: rag-index`);
-    logger?.warn('waitForInfinity: timeout (non-fatal)', { reason, steps: JSON.stringify(steps) });
-    return false;
-}
 async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
     try {
         const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
@@ -227,8 +151,16 @@ async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
         return false;
     }
 }
-async function startDockerContainers(opts) {
-    const { provider, ollamaHost, embBaseURL, dbPort, dbUser, dbPass, embModel, rerankModel, startDb, startBackend, logger, steps } = opts;
+/**
+ * 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');
@@ -236,72 +168,99 @@ async function startDockerContainers(opts) {
         .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');
+    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 */ }
-    const dockerFail = (reason) => {
-        console.error(reason);
-        logger?.error('startDockerContainers: docker startup failed', { reason, steps: JSON.stringify(steps) });
+    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);
-    };
-    // --- Database ---
-    if (startDb) {
-        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)
-            dockerFail('Failed to start the database container. Make sure Docker is running.');
-        await waitForDb('localhost', parseInt(dbPort), dbUser, dbPass, 'postgres', 60, logger, steps);
     }
-    // --- Embedding backend ---
-    if (!startBackend) {
-        if (isLocalBackend(provider))
-            console.log(`${provider} is already reachable — not starting a managed container.`);
-        else
-            console.log('Cloud embedding provider — no local backend to start.');
-        return;
+    await waitForDb('localhost', parseInt(dbPort), dbUser, dbPass, 'postgres', 60, logger, steps);
+}
+/**
+ * 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 (provider === 'ollama') {
-        console.log('\nStarting the Ollama container...');
-        const r = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'up', '-d', 'ollama'], { stdio: 'inherit' });
-        if (r.status !== 0)
-            dockerFail('Failed to start the Ollama container. Make sure Docker is running.');
-        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 ${embModel}`);
-            logger?.error('startDockerContainers: ollama container not found', { reason, steps: JSON.stringify(steps) });
-            process.exit(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;
+            }
         }
-        console.log(`Pulling ${embModel} model (this may take a while)...`);
-        // `-t` allocates a pseudo-TTY so `ollama pull` renders its live progress bar;
-        // only when our stdout is itself a TTY (docker refuses `-t` without one).
-        const ttyFlag = process.stdout.isTTY ? ['-t'] : [];
-        (0, child_process_1.spawnSync)('docker', ['exec', ...ttyFlag, ollamaId, 'ollama', 'pull', embModel], { stdio: 'inherit' });
         return;
     }
-    if (provider === 'infinity') {
-        // Both models are bound at boot via a ";"-separated INFINITY_MODEL_ID.
-        const modelIds = [embModel, ...(rerankModel ? [rerankModel] : [])].join(';');
-        // Only layer the GPU override when it actually exists on disk — otherwise a
-        // GPU host whose override copy failed would get `-f <missing>` → hard failure
-        // instead of the intended CPU fallback.
-        const gpu = hasNvidiaGpu() && fs.existsSync(DOCKER_GPU_OVERRIDE_DST);
-        const files = ['-f', DOCKER_COMPOSE_DST, ...(gpu ? ['-f', DOCKER_GPU_OVERRIDE_DST] : [])];
-        console.log(`\nStarting the Infinity container (${gpu ? 'GPU' : 'CPU'}) serving: ${modelIds}`);
-        // `--force-recreate` so a changed model set recreates the container (D7) —
-        // Infinity binds its models at startup and won't pick up a new set otherwise.
-        const r = (0, child_process_1.spawnSync)('docker', ['compose', ...files, 'up', '-d', '--force-recreate', 'infinity'], { stdio: 'inherit', env: { ...process.env, INFINITY_MODEL_ID: modelIds } });
-        if (r.status !== 0)
-            dockerFail('Failed to start the Infinity container. Make sure Docker is running.');
-        await waitForInfinity(embBaseURL, 1800, logger, steps);
+    // 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)}`);
     }
 }
 async function runSetup(logger) {
@@ -340,24 +299,22 @@ async function runSetup(logger) {
     } while (!workspaceInput.trim());
     const workspaceRoot = expandHome(workspaceInput.trim());
     console.log('\n--- Embedding backend ---');
-    console.log('  ollama            — local, zero-setup (default)');
-    console.log('  infinity          — local, one container serves embeddings + reranking (GPU/CPU)');
-    console.log('  openai-compatible — OpenAI cloud, or a local Infinity/TEI/vLLM server');
+    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');
-    const validProviders = ['ollama', 'infinity', 'openai-compatible', 'voyage'];
     let embProvider;
     do {
-        embProvider = (await loggedPrompt('Provider (ollama/infinity/openai-compatible/voyage)', 'ollama'));
-        if (!validProviders.includes(embProvider))
-            console.log(`  Invalid provider. Choose: ${validProviders.join(', ')}`);
-    } while (!validProviders.includes(embProvider));
+        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)`, DEFAULT_INFINITY_RERANK_MODEL)).trim();
+        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 = '';
@@ -373,8 +330,6 @@ async function runSetup(logger) {
             console.log(`  No key entered — set it later: echo '${pd.envVar}=sk-…' >> ${config_store_1.ENV_FILE}`);
         }
     }
-    // Ollama host used by the Docker helper below (only meaningful for ollama).
-    const ollamaHost = embProvider === 'ollama' ? embBaseURL : 'http://localhost:11434';
     console.log('\n--- Database ---');
     const dbHost = await loggedPrompt('DB host', 'localhost');
     const dbPort = await loggedPrompt('DB port', '5433');
@@ -398,15 +353,9 @@ async function runSetup(logger) {
     const startDockerRaw = await loggedAsk(`Start Docker containers automatically? (y/n) (${dockerDefault}): `);
     const startDocker = (startDockerRaw.trim().toLowerCase() || dockerDefault) === 'y';
     if (startDocker) {
-        await startDockerContainers({
-            provider: embProvider,
-            ollamaHost,
-            embBaseURL,
+        await prepareComposeAndStartDb({
             dbPort, dbUser, dbPass,
-            embModel,
-            rerankModel: rerankModel || undefined,
             startDb: !dbReachable,
-            startBackend: isLocalBackend(embProvider) && !embReachable,
             logger, steps,
         });
     }
@@ -469,6 +418,11 @@ async function runSetup(logger) {
     (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/docker/docker-compose.yml

@@ -12,19 +12,12 @@ services:
     volumes:
       - pgdata:/var/lib/postgresql/data
 
-  ollama:
-    image: ollama/ollama
-    ports:
-      - "11434:11434"
-    volumes:
-      - ollama_data:/root/.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"). Defaults to CPU so it starts on
-  # any host; GPU is opt-in via docker-compose.infinity-gpu.yml (see rag-setup).
-  # Behind an "infinity" profile so `docker compose up -d` (ollama path) doesn't
-  # pull this multi-GB image — it starts only when explicitly targeted.
+  # 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.
@@ -34,16 +27,13 @@ services:
     ports:
       - "7997:7997"
     environment:
-      INFINITY_MODEL_ID: ${INFINITY_MODEL_ID:-jinaai/jina-embeddings-v2-base-code}
+      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:
       - infinity_cache:/app/.cache
-    profiles:
-      - infinity
 
 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.1.0-alpha",
+  "version": "0.2.0-alpha",
   "description": "Local semantic codebase search via MCP — indexes projects into pgvector, exposes search to Claude",
   "license": "MIT",
   "keywords": [
@@ -18,9 +18,6 @@
   "engines": {
     "node": ">=18"
   },
-  "publishConfig": {
-    "tag": "alpha"
-  },
   "main": "dist/app.js",
   "bin": {
     "rag-index": "dist/app.js",
@@ -58,7 +55,6 @@
     "cli-progress": "^3.12.0",
     "drizzle-orm": "^0.45.2",
     "ignore": "^7.0.5",
-    "ollama": "^0.5.0",
     "pg": "^8.13.0",
     "pino": "^10.3.1",
     "pino-roll": "^4.0.0",

package/dist/src/services/OllamaEmbedder.d.ts

@@ -1,25 +0,0 @@
-import type { Config } from '../config';
-import type { IEmbedder, InputType } from '../interfaces';
-import type { ILogger } from '../interfaces';
-import type { EmbedderDeps } from './OpenAICompatibleEmbedder';
-export declare class OllamaEmbedder implements IEmbedder {
-    private config;
-    private logger;
-    readonly dimensions: number;
-    private client;
-    rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
-    constructor(config: Config, logger?: ILogger, deps?: EmbedderDeps);
-    embed(text: string, _inputType?: InputType): Promise<number[]>;
-    embedBatch(texts: string[], _inputType?: InputType): Promise<number[][]>;
-    listModels(): Promise<string[]>;
-    /**
-     * Pull the configured model if it is not already present locally, so a plain
-     * `rag-index` works after switching to (or back to) a local model that was
-     * never pulled — `rag-setup` is no longer the only place that fetches models.
-     * A tagless model name (`bge-m3`) matches its `:latest`/tagged install.
-     * Streams pull progress to the console: a live single-line bar on a TTY, or
-     * de-duplicated status lines otherwise.
-     */
-    ensureModelAvailable(): Promise<void>;
-    private static formatPullProgress;
-}