@gmickel/gno 0.37.0 → 0.38.0

package/README.md

@@ -85,45 +85,15 @@ gno daemon
 
 ---
 
-## What's New in v0.29
+## What's New
 
-- **GNO Desktop Beta**: first mac-first desktop beta shell with deep-link routing, singleton handoff, and the same onboarding/search/edit flows as `gno serve`
-- **Desktop Onboarding Polish**: guided setup now covers folders, presets, model readiness, indexing, connectors, import preview, app tabs, file actions, and recovery without drift between web and desktop
-- **Default Preset Upgrade**: `slim-tuned` is now the built-in default, using the fine-tuned retrieval expansion model while keeping the same embed, rerank, and answer stack as `slim`
-- **Workspace UI Polish**: richer scholarly-dusk presentation across dashboard, tabs, search, ask, footer, and global styling without introducing external font or asset dependencies
+> Latest release: [v0.37.0](./CHANGELOG.md#0370---2026-04-06)  
+> Full release history: [CHANGELOG.md](./CHANGELOG.md)
 
-## What's New in v0.30
-
-- **Headless Daemon Mode**: `gno daemon` keeps your index fresh continuously without opening the Web UI
-- **CLI Concurrency Hardening**: read-only commands no longer trip transient `database is locked` errors when they overlap with `gno update`
-- **Web/Desktop UI Polish**: sharper workspace styling across dashboard, tabs, search, ask, and footer surfaces
-
-## What's New in v0.31
-
-- **Windows Desktop Beta Artifact**: release flow now includes a packaged `windows-x64` desktop beta zip, not just source-level support claims
-- **Packaged Runtime Proof**: Windows desktop packaging validates bundled Bun + staged GNO runtime + FTS5 + vendored snowball + `sqlite-vec`
-- **Scoped Index Fix**: `gno index <collection>` now embeds only that collection instead of accidentally burning through unrelated backlog from other collections
-- **CLI Reporting Fix**: long embed runs now report sane durations instead of bogus sub-second summaries
-
-### v0.24
-
-- **Structured Query Documents**: first-class multi-line query syntax using `term:`, `intent:`, and `hyde:`
-- **Cross-Surface Rollout**: works across CLI, API, MCP, SDK, and Web Search/Ask
-- **Portable Retrieval Prompts**: save/share advanced retrieval intent as one text payload instead of repeated flags or JSON arrays
-
-### v0.23
-
-- **SDK / Library Mode**: package-root importable SDK with `createGnoClient(...)` for direct retrieval, document access, and indexing flows
-- **Inline Config Support**: embed GNO in another app without writing YAML config files
-- **Programmatic Indexing**: call `update`, `embed`, and `index` directly from Bun/TypeScript
-- **Docs & Website**: dedicated SDK guide, feature page, homepage section, and architecture docs
-
-### v0.22
-
-- **Promoted Slim Retrieval Model**: published `slim-retrieval-v1` on Hugging Face for direct `hf:` installation in GNO
-- **Fine-Tuning Workflow**: local MLX LoRA training, portable GGUF export, automatic checkpoint selection, promotion bundles, and repeatable benchmark comparisons
-- **Autonomous Search Harness**: bounded candidate search with early-stop guards, repeated incumbent confirmation, and promotion targets
-- **Public Docs & Site**: fine-tuned model docs and feature pages now point at the published HF model and the `slim-tuned` preset
+- **Retrieval Quality Upgrade**: stronger BM25 lexical handling, code-aware chunking, terminal result hyperlinks, and per-collection model overrides
+- **Code Embedding Benchmarks**: new benchmark workflow across canonical, real-GNO, and pinned OSS slices for comparing alternate embedding models
+- **Recommended Code Embed Model**: docs and benchmark pages now point to `Qwen3-Embedding-0.6B-GGUF` as the current code-specialist embedding option
+- **Regression Fixes**: tightened phrase/negation/hyphen/underscore BM25 behavior, cleaned non-TTY hyperlink output, improved `gno doctor` chunking visibility, and fixed the embedding autoresearch harness
 
 ### Fine-Tuned Model Quick Use
 
@@ -150,58 +120,6 @@ gno query "ECONNREFUSED 127.0.0.1:5432" --thorough
 
 > Full guide: [Fine-Tuned Models](https://gno.sh/docs/FINE-TUNED-MODELS/) · [Feature page](https://gno.sh/features/fine-tuned-models/)
 
-## What's New in v0.21
-
-- **Ask CLI Query Modes**: `gno ask` now accepts repeatable `--query-mode term|intent|hyde` entries, matching the existing Ask API and Web controls
-
-### v0.20
-
-- **Improved Model Init Fallbacks**: upgraded `node-llama-cpp` to `3.17.1` and switched to `build: "autoAttempt"` for better backend selection/fallback behavior
-
-### v0.19
-
-- **Exclusion Filters**: explicit `exclude` controls across CLI, API, Web, and MCP to hard-prune unwanted docs by title/path/body text
-- **Ask Query-Mode Parity**: Ask now supports structured `term` / `intent` / `hyde` controls in both API and Web UI
-
-### v0.18
-
-- **Intent Steering**: optional `intent` control for ambiguous queries across CLI, API, Web, and MCP query flows
-- **Rerank Controls**: `candidateLimit` lets you tune rerank cost vs. recall on slower or memory-constrained machines
-- **Stability**: query expansion now uses a bounded configurable context size (`models.expandContextSize`, default `2048`)
-- **Rerank Efficiency**: identical chunk texts are deduplicated before scoring and expanded back out deterministically
-
-### v0.17
-
-- **Structured Query Modes**: `term`, `intent`, and `hyde` controls across CLI, API, MCP, and Web
-- **Temporal Retrieval Upgrades**: `since`/`until`, date-range parsing, and recency sorting with frontmatter-date fallback
-- **Web Retrieval UX Polish**: richer advanced controls in Search and Ask (collection/date/category/author/tags + query modes)
-- **Metadata-Aware Retrieval**: ingestion now materializes document metadata/date fields for better filtering and ranking
-- **Migration Reliability**: SQLite-compatible migration path for existing indexes (including older SQLite engines)
-
-### v0.15
-
-- **HTTP Backends**: Offload embedding, reranking, and generation to remote GPU servers
-- Simple URI config: `http://host:port/path#modelname`
-- Works with llama-server, Ollama, LocalAI, vLLM
-- Run GNO on lightweight machines while GPU inference runs on your network
-
-### v0.13
-
-- **Knowledge Graph**: Interactive force-directed visualization of document connections
-- **Graph with Similarity**: See semantic similarity as golden edges (not just wiki/markdown links)
-- **CLI**: `gno graph` command with collection filtering and similarity options
-- **Web UI**: `/graph` page with zoom, pan, collection filter, similarity toggle
-- **MCP**: `gno_graph` tool for AI agents to explore document relationships
-- **REST API**: `/api/graph` endpoint with full query parameters
-
-### v0.12
-
-- **Note Linking**: Wiki-style `[[links]]`, backlinks, and AI-powered related notes
-- **Tag System**: Filter searches by frontmatter tags with `--tags-any`/`--tags-all`
-- **Web UI**: Outgoing links panel, backlinks panel, related notes sidebar
-- **CLI**: `gno links`, `gno backlinks`, `gno similar` commands
-- **MCP**: `gno_links`, `gno_backlinks`, `gno_similar` tools
-
 ---
 
 ## Quick Start

package/assets/skill/SKILL.md

@@ -177,6 +177,28 @@ gno embed              # Embed only (if already synced)
 
 MCP `gno.sync` and `gno.capture` do NOT auto-embed. Use CLI for embedding.
 
+## Collection-specific embedding models
+
+Collections can override the global embedding model with `models.embed`.
+
+CLI path:
+
+```bash
+gno collection add ~/work/gno/src \
+  --name gno-code \
+  --embed-model "hf:Qwen/Qwen3-Embedding-0.6B-GGUF/Qwen3-Embedding-0.6B-Q8_0.gguf"
+```
+
+Good default guidance:
+
+- keep the global preset for mixed notes/docs collections
+- use a collection-specific embed override for code-heavy collections when benchmark guidance says so
+- after changing an embed model on an existing populated collection, run:
+
+```bash
+gno embed --collection gno-code
+```
+
 ## Reference Documentation
 
 | Topic                                                 | File                                 |

package/assets/skill/cli-reference.md

@@ -42,7 +42,11 @@ gno init [<path>] [options]
 gno collection add <path> --name <name> [options]
 ```
 
-Options same as `init`.
+Options same as `init`, plus:
+
+| Option                | Description                                          |
+| --------------------- | ---------------------------------------------------- |
+| `--embed-model <uri>` | Initial collection-specific embedding model override |
 
 ### gno collection list
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/cli/commands/collection/add.ts

@@ -12,6 +12,7 @@ import {
 import { CliError } from "../../errors";
 
 interface AddOptions {
+  embedModel?: string;
   name?: string;
   pattern?: string;
   include?: string;
@@ -51,6 +52,11 @@ export async function collectionAdd(
     pattern: options.pattern,
     include: options.include,
     exclude: options.exclude,
+    models: options.embedModel
+      ? {
+          embed: options.embedModel,
+        }
+      : undefined,
     updateCmd: options.update,
   });
 

package/src/cli/program.ts

@@ -1264,10 +1264,12 @@ function wireManagementCommands(program: Command): void {
     .option("--pattern <glob>", "file matching pattern")
     .option("--include <exts>", "extension allowlist (CSV)")
     .option("--exclude <patterns>", "exclude patterns (CSV)")
+    .option("--embed-model <uri>", "collection-specific embedding model URI")
     .option("--update <cmd>", "shell command to run before indexing")
     .action(async (path: string, cmdOpts: Record<string, unknown>) => {
       const { collectionAdd } = await import("./commands/collection");
       await collectionAdd(path, {
+        embedModel: cmdOpts.embedModel as string | undefined,
         name: cmdOpts.name as string,
         pattern: cmdOpts.pattern as string | undefined,
         include: cmdOpts.include as string | undefined,

package/src/collection/add.ts

@@ -97,6 +97,7 @@ export async function addCollection(
     pattern: input.pattern ?? DEFAULT_PATTERN,
     include: includeList,
     exclude: excludeList,
+    models: input.models,
     updateCmd: input.updateCmd,
   };
 

package/src/collection/index.ts

@@ -7,6 +7,7 @@
 
 export { addCollection } from "./add";
 export { removeCollection } from "./remove";
+export { updateCollection } from "./update";
 export type {
   AddCollectionInput,
   CollectionError,
@@ -14,4 +15,5 @@ export type {
   CollectionSuccess,
   RemoveCollectionInput,
   RenameCollectionInput,
+  UpdateCollectionInput,
 } from "./types";

package/src/collection/types.ts

@@ -5,6 +5,7 @@
  */
 
 import type { Collection, Config } from "../config/types";
+import type { ModelType } from "../llm/types";
 
 /**
  * Input for adding a collection.
@@ -22,6 +23,8 @@ export interface AddCollectionInput {
   exclude?: string[] | string;
   /** Update command to run before sync */
   updateCmd?: string;
+  /** Optional initial model overrides */
+  models?: Partial<Record<ModelType, string>>;
 }
 
 /**
@@ -42,6 +45,16 @@ export interface RenameCollectionInput {
   newName: string;
 }
 
+/**
+ * Input for updating a collection.
+ */
+export interface UpdateCollectionInput {
+  /** Collection name (case-insensitive) */
+  name: string;
+  /** Partial model override patch; null clears one role */
+  models?: Partial<Record<ModelType, string | null>>;
+}
+
 /**
  * Successful collection operation result.
  */

package/src/collection/update.ts

@@ -0,0 +1,93 @@
+/**
+ * Update collection core logic.
+ * Pure function that mutates config - caller handles I/O.
+ *
+ * @module src/collection/update
+ */
+
+import type {
+  Collection,
+  CollectionModelOverrides,
+  Config,
+} from "../config/types";
+import type { CollectionResult, UpdateCollectionInput } from "./types";
+
+import { CollectionSchema } from "../config";
+
+function normalizeOverrides(
+  models?: UpdateCollectionInput["models"]
+): CollectionModelOverrides | undefined {
+  if (!models) {
+    return undefined;
+  }
+
+  const entries = Object.entries(models).filter(
+    ([, value]) => value !== undefined && value !== null
+  );
+  if (entries.length === 0) {
+    return undefined;
+  }
+
+  return Object.fromEntries(entries) as CollectionModelOverrides;
+}
+
+/**
+ * Update a collection in config.
+ */
+export function updateCollection(
+  config: Config,
+  input: UpdateCollectionInput
+): CollectionResult {
+  const collectionName = input.name.toLowerCase();
+  const index = config.collections.findIndex((c) => c.name === collectionName);
+  if (index < 0) {
+    return {
+      ok: false,
+      code: "NOT_FOUND",
+      message: `Collection "${collectionName}" not found`,
+    };
+  }
+
+  const current = config.collections[index];
+  if (!current) {
+    return {
+      ok: false,
+      code: "NOT_FOUND",
+      message: `Collection "${collectionName}" not found`,
+    };
+  }
+
+  let nextModels = current.models;
+  if (input.models) {
+    nextModels = normalizeOverrides({
+      ...current.models,
+      ...input.models,
+    });
+  }
+
+  const nextCollection: Collection = {
+    ...current,
+    models: nextModels,
+  };
+
+  const validation = CollectionSchema.safeParse(nextCollection);
+  if (!validation.success) {
+    return {
+      ok: false,
+      code: "VALIDATION",
+      message: `Invalid collection: ${validation.error.issues[0]?.message ?? "unknown error"}`,
+    };
+  }
+
+  const nextCollections = [...config.collections];
+  nextCollections[index] = validation.data;
+
+  return {
+    ok: true,
+    config: {
+      ...config,
+      collections: nextCollections,
+    },
+    collection: validation.data,
+  };
+}

package/src/llm/registry.ts

@@ -15,6 +15,10 @@ import type { ModelType } from "./types";
 
 import { DEFAULT_MODEL_PRESETS } from "../config/types";
 
+export type ModelResolutionSource = "override" | "preset" | "default";
+export type ModelResolutionMap = Record<ModelType, string>;
+export type ModelResolutionSourceMap = Record<ModelType, ModelResolutionSource>;
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Registry Functions
 // ─────────────────────────────────────────────────────────────────────────────
@@ -130,6 +134,55 @@ export function resolveModelUri(
   return preset[type];
 }
 
+export function resolveModelSource(
+  config: Config,
+  type: ModelType,
+  override?: string,
+  collection?: string
+): ModelResolutionSource {
+  if (override) {
+    return "override";
+  }
+  const collectionModels = getCollectionModelOverrides(config, collection);
+  if (collectionModels?.[type]) {
+    return "override";
+  }
+
+  const modelConfig = getModelConfig(config);
+  const preset = modelConfig.presets.find(
+    (p) => p.id === modelConfig.activePreset
+  );
+  if (preset) {
+    return "preset";
+  }
+
+  return "default";
+}
+
+export function getCollectionEffectiveModels(
+  config: Config,
+  collection?: string
+): ModelResolutionMap {
+  return {
+    embed: resolveModelUri(config, "embed", undefined, collection),
+    rerank: resolveModelUri(config, "rerank", undefined, collection),
+    expand: resolveModelUri(config, "expand", undefined, collection),
+    gen: resolveModelUri(config, "gen", undefined, collection),
+  };
+}
+
+export function getCollectionModelSources(
+  config: Config,
+  collection?: string
+): ModelResolutionSourceMap {
+  return {
+    embed: resolveModelSource(config, "embed", undefined, collection),
+    rerank: resolveModelSource(config, "rerank", undefined, collection),
+    expand: resolveModelSource(config, "expand", undefined, collection),
+    gen: resolveModelSource(config, "gen", undefined, collection),
+  };
+}
+
 /**
  * List all available presets.
  */

package/src/serve/public/components/CollectionModelDialog.tsx

@@ -0,0 +1,397 @@
+import {
+  AlertTriangleIcon,
+  CpuIcon,
+  Loader2Icon,
+  RotateCcwIcon,
+  SparklesIcon,
+} from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+
+import { apiFetch } from "../hooks/use-api";
+import { Button } from "./ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "./ui/dialog";
+import { Input } from "./ui/input";
+
+const MODEL_ROLES = ["embed", "rerank", "expand", "gen"] as const;
+
+type ModelRole = (typeof MODEL_ROLES)[number];
+type ModelSource = "override" | "preset" | "default";
+
+const ROLE_LABELS: Record<ModelRole, string> = {
+  embed: "Embedding",
+  rerank: "Reranker",
+  expand: "Query Expansion",
+  gen: "Answer Model",
+};
+
+const ROLE_NOTES: Record<ModelRole, string> = {
+  embed: "Drives vector search and embedding backlog for this collection.",
+  rerank: "Scores candidate passages/documents after retrieval.",
+  expand:
+    "Generates lexical and semantic expansion variants for harder queries.",
+  gen: "Used for collection-targeted answer generation flows.",
+};
+
+export interface CollectionModelDetails {
+  activePresetId?: string;
+  chunkCount: number;
+  documentCount: number;
+  effectiveModels?: Record<ModelRole, string>;
+  include?: string[];
+  modelSources?: Record<ModelRole, ModelSource>;
+  models?: Partial<Record<ModelRole, string>>;
+  name: string;
+  path: string;
+  pattern?: string;
+}
+
+interface UpdateCollectionResponse {
+  collection: CollectionModelDetails;
+  success: boolean;
+}
+
+interface CollectionModelDialogProps {
+  collection: CollectionModelDetails | null;
+  onOpenChange: (open: boolean) => void;
+  onSaved: () => void;
+  open: boolean;
+}
+
+function normalizeValue(value: string | undefined): string {
+  return value?.trim() ?? "";
+}
+
+const CODE_EMBED_RECOMMENDATION =
+  "hf:Qwen/Qwen3-Embedding-0.6B-GGUF/Qwen3-Embedding-0.6B-Q8_0.gguf";
+
+const CODE_PATH_HINTS = [
+  "/src",
+  "/lib",
+  "/app",
+  "/apps",
+  "/packages",
+  "/server",
+  "/services",
+] as const;
+
+const CODE_EXT_HINTS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".go",
+  ".rs",
+  ".py",
+  ".swift",
+  ".c",
+] as const;
+
+function collectionLooksCodeHeavy(collection: CollectionModelDetails): boolean {
+  const path = collection.path.toLowerCase();
+  if (
+    CODE_PATH_HINTS.some(
+      (hint) => path.endsWith(hint) || path.includes(`${hint}/`)
+    )
+  ) {
+    return true;
+  }
+
+  const includeValues = collection.include ?? [];
+  if (
+    includeValues.some((value) =>
+      CODE_EXT_HINTS.some((ext) => value.includes(ext))
+    )
+  ) {
+    return true;
+  }
+
+  const pattern = collection.pattern?.toLowerCase() ?? "";
+  return CODE_EXT_HINTS.some(
+    (ext) => pattern.includes(ext) || pattern.includes(ext.replace(".", ""))
+  );
+}
+
+export function CollectionModelDialog({
+  collection,
+  onOpenChange,
+  onSaved,
+  open,
+}: CollectionModelDialogProps) {
+  const [draft, setDraft] = useState<Record<ModelRole, string>>({
+    embed: "",
+    rerank: "",
+    expand: "",
+    gen: "",
+  });
+  const [error, setError] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
+  const showCodeRecommendation =
+    collection !== null && collectionLooksCodeHeavy(collection);
+
+  useEffect(() => {
+    if (!open || !collection) {
+      return;
+    }
+
+    setDraft({
+      embed: collection.models?.embed ?? "",
+      rerank: collection.models?.rerank ?? "",
+      expand: collection.models?.expand ?? "",
+      gen: collection.models?.gen ?? "",
+    });
+    setError(null);
+    setSaving(false);
+  }, [collection, open]);
+
+  const patch = useMemo(() => {
+    if (!collection) {
+      return {};
+    }
+
+    const nextPatch: Partial<Record<ModelRole, string | null>> = {};
+    for (const role of MODEL_ROLES) {
+      const original = normalizeValue(collection.models?.[role]);
+      const current = normalizeValue(draft[role]);
+      if (original === current) {
+        continue;
+      }
+      nextPatch[role] = current.length === 0 ? null : current;
+    }
+
+    return nextPatch;
+  }, [collection, draft]);
+
+  const hasChanges = Object.keys(patch).length > 0;
+  const embedChanged = Object.hasOwn(patch, "embed");
+
+  const handleSave = async () => {
+    if (!collection || !hasChanges) {
+      return;
+    }
+
+    setSaving(true);
+    setError(null);
+
+    const { error: requestError } = await apiFetch<UpdateCollectionResponse>(
+      `/api/collections/${encodeURIComponent(collection.name)}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ models: patch }),
+      }
+    );
+
+    setSaving(false);
+
+    if (requestError) {
+      setError(requestError);
+      return;
+    }
+
+    onSaved();
+    onOpenChange(false);
+  };
+
+  return (
+    <Dialog onOpenChange={onOpenChange} open={open}>
+      <DialogContent className="flex max-h-[85vh] max-w-3xl flex-col gap-0 overflow-x-hidden border-none bg-[#0f1115] p-0 shadow-[0_30px_90px_-35px_rgba(0,0,0,0.8)]">
+        {/* Header */}
+        <DialogHeader className="shrink-0 border-border/20 border-b px-6 pt-5 pb-4 text-left">
+          <div className="flex items-start justify-between gap-4">
+            <div className="min-w-0 space-y-1.5">
+              <div className="flex flex-wrap items-center gap-x-2 gap-y-1">
+                <span className="rounded bg-muted/40 px-2 py-0.5 font-mono text-[10px] text-muted-foreground/70 uppercase tracking-[0.12em]">
+                  Collection models
+                </span>
+                <span className="rounded bg-muted/30 px-2 py-0.5 font-mono text-[10px] text-muted-foreground/50 tracking-[0.05em]">
+                  preset: {collection?.activePresetId ?? "unknown"}
+                </span>
+              </div>
+              <DialogTitle className="font-[Iowan_Old_Style,Palatino_Linotype,Palatino,Book_Antiqua,Georgia,serif] text-2xl leading-tight">
+                {collection?.name ?? "Collection"}
+              </DialogTitle>
+              <DialogDescription className="text-muted-foreground/70 text-[13px]">
+                Override model roles for one collection without changing the
+                active preset for the rest of the workspace.
+              </DialogDescription>
+            </div>
+            <div className="hidden shrink-0 max-w-[200px] space-y-1 border-border/15 border-l pl-4 lg:block">
+              <p className="font-mono text-[10px] text-muted-foreground/50 uppercase tracking-[0.15em]">
+                Path
+              </p>
+              <p
+                className="break-all font-mono text-[10px] leading-relaxed text-muted-foreground/50"
+                title={collection?.path}
+              >
+                {collection?.path}
+              </p>
+            </div>
+          </div>
+        </DialogHeader>
+
+        {/* Scrollable model roles */}
+        <div className="min-h-0 flex-1 overflow-y-auto overflow-x-hidden">
+          <div className="divide-y divide-border/15">
+            {MODEL_ROLES.map((role) => {
+              const source = collection?.modelSources?.[role] ?? "preset";
+              const effectiveValue = collection?.effectiveModels?.[role] ?? "";
+              const draftValue = draft[role];
+              const isOverride = source === "override";
+
+              return (
+                <div
+                  className="grid gap-x-5 gap-y-3 px-6 py-4 lg:grid-cols-[180px_minmax(0,1fr)]"
+                  key={role}
+                >
+                  {/* Left: role info */}
+                  <div className="space-y-1">
+                    <div className="flex items-center gap-2">
+                      <CpuIcon className="size-3.5 text-secondary/70" />
+                      <h3 className="font-medium text-[13px]">
+                        {ROLE_LABELS[role]}
+                      </h3>
+                    </div>
+                    <p className="text-muted-foreground/50 text-xs leading-relaxed">
+                      {ROLE_NOTES[role]}
+                    </p>
+                  </div>
+
+                  {/* Right: controls */}
+                  <div className="space-y-2.5">
+                    {/* Source + effective model */}
+                    <div className="flex items-baseline gap-2">
+                      <span
+                        className={`shrink-0 rounded px-1.5 py-0.5 font-mono text-[9px] uppercase tracking-[0.1em] ${
+                          isOverride
+                            ? "bg-secondary/15 text-secondary/80"
+                            : "bg-muted/40 text-muted-foreground/50"
+                        }`}
+                      >
+                        {isOverride ? "override" : "inherits"}
+                      </span>
+                      <span className="font-mono text-[9px] text-muted-foreground/35 uppercase tracking-[0.12em]">
+                        effective
+                      </span>
+                    </div>
+                    <p
+                      className="break-all font-mono text-[11px] leading-relaxed text-foreground/70"
+                      title={effectiveValue}
+                    >
+                      {effectiveValue}
+                    </p>
+
+                    {/* Code embed recommendation */}
+                    {role === "embed" && showCodeRecommendation ? (
+                      <button
+                        className="flex w-full cursor-pointer items-center gap-2.5 rounded-md border border-secondary/15 bg-secondary/5 px-3 py-2 text-left transition-colors hover:border-secondary/25 hover:bg-secondary/8"
+                        onClick={() =>
+                          setDraft((current) => ({
+                            ...current,
+                            embed: CODE_EMBED_RECOMMENDATION,
+                          }))
+                        }
+                        type="button"
+                      >
+                        <SparklesIcon className="size-3.5 shrink-0 text-secondary/60" />
+                        <div className="min-w-0">
+                          <p className="text-[11px] text-foreground/70">
+                            Apply code-optimized embedding
+                          </p>
+                          <p className="truncate font-mono text-[10px] text-muted-foreground/40">
+                            {CODE_EMBED_RECOMMENDATION}
+                          </p>
+                        </div>
+                      </button>
+                    ) : null}
+
+                    {/* Input + reset */}
+                    <div className="flex items-center gap-1.5">
+                      <Input
+                        className="h-8 border-border/20 bg-muted/10 font-mono text-[11px] placeholder:text-muted-foreground/25"
+                        onChange={(event) =>
+                          setDraft((current) => ({
+                            ...current,
+                            [role]: event.target.value,
+                          }))
+                        }
+                        placeholder="Leave empty to inherit from preset"
+                        value={draftValue}
+                      />
+                      <Button
+                        className="size-8 shrink-0 border-border/20 text-muted-foreground/30 hover:text-muted-foreground/60"
+                        disabled={draftValue.trim().length === 0}
+                        onClick={() =>
+                          setDraft((current) => ({
+                            ...current,
+                            [role]: "",
+                          }))
+                        }
+                        size="icon-sm"
+                        variant="outline"
+                      >
+                        <RotateCcwIcon className="size-3" />
+                      </Button>
+                    </div>
+                  </div>
+                </div>
+              );
+            })}
+          </div>
+
+          {/* Warnings */}
+          {collection && embedChanged && collection.documentCount > 0 ? (
+            <div className="border-border/15 border-t px-6 py-3">
+              <div className="flex items-start gap-2.5 rounded-md border border-secondary/15 bg-secondary/5 px-3 py-2.5">
+                <AlertTriangleIcon className="mt-0.5 size-3.5 shrink-0 text-secondary/60" />
+                <div>
+                  <p className="font-medium text-secondary/80 text-xs">
+                    Re-index needed after save
+                  </p>
+                  <p className="mt-0.5 text-muted-foreground/50 text-xs">
+                    {collection.documentCount} docs / {collection.chunkCount}{" "}
+                    chunks will need re-embedding for the new model.
+                  </p>
+                </div>
+              </div>
+            </div>
+          ) : null}
+
+          {error ? (
+            <div className="border-border/15 border-t px-6 py-3">
+              <div className="rounded-md border border-destructive/25 bg-destructive/8 px-3 py-2.5 text-destructive text-xs">
+                {error}
+              </div>
+            </div>
+          ) : null}
+        </div>
+
+        {/* Footer — always visible */}
+        <DialogFooter className="shrink-0 border-border/20 border-t px-6 py-3">
+          <Button
+            className="border-border/20 text-xs"
+            onClick={() => onOpenChange(false)}
+            size="sm"
+            variant="outline"
+          >
+            Cancel
+          </Button>
+          <Button
+            className="text-xs"
+            disabled={!hasChanges || saving}
+            onClick={() => void handleSave()}
+            size="sm"
+          >
+            {saving ? <Loader2Icon className="size-3.5 animate-spin" /> : null}
+            Save model settings
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/serve/public/pages/Collections.tsx

@@ -12,6 +12,7 @@
 import {
   AlertCircleIcon,
   ArrowLeftIcon,
+  CpuIcon,
   DatabaseIcon,
   FileTextIcon,
   FolderIcon,
@@ -29,6 +30,10 @@ import type { AppStatusResponse } from "../../status-model";
 
 import { AddCollectionDialog } from "../components/AddCollectionDialog";
 import { Loader } from "../components/ai-elements/loader";
+import {
+  CollectionModelDialog,
+  type CollectionModelDetails,
+} from "../components/CollectionModelDialog";
 import { CollectionsEmptyState } from "../components/CollectionsEmptyState";
 import { IndexingProgress } from "../components/IndexingProgress";
 import { Badge } from "../components/ui/badge";
@@ -67,11 +72,20 @@ interface PageProps {
 }
 
 interface CollectionStats {
+  activePresetId?: string;
   name: string;
   path: string;
   documentCount: number;
   chunkCount: number;
   embeddedCount: number;
+  include?: string[];
+  models?: Partial<Record<"embed" | "rerank" | "expand" | "gen", string>>;
+  effectiveModels?: Record<"embed" | "rerank" | "expand" | "gen", string>;
+  modelSources?: Record<
+    "embed" | "rerank" | "expand" | "gen",
+    "override" | "preset" | "default"
+  >;
+  pattern?: string;
 }
 
 interface StatusResponse {
@@ -86,10 +100,13 @@ interface SyncResponse {
   jobId: string;
 }
 
+interface CollectionsResponseItem extends CollectionModelDetails {}
+
 interface CollectionCardProps {
   actionsDisabled: boolean;
   collection: CollectionStats;
   onBrowse: () => void;
+  onModelSettings: () => void;
   onReindex: () => void;
   onRemove: () => void;
   isReindexing: boolean;
@@ -118,6 +135,7 @@ function CollectionCard({
   actionsDisabled,
   collection,
   onBrowse,
+  onModelSettings,
   onReindex,
   onRemove,
   isReindexing,
@@ -164,6 +182,17 @@ function CollectionCard({
               </Button>
             </DropdownMenuTrigger>
             <DropdownMenuContent align="end">
+              <DropdownMenuItem
+                disabled={actionsDisabled}
+                onClick={(event) => {
+                  event.stopPropagation();
+                  onModelSettings();
+                }}
+              >
+                <CpuIcon className="mr-2 size-4" />
+                Model settings
+              </DropdownMenuItem>
+              <DropdownMenuSeparator />
               <DropdownMenuItem
                 disabled={actionsDisabled || isReindexing}
                 onClick={(event) => {
@@ -244,6 +273,27 @@ function CollectionCard({
           </div>
         )}
 
+        {collection.modelSources ? (
+          <div className="mt-3 flex flex-wrap items-center gap-2 border-border/30 border-t pt-3">
+            {(["embed", "rerank", "expand", "gen"] as const).map((role) => {
+              const source = collection.modelSources?.[role];
+              if (source !== "override") {
+                return null;
+              }
+
+              return (
+                <Badge
+                  className="font-mono text-[10px] uppercase tracking-[0.12em]"
+                  key={role}
+                  variant="secondary"
+                >
+                  {role} override
+                </Badge>
+              );
+            })}
+          </div>
+        ) : null}
+
         <div className="mt-3 border-border/40 border-t pt-3 text-muted-foreground text-xs">
           Click card to browse documents in this collection.
         </div>
@@ -268,19 +318,46 @@ export default function Collections({ navigate }: PageProps) {
   );
   const [removing, setRemoving] = useState(false);
   const [addDialogOpen, setAddDialogOpen] = useState(false);
+  const [modelDialogCollection, setModelDialogCollection] =
+    useState<CollectionStats | null>(null);
   const [initialCollectionPath, setInitialCollectionPath] = useState<
     string | undefined
   >(undefined);
 
   const loadCollections = useCallback(async () => {
-    const { data, error: err } = await apiFetch<StatusResponse>("/api/status");
-    if (err) {
-      setError(err);
-    } else if (data) {
-      setCollections(data.collections);
-      setOnboarding(data.onboarding);
-      setError(null);
+    const [statusResult, collectionsResult] = await Promise.all([
+      apiFetch<StatusResponse>("/api/status"),
+      apiFetch<CollectionsResponseItem[]>("/api/collections"),
+    ]);
+
+    if (statusResult.error) {
+      setError(statusResult.error);
+      return;
+    }
+
+    if (!statusResult.data) {
+      return;
     }
+
+    const collectionsByName = new Map(
+      (collectionsResult.data ?? []).map((item) => [item.name, item] as const)
+    );
+    const merged = statusResult.data.collections.map((collection) => {
+      const config = collectionsByName.get(collection.name);
+      return {
+        ...collection,
+        activePresetId: config?.activePresetId,
+        effectiveModels: config?.effectiveModels,
+        include: config?.include,
+        models: config?.models,
+        modelSources: config?.modelSources,
+        pattern: config?.pattern,
+      };
+    });
+
+    setCollections(merged);
+    setOnboarding(statusResult.data.onboarding);
+    setError(collectionsResult.error ?? null);
   }, []);
 
   // Initial load
@@ -500,6 +577,7 @@ export default function Collections({ navigate }: PageProps) {
                     `/browse?collection=${encodeURIComponent(collection.name)}`
                   )
                 }
+                onModelSettings={() => setModelDialogCollection(collection)}
                 onReindex={() => void handleReindex(collection.name)}
                 onRemove={() => setRemoveDialog(collection)}
               />
@@ -516,6 +594,17 @@ export default function Collections({ navigate }: PageProps) {
         open={addDialogOpen}
       />
 
+      <CollectionModelDialog
+        collection={modelDialogCollection}
+        onOpenChange={(open) => {
+          if (!open) {
+            setModelDialogCollection(null);
+          }
+        }}
+        onSaved={() => void loadCollections()}
+        open={!!modelDialogCollection}
+      />
+
       {/* Remove confirmation dialog */}
       <Dialog
         onOpenChange={(open) => !open && setRemoveDialog(null)}

package/src/serve/routes/api.ts

@@ -10,8 +10,12 @@ import { readdir } from "node:fs/promises";
 // node:path has no Bun equivalent
 import { posix as pathPosix } from "node:path";
 
-import type { Config, ModelPreset } from "../../config/types";
-import type { Collection } from "../../config/types";
+import type {
+  Collection,
+  CollectionModelOverrides,
+  Config,
+  ModelPreset,
+} from "../../config/types";
 import type {
   AskResult,
   Citation,
@@ -26,7 +30,11 @@ import type { StartJobError } from "../jobs";
 import type { CollectionWatchService } from "../watch-service";
 
 import { modelsPull } from "../../cli/commands/models/pull";
-import { addCollection, removeCollection } from "../../collection";
+import {
+  addCollection,
+  removeCollection,
+  updateCollection,
+} from "../../collection";
 import {
   buildEditableCopyContent,
   deriveEditableCopyRelPath,
@@ -68,7 +76,13 @@ import {
 import { validateRelPath } from "../../core/validation";
 import { defaultSyncService, type SyncResult } from "../../ingestion";
 import { updateFrontmatterTags } from "../../ingestion/frontmatter";
-import { getModelConfig, getPreset, listPresets } from "../../llm/registry";
+import {
+  getCollectionEffectiveModels,
+  getCollectionModelSources,
+  getModelConfig,
+  getPreset,
+  listPresets,
+} from "../../llm/registry";
 import {
   generateGroundedAnswer,
   processAnswerResult,
@@ -189,6 +203,59 @@ export interface CreateCollectionRequestBody {
   gitPull?: boolean;
 }
 
+export interface UpdateCollectionRequestBody {
+  models?: {
+    embed?: string | null;
+    rerank?: string | null;
+    expand?: string | null;
+    gen?: string | null;
+  };
+}
+
+export interface CollectionResponse {
+  name: string;
+  path: string;
+  pattern: string;
+  include: string[];
+  exclude: string[];
+  updateCmd?: string;
+  languageHint?: string;
+  models?: CollectionModelOverrides;
+  effectiveModels: {
+    embed: string;
+    rerank: string;
+    expand: string;
+    gen: string;
+  };
+  modelSources: {
+    embed: "override" | "preset" | "default";
+    rerank: "override" | "preset" | "default";
+    expand: "override" | "preset" | "default";
+    gen: "override" | "preset" | "default";
+  };
+  activePresetId: string;
+}
+
+function serializeCollection(
+  config: Config,
+  collection: Collection
+): CollectionResponse {
+  const modelConfig = getModelConfig(config);
+  return {
+    name: collection.name,
+    path: collection.path,
+    pattern: collection.pattern,
+    include: collection.include,
+    exclude: collection.exclude,
+    updateCmd: collection.updateCmd,
+    languageHint: collection.languageHint,
+    models: collection.models,
+    effectiveModels: getCollectionEffectiveModels(config, collection.name),
+    modelSources: getCollectionModelSources(config, collection.name),
+    activePresetId: modelConfig.activePreset,
+  };
+}
+
 export interface ImportPreviewRequestBody {
   path: string;
   name?: string;
@@ -630,19 +697,9 @@ export async function handleStatus(
  * GET /api/collections
  * Returns list of collections.
  */
-export async function handleCollections(
-  store: SqliteAdapter
-): Promise<Response> {
-  const result = await store.getCollections();
-  if (!result.ok) {
-    return errorResponse("RUNTIME", result.error.message, 500);
-  }
-
+export async function handleCollections(config: Config): Promise<Response> {
   return jsonResponse(
-    result.value.map((c) => ({
-      name: c.name,
-      path: c.path,
-    }))
+    config.collections.map((c) => serializeCollection(config, c))
   );
 }
 
@@ -850,6 +907,86 @@ export async function handleDeleteCollection(
   });
 }
 
+/**
+ * PATCH /api/collections/:name
+ * Update collection model overrides.
+ */
+export async function handleUpdateCollection(
+  ctxHolder: ContextHolder,
+  store: SqliteAdapter,
+  name: string,
+  req: Request
+): Promise<Response> {
+  let body: UpdateCollectionRequestBody;
+  try {
+    body = (await req.json()) as UpdateCollectionRequestBody;
+  } catch {
+    return errorResponse("VALIDATION", "Invalid JSON body");
+  }
+
+  if (body.models !== undefined && typeof body.models !== "object") {
+    return errorResponse("VALIDATION", "models must be an object");
+  }
+  if (!body.models) {
+    return errorResponse("VALIDATION", "Missing models patch");
+  }
+
+  for (const [role, value] of Object.entries(body.models)) {
+    if (!["embed", "rerank", "expand", "gen"].includes(role)) {
+      return errorResponse("VALIDATION", `Unknown model role: ${role}`);
+    }
+    if (value !== undefined && value !== null && typeof value !== "string") {
+      return errorResponse("VALIDATION", `${role} must be a string or null`);
+    }
+  }
+
+  const syncResult = await applyConfigChangeTyped<Collection>(
+    ctxHolder,
+    store,
+    (cfg) => {
+      const result = updateCollection(cfg, {
+        name,
+        models: body.models,
+      });
+      if (!result.ok) {
+        return Promise.resolve({
+          ok: false as const,
+          error: result.message,
+          code: result.code,
+        });
+      }
+      return Promise.resolve({
+        ok: true as const,
+        config: result.config,
+        value: result.collection,
+      });
+    }
+  );
+
+  if (!syncResult.ok) {
+    const statusMap: Record<string, number> = {
+      NOT_FOUND: 404,
+      VALIDATION: 400,
+    };
+    const status = statusMap[syncResult.code] ?? 500;
+    return errorResponse(syncResult.code, syncResult.error, status);
+  }
+
+  const collection =
+    syncResult.value ??
+    syncResult.config.collections.find(
+      (item) => item.name === name.toLowerCase()
+    );
+  if (!collection) {
+    return errorResponse("RUNTIME", "Collection not found after update", 500);
+  }
+
+  return jsonResponse({
+    success: true,
+    collection: serializeCollection(syncResult.config, collection),
+  });
+}
+
 /**
  * POST /api/sync
  * Trigger re-index of all or specific collection.
@@ -3577,7 +3714,7 @@ export async function routeApi(
   }
 
   if (path === "/api/collections") {
-    return handleCollections(store);
+    return handleCollections(config);
   }
 
   if (path === "/api/docs") {

package/src/serve/server.ts

@@ -51,6 +51,7 @@ import {
   handleSync,
   handleTags,
   handleTrashDoc,
+  handleUpdateCollection,
   handleUpdateDoc,
 } from "./routes/api";
 import { handleGraph } from "./routes/graph";
@@ -192,7 +193,10 @@ export async function startServer(
         },
         "/api/collections": {
           GET: async () =>
-            withSecurityHeaders(await handleCollections(store), isDev),
+            withSecurityHeaders(
+              await handleCollections(ctxHolder.config),
+              isDev
+            ),
           POST: async (req: Request) => {
             if (!isRequestAllowed(req, port)) {
               return withSecurityHeaders(forbiddenResponse(), isDev);
@@ -516,6 +520,19 @@ export async function startServer(
             withSecurityHeaders(handleEmbedStatus(ctxHolder.scheduler), isDev),
         },
         "/api/collections/:name": {
+          PATCH: async (req: Request) => {
+            if (!isRequestAllowed(req, port)) {
+              return withSecurityHeaders(forbiddenResponse(), isDev);
+            }
+            const url = new URL(req.url);
+            const name = decodeURIComponent(
+              url.pathname.split("/").pop() || ""
+            );
+            return withSecurityHeaders(
+              await handleUpdateCollection(ctxHolder, store, name, req),
+              isDev
+            );
+          },
           DELETE: async (req: Request) => {
             if (!isRequestAllowed(req, port)) {
               return withSecurityHeaders(forbiddenResponse(), isDev);