@geravant/sinain 1.24.1 → 1.25.0

package/config-shared.js

@@ -531,34 +531,185 @@ async function setupLocalGateway(existing) {
   };
 }
 
-export async function stepPrivacy(existing, label = "Privacy mode") {
+/**
+ * Local mode: run everything on-device with Ollama + whisper.cpp.
+ *
+ * Returns null (skip) or { llm, vision } model names.
+ * When enabled, also checks Ollama is reachable and offers to pull models.
+ */
+export async function stepLocalMode(existing, label = "Local mode (Ollama)") {
+  const currentEnabled = existing.SINAIN_LOCAL_MODE === "true";
+  const enable = guard(await p.confirm({
+    message: `${label} — run analysis + OCR on your machine, no cloud?`,
+    initialValue: currentEnabled,
+  }));
+
+  if (!enable) return null;
+
+  // Check Ollama
+  let ollamaOk = false;
+  let availableModels = [];
+  const s = p.spinner();
+  s.start("Checking Ollama...");
+  try {
+    const res = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(3000) });
+    if (res.ok) {
+      const data = await res.json();
+      availableModels = (data.models || []).map((m) => m.name);
+      ollamaOk = true;
+      s.stop(c.green(`Ollama running (${availableModels.length} models).`));
+    } else {
+      s.stop(c.yellow("Ollama responded but returned an error."));
+    }
+  } catch {
+    s.stop(c.yellow("Ollama not reachable at localhost:11434."));
+  }
+
+  if (!ollamaOk) {
+    p.note(
+      "Install and start Ollama first:\n" +
+      "  brew install ollama && ollama serve\n" +
+      "Then re-run setup.",
+      "Ollama required",
+    );
+    const proceed = guard(await p.confirm({
+      message: "Continue anyway? (config will be saved, but won't work until Ollama runs)",
+      initialValue: false,
+    }));
+    if (!proceed) return null;
+  }
+
+  // LLM model (analysis + distillation)
+  const currentLlm = existing.SINAIN_LOCAL_LLM || "phi4-mini";
+  const llmOptions = [
+    { value: "phi4-mini", label: "phi4-mini", hint: "2.5 GB — fast, good quality (recommended)" },
+    { value: "gemma3:4b", label: "gemma3:4b", hint: "2.5 GB — Google, competitive quality" },
+    { value: "llama3.2:3b", label: "llama3.2:3b", hint: "2.0 GB — Meta, smallest" },
+  ];
+  // Add current model if it's custom and not in the list
+  if (!llmOptions.some((o) => o.value === currentLlm)) {
+    llmOptions.push({ value: currentLlm, label: currentLlm, hint: "currently configured" });
+  }
+  llmOptions.push({ value: "custom", label: "Custom", hint: "Enter any Ollama model name" });
+
+  let llm = guard(await p.select({
+    message: "LLM model (analysis + knowledge distillation)",
+    options: llmOptions,
+    initialValue: llmOptions.some((o) => o.value === currentLlm) ? currentLlm : "custom",
+  }));
+
+  if (llm === "custom") {
+    llm = guard(await p.text({
+      message: "Ollama model name for LLM",
+      placeholder: "model-name or model-name:tag",
+      validate: (val) => { if (!val) return "Model name required"; },
+    }));
+  }
+
+  // Vision model (screen OCR)
+  const currentVision = existing.SINAIN_LOCAL_VISION || "qwen2.5vl:7b";
+  const visionOptions = [
+    { value: "qwen2.5vl:7b", label: "qwen2.5vl:7b", hint: "4.7 GB — best OCR quality (recommended)" },
+    { value: "gemma4:e2b", label: "gemma4:e2b", hint: "5.2 GB — Google multimodal, new" },
+    { value: "llava:7b", label: "llava:7b", hint: "4.7 GB — general purpose vision" },
+    { value: "moondream", label: "moondream", hint: "1.7 GB — fastest, lower quality" },
+  ];
+  if (!visionOptions.some((o) => o.value === currentVision)) {
+    visionOptions.push({ value: currentVision, label: currentVision, hint: "currently configured" });
+  }
+  visionOptions.push({ value: "custom", label: "Custom", hint: "Enter any Ollama vision model" });
+
+  let vision = guard(await p.select({
+    message: "Vision model (screen OCR)",
+    options: visionOptions,
+    initialValue: visionOptions.some((o) => o.value === currentVision) ? currentVision : "custom",
+  }));
+
+  if (vision === "custom") {
+    vision = guard(await p.text({
+      message: "Ollama model name for vision",
+      placeholder: "model-name:tag",
+      validate: (val) => { if (!val) return "Model name required"; },
+    }));
+  }
+
+  // Offer to pull missing models
+  if (ollamaOk) {
+    const missing = [llm, vision].filter((m) => !availableModels.some((a) => a.startsWith(m)));
+    if (missing.length > 0) {
+      const pull = guard(await p.confirm({
+        message: `Pull missing models? (${missing.join(", ")})`,
+        initialValue: true,
+      }));
+      if (pull) {
+        for (const model of missing) {
+          const sp = p.spinner();
+          sp.start(`Pulling ${model}...`);
+          try {
+            execFileSync("ollama", ["pull", model], { stdio: "pipe", timeout: 600_000 });
+            sp.stop(c.green(`${model} pulled.`));
+          } catch {
+            sp.stop(c.yellow(`Failed to pull ${model} — pull manually: ollama pull ${model}`));
+          }
+        }
+      }
+    }
+  }
+
+  return { llm, vision };
+}
+
+export async function stepPrivacy(existing, label = "Privacy mode", { localModeEnabled = false } = {}) {
   const current = existing.PRIVACY_MODE || "standard";
-  return guard(await p.select({
+
+  const options = [
+    {
+      value: "off",
+      label: "Off",
+      hint: "No filtering — screen text, credentials, everything sent to cloud",
+    },
+    {
+      value: "standard",
+      label: "Standard",
+      hint: "Auto-redacts cards, API keys, tokens before sending to cloud",
+    },
+    {
+      value: "strict",
+      label: "Strict",
+      hint: "Only summaries leave your machine, no raw screen text or audio",
+    },
+  ];
+
+  if (localModeEnabled) {
+    options.push({
+      value: "paranoid",
+      label: "Paranoid",
+      hint: "Zero cloud calls — all processing stays on-device via Ollama + Whisper",
+    });
+  } else {
+    options.push({
+      value: "paranoid",
+      label: "Paranoid",
+      hint: c.dim("Requires local mode — enable it first"),
+    });
+  }
+
+  const choice = guard(await p.select({
     message: label,
-    options: [
-      {
-        value: "off",
-        label: "Off",
-        hint: "No filtering — screen text, credentials, everything sent to cloud",
-      },
-      {
-        value: "standard",
-        label: "Standard",
-        hint: "Auto-redacts cards, API keys, tokens before sending to cloud",
-      },
-      {
-        value: "strict",
-        label: "Strict",
-        hint: "Only summaries leave your machine, no raw screen text or audio",
-      },
-      {
-        value: "paranoid",
-        label: "Paranoid",
-        hint: "Zero cloud calls — needs Whisper + Ollama installed or nothing works",
-      },
-    ],
-    initialValue: current,
+    options,
+    initialValue: current === "paranoid" && !localModeEnabled ? "standard" : current,
   }));
+
+  if (choice === "paranoid" && !localModeEnabled) {
+    p.log.warn("Paranoid mode requires local mode (Ollama + Whisper). Enable local mode first.");
+    return guard(await p.select({
+      message: `${label} (local mode not enabled)`,
+      options: options.slice(0, 3),
+      initialValue: "standard",
+    }));
+  }
+
+  return choice;
 }
 
 export async function stepModel(existing, label = "AI model for HUD analysis") {

package/config.js

@@ -6,7 +6,7 @@
 import * as p from "@clack/prompts";
 import {
   c, guard, readEnv, writeEnv, summarizeConfig, runHealthCheck,
-  stepApiKey, stepTranscription, stepGateway, stepPrivacy, stepModel, stepAgent,
+  stepApiKey, stepTranscription, stepGateway, stepPrivacy, stepModel, stepAgent, stepLocalMode,
   ENV_PATH, IS_WINDOWS, HOME, PKG_DIR,
 } from "./config-shared.js";
 import fs from "fs";
@@ -16,6 +16,7 @@ import path from "path";
 
 const SECTIONS = [
   { value: "apikey",        label: "API Key",        hint: "OpenRouter API key" },
+  { value: "localmode",     label: "Local Mode",     hint: "Ollama + Whisper, zero cloud" },
   { value: "transcription", label: "Transcription",  hint: "Cloud or local whisper" },
   { value: "model",         label: "Model",          hint: "AI model for analysis" },
   { value: "privacy",       label: "Privacy",        hint: "Standard / strict / paranoid" },
@@ -48,9 +49,26 @@ async function runSection(section, existing) {
       const model = await stepModel(existing);
       return { AGENT_MODEL: model };
     }
+    case "localmode": {
+      const result = await stepLocalMode(existing);
+      if (result) {
+        return {
+          SINAIN_LOCAL_MODE: "true",
+          SINAIN_LOCAL_LLM: result.llm,
+          SINAIN_LOCAL_VISION: result.vision,
+        };
+      }
+      return { SINAIN_LOCAL_MODE: "" };
+    }
     case "privacy": {
-      const mode = await stepPrivacy(existing);
-      return { PRIVACY_MODE: mode };
+      const localModeEnabled = existing.SINAIN_LOCAL_MODE === "true";
+      const mode = await stepPrivacy(existing, "Privacy mode", { localModeEnabled });
+      const vars = { PRIVACY_MODE: mode };
+      if (mode === "paranoid" && localModeEnabled) {
+        vars.PRIVACY_OCR_AGENT_GATEWAY = "redacted";
+        vars.PRIVACY_AUDIO_AGENT_GATEWAY = "redacted";
+      }
+      return vars;
     }
     case "gateway": {
       return await stepGateway(existing);

package/launcher.js

@@ -106,6 +106,20 @@ async function main() {
   // Load user config
   loadUserEnv();
 
+  // Propagate unified local mode config to component-level vars
+  if (process.env.SINAIN_LOCAL_MODE === "true") {
+    const llm = process.env.SINAIN_LOCAL_LLM || "phi4-mini";
+    const vision = process.env.SINAIN_LOCAL_VISION || "qwen2.5vl:7b";
+    if (!process.env.LOCAL_VISION_ENABLED) process.env.LOCAL_VISION_ENABLED = "true";
+    if (!process.env.LOCAL_VISION_MODEL) process.env.LOCAL_VISION_MODEL = vision;
+    if (!process.env.ANALYSIS_PROVIDER) process.env.ANALYSIS_PROVIDER = "ollama";
+    if (!process.env.ANALYSIS_MODEL) process.env.ANALYSIS_MODEL = llm;
+    if (!process.env.TRANSCRIPTION_BACKEND) process.env.TRANSCRIPTION_BACKEND = "local";
+    if (!process.env.SINAIN_FAST_MODEL) process.env.SINAIN_FAST_MODEL = `ollama/${llm}`;
+    if (!process.env.SINAIN_SMART_MODEL) process.env.SINAIN_SMART_MODEL = `ollama/${llm}`;
+    log(`${MAGENTA}LOCAL MODE${RESET} — LLM: ${llm}, Vision: ${vision}`);
+  }
+
   // Ensure Ollama is running (if local vision enabled)
   if (process.env.LOCAL_VISION_ENABLED === "true") {
     await ensureOllama();
@@ -162,10 +176,11 @@ async function main() {
     color: CYAN,
   });
 
-  // Health check
-  const healthy = await healthCheck("http://localhost:9500/health", 20);
+  // Health check (local mode needs longer — cold model load + startup distillation)
+  const healthTimeout = process.env.SINAIN_LOCAL_MODE === "true" ? 45 : 20;
+  const healthy = await healthCheck("http://localhost:9500/health", healthTimeout);
   if (!healthy) {
-    fail("sinain-core did not become healthy after 20s");
+    fail(`sinain-core did not become healthy after ${healthTimeout}s`);
   }
   ok("sinain-core healthy on :9500");
 

package/onboard.js

@@ -8,8 +8,8 @@ import fs from "fs";
 import path from "path";
 import { execFileSync } from "child_process";
 import {
-  c, guard, maskKey, readEnv, writeEnv, writeAgentsConfig, summarizeConfig, runHealthCheck,
-  stepApiKey, stepTranscription, stepGateway, stepPrivacy, stepModel,
+  c, guard, cmdExists, maskKey, readEnv, writeEnv, writeAgentsConfig, summarizeConfig, runHealthCheck,
+  stepApiKey, stepTranscription, stepGateway, stepPrivacy, stepModel, stepLocalMode,
   HOME, SINAIN_DIR, ENV_PATH, PKG_DIR, IS_WINDOWS, IS_MAC,
 } from "./config-shared.js";
 import { stepMcpInstall, detectMcpAgents } from "./mcp-register.js";
@@ -130,6 +130,11 @@ export async function runOnboard(args = {}) {
         label: "QuickStart",
         hint: "Get running in 2 minutes. Configure details later.",
       },
+      {
+        value: "local",
+        label: "Local / Paranoid",
+        hint: "Fully offline — Ollama + Whisper, zero cloud calls.",
+      },
       {
         value: "advanced",
         label: "Advanced",
@@ -139,7 +144,7 @@ export async function runOnboard(args = {}) {
     initialValue: "quickstart",
   }));
 
-  const totalSteps = flow === "quickstart" ? 2 : 6;
+  const totalSteps = flow === "quickstart" ? 2 : flow === "local" ? 4 : 6;
 
   // ── Collect vars ────────────────────────────────────────────────────────
 
@@ -149,12 +154,130 @@ export async function runOnboard(args = {}) {
   // complete so we don't churn ~/.sinain/agents.json on every prompt.
   let agentsPatch = {};
 
-  // Step 1: API key (both flows)
-  const apiKey = await stepApiKey(base, `[1/${totalSteps}] OpenRouter API key`);
-  vars.OPENROUTER_API_KEY = apiKey;
-  p.log.success("API key saved.");
+  // Step 1: API key (quickstart + advanced only — local mode skips cloud)
+  if (flow !== "local") {
+    const apiKey = await stepApiKey(base, `[1/${totalSteps}] OpenRouter API key`);
+    vars.OPENROUTER_API_KEY = apiKey;
+    p.log.success("API key saved.");
+  }
+
+  if (flow === "local") {
+    // ── Local / Paranoid flow ─────────────────────────────────────────────
+    // Step 1: Local models (Ollama)
+    const localResult = await stepLocalMode(base, `[1/${totalSteps}] Local models`);
+    if (localResult) {
+      vars.SINAIN_LOCAL_MODE = "true";
+      vars.SINAIN_LOCAL_LLM = localResult.llm;
+      vars.SINAIN_LOCAL_VISION = localResult.vision;
+      p.log.success(`LLM: ${localResult.llm}, Vision: ${localResult.vision}`);
+    } else {
+      p.log.warn("Local mode cancelled — switching to QuickStart defaults.");
+      vars.TRANSCRIPTION_BACKEND = "openrouter";
+      vars.PRIVACY_MODE = "standard";
+      vars.AGENT_MODEL = "google/gemini-2.5-flash-lite";
+    }
+
+    // Step 2: Whisper setup (if local mode enabled)
+    if (vars.SINAIN_LOCAL_MODE === "true") {
+      vars.TRANSCRIPTION_BACKEND = "local";
+      const hasWhisper = !IS_WINDOWS && cmdExists("whisper-cli");
+      if (hasWhisper) {
+        p.log.success(`[2/${totalSteps}] whisper-cli found — local transcription enabled.`);
+      } else if (IS_MAC) {
+        const install = guard(await p.confirm({
+          message: `[2/${totalSteps}] whisper-cli not found. Install via Homebrew?`,
+          initialValue: true,
+        }));
+        if (install) {
+          const s = p.spinner();
+          s.start("Installing whisper-cpp...");
+          try {
+            execFileSync("brew", ["install", "whisper-cpp"], { stdio: "pipe" });
+            s.stop(c.green("whisper-cpp installed."));
+          } catch {
+            s.stop(c.yellow("Install failed — audio transcription won't work offline."));
+          }
+        }
+      }
+      // Check whisper model
+      const modelDir = path.join(HOME, "models");
+      const modelPath = path.join(modelDir, "ggml-large-v3-turbo.bin");
+      if (fs.existsSync(modelPath)) {
+        vars.LOCAL_WHISPER_MODEL = modelPath;
+        p.log.info(`Whisper model: ${c.dim(modelPath)}`);
+      } else {
+        const download = guard(await p.confirm({
+          message: "Download Whisper model (~1.5 GB)?",
+          initialValue: true,
+        }));
+        if (download) {
+          const s = p.spinner();
+          s.start("Downloading Whisper model...");
+          try {
+            fs.mkdirSync(modelDir, { recursive: true });
+            execFileSync("curl", [
+              "-L", "--progress-bar",
+              "-o", modelPath,
+              "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin",
+            ], { stdio: "inherit" });
+            s.stop(c.green("Model downloaded."));
+            vars.LOCAL_WHISPER_MODEL = modelPath;
+          } catch {
+            s.stop(c.yellow("Download failed. Run manually later."));
+          }
+        }
+      }
+
+      // Step 3: Privacy — default to paranoid since user chose local mode
+      vars.PRIVACY_MODE = "paranoid";
+      const privacy = await stepPrivacy(base, `[3/${totalSteps}] Privacy mode`, { localModeEnabled: true });
+      vars.PRIVACY_MODE = privacy;
+      p.log.success(`Privacy: ${privacy}.`);
+
+      // Privacy overrides for escalation (redacted OCR+audio in escalation)
+      if (privacy === "paranoid") {
+        vars.PRIVACY_OCR_AGENT_GATEWAY = "redacted";
+        vars.PRIVACY_AUDIO_AGENT_GATEWAY = "redacted";
+      }
+    }
+
+    // Step 4: Gateway (optional — works with local mode too)
+    const hasExistingGateway = (() => {
+      try {
+        const agentsPath = path.join(SINAIN_DIR, "agents.json");
+        if (!fs.existsSync(agentsPath)) return false;
+        const cfg = JSON.parse(fs.readFileSync(agentsPath, "utf-8"));
+        return !!cfg?.profiles?.openclaw;
+      } catch { return false; }
+    })();
+    const enableGateway = guard(await p.confirm({
+      message: `[4/${totalSteps}] Enable OpenClaw gateway? (escalation agent for deeper analysis)`,
+      initialValue: hasExistingGateway,
+    }));
+    if (enableGateway) {
+      const gatewayResult = await stepGateway(base, "OpenClaw gateway");
+      Object.assign(vars, gatewayResult.envVars);
+      Object.assign(agentsPatch, gatewayResult.agentsPatch);
+    } else {
+      agentsPatch.openclawProfile = null;
+    }
+    agentsPatch.default = base.SINAIN_AGENT || "claude";
 
-  if (flow === "quickstart") {
+    p.note(
+      [
+        `Local mode: ${vars.SINAIN_LOCAL_MODE === "true" ? c.green("enabled") : "disabled"}`,
+        vars.SINAIN_LOCAL_LLM ? `  LLM: ${vars.SINAIN_LOCAL_LLM}` : null,
+        vars.SINAIN_LOCAL_VISION ? `  Vision: ${vars.SINAIN_LOCAL_VISION}` : null,
+        `Transcription: ${vars.TRANSCRIPTION_BACKEND}`,
+        `Privacy: ${vars.PRIVACY_MODE}`,
+        `OpenClaw gateway: ${enableGateway ? "enabled" : "disabled"}`,
+        "",
+        `Start with: ./start.sh --paranoid`,
+        `Change later: sinain config`,
+      ].filter(Boolean).join("\n"),
+      "Local mode summary",
+    );
+  } else if (flow === "quickstart") {
     // QuickStart: sensible defaults + a single opt-in question for OpenClaw.
     // Gateway integration is off by default; users who want it run Advanced
     // (or answer Yes here, which then walks them through stepGateway).
@@ -267,35 +390,14 @@ export async function runOnboard(args = {}) {
       }
     }
 
-    // If Ollama is installed, offer to pull a local LLM for paranoid-mode
-    // analysis. Mirrors the whisper download pattern — auto-acquire optional,
-    // user can `ollama pull <model>` manually later if they skip here.
-    let ollamaInstalled = false;
-    try {
-      execFileSync("ollama", ["--version"], { stdio: "ignore" });
-      ollamaInstalled = true;
-    } catch { /* ollama not on PATH */ }
-
-    if (ollamaInstalled) {
-      const pullOllama = guard(await p.confirm({
-        message: "Pull an Ollama model for paranoid-mode analysis (~4.7 GB for llava)?",
-        initialValue: true,
-      }));
-      if (pullOllama) {
-        const modelName = guard(await p.text({
-          message: "Ollama model to pull",
-          placeholder: "llava",
-          defaultValue: "llava",
-        }));
-        const s = p.spinner();
-        s.start(`Pulling ${modelName} via Ollama (this can take several minutes)...`);
-        try {
-          execFileSync("ollama", ["pull", modelName], { stdio: "inherit" });
-          s.stop(c.green(`Pulled ${modelName}.`));
-        } catch {
-          s.stop(c.yellow(`Pull failed. Run \`ollama pull ${modelName}\` manually later.`));
-        }
-      }
+    // Offer local mode (Ollama) — enables paranoid privacy
+    const localResult = await stepLocalMode(base, "Local mode (Ollama)");
+    const localModeEnabled = !!localResult;
+    if (localResult) {
+      vars.SINAIN_LOCAL_MODE = "true";
+      vars.SINAIN_LOCAL_LLM = localResult.llm;
+      vars.SINAIN_LOCAL_VISION = localResult.vision;
+      p.log.success(`Local mode: LLM=${localResult.llm}, Vision=${localResult.vision}`);
     }
 
     // OpenClaw gateway is opt-in: most users run sinain in standalone mode
@@ -333,8 +435,12 @@ export async function runOnboard(args = {}) {
       p.log.info("Standalone mode (no gateway).");
     }
 
-    const privacy = await stepPrivacy(base, "[4/6] Privacy mode");
+    const privacy = await stepPrivacy(base, "[4/6] Privacy mode", { localModeEnabled });
     vars.PRIVACY_MODE = privacy;
+    if (privacy === "paranoid" && localModeEnabled) {
+      vars.PRIVACY_OCR_AGENT_GATEWAY = "redacted";
+      vars.PRIVACY_AUDIO_AGENT_GATEWAY = "redacted";
+    }
     p.log.success(`Privacy: ${privacy}.`);
 
     const model = await stepModel(base, "[5/6] AI model for HUD analysis");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "description": "Context OS — ambient intelligence for builders. Captures screen + audio, distills into a private knowledge graph, accessible from MCP, web UI, and HUD overlay.",
   "type": "module",
   "bin": {

package/sense_client/ollama_vision.py

@@ -39,7 +39,7 @@ class OllamaVision:
         self,
         model: str = "llava",
         base_url: str = "http://localhost:11434",
-        timeout: float = 10.0,
+        timeout: float = 30.0,
         max_tokens: int = 200,
     ):
         self.model = model

package/sinain-core/src/agent/analyzer.ts

@@ -366,7 +366,8 @@ async function callOllama(
 ): Promise<AgentResult> {
   const start = Date.now();
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), config.timeout);
+  // Local Ollama models need more time than cloud APIs (cold start + generation)
+  const timeout = setTimeout(() => controller.abort(), Math.max(config.timeout, 45_000));
 
   try {
     const imageB64List = (images || []).map((img) => img.data);

package/sinain-core/src/config.ts

@@ -186,6 +186,25 @@ export function loadConfig(): CoreConfig {
     gainDb: intEnv("MIC_GAIN_DB", 0),
   };
 
+  // ── Local mode: unified config ──────────────────────────────────────────
+  // SINAIN_LOCAL_MODE=true auto-derives all component config from two vars:
+  //   SINAIN_LOCAL_LLM=phi4-mini       → analyzer + distiller
+  //   SINAIN_LOCAL_VISION=qwen2.5vl:7b → sense_client (propagated via start.sh)
+  // Must run BEFORE transcriptionConfig / analysisConfig are read.
+  const localMode = boolEnv("SINAIN_LOCAL_MODE", false);
+  if (localMode) {
+    const localLlm = env("SINAIN_LOCAL_LLM", "phi4-mini");
+    const localVision = env("SINAIN_LOCAL_VISION", "qwen2.5vl:7b");
+    if (!process.env.ANALYSIS_PROVIDER) process.env.ANALYSIS_PROVIDER = "ollama";
+    if (!process.env.ANALYSIS_MODEL) process.env.ANALYSIS_MODEL = localLlm;
+    if (!process.env.ANALYSIS_VISION_MODEL) process.env.ANALYSIS_VISION_MODEL = localLlm;
+    if (!process.env.TRANSCRIPTION_BACKEND) process.env.TRANSCRIPTION_BACKEND = "local";
+    if (!process.env.LOCAL_VISION_ENABLED) process.env.LOCAL_VISION_ENABLED = "true";
+    if (!process.env.LOCAL_VISION_MODEL) process.env.LOCAL_VISION_MODEL = localVision;
+    if (!process.env.SINAIN_FAST_MODEL) process.env.SINAIN_FAST_MODEL = `ollama/${localLlm}`;
+    if (!process.env.SINAIN_SMART_MODEL) process.env.SINAIN_SMART_MODEL = `ollama/${localLlm}`;
+  }
+
   const transcriptionConfig: TranscriptionConfig = {
     backend: env("TRANSCRIPTION_BACKEND", "openrouter") as TranscriptionConfig["backend"],
     openrouterApiKey: env("OPENROUTER_API_KEY", ""),