Upload 143 files

.gitattributes

@@ -33,3 +33,16 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/_indices/1bf8e725-d7c9-40b1-ba8f-f87711c6f146/part_0_invert.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/_indices/4036b9ca-15fe-43b1-ada3-eb7603ddda14/part_0_invert.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/_indices/8c701121-c985-485b-aaac-a1ff6805ad15/part_0_invert.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/_indices/bc5cf2ff-eef5-41f3-8c32-e623b0771590/part_0_invert.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/_indices/d0ae91ba-acf5-44fb-8863-fc9efad5ef09/part_1_invert.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/_indices/f9943ee7-cbfc-4972-9b4f-c5737473b88a/part_0_invert.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/_indices/fe5c2cf5-6aad-44b5-8308-a08422c6a259/part_0_invert.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/data/000101001101011011001000d12f72422994e6d4750671d1cb.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/data/000111110111000011000010fb6b6343448c22c242e8a7e820.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/data/1001010110001010001010117460c543a7ab8135cc05eb0a67.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/data/100110110110110110000101ab4f8a403c88cf44f5dfcc16e2.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/data/1110110000011010101111109886fb45d299593d03bffd0230.lance filter=lfs diff=lfs merge=lfs -text
+lancedb/passages.lance/data/1111001101101101110100007dd4244f748f751fd19c94e429.lance filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,23 @@
+# Slim online SearchAudio image (CPU only). Build context = project root:
+#   docker build -f deploy/Dockerfile -t searchaudio-online .
+FROM python:3.11-slim
+
+WORKDIR /app
+ENV HF_HOME=/app/models \
+    HF_HUB_CACHE=/app/models/hub \
+    SEARCHAUDIO_AUDIO_MODE=archive \
+    PYTHONUNBUFFERED=1
+
+COPY requirements-online.txt .
+RUN pip install --no-cache-dir -r requirements-online.txt
+
+# Bake bge-m3 into the image so cold starts don't download it; then run offline.
+RUN python -c "from FlagEmbedding import BGEM3FlagModel; BGEM3FlagModel('BAAI/bge-m3', use_fp16=False)"
+ENV HF_HUB_OFFLINE=1
+
+COPY app ./app
+COPY config.yaml ./config.yaml
+COPY deploy/index/lancedb ./data/index/lancedb
+
+EXPOSE 7860
+CMD ["uvicorn", "app.server:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

app/__init__.py

@@ -0,0 +1,12 @@
+"""SearchAudio — fully-local semantic search over long Hindi audio talks.
+
+Type an English sentence (or speak/upload a Hindi clip) and jump straight to the
+moment in a recording where that topic is discussed. Everything runs offline on a
+single Windows PC with an NVIDIA GPU.
+
+Pipeline:  audio -> ffmpeg normalize -> WhisperX ASR (word timestamps) ->
+           sentence-packed chunks -> bge-m3 embeddings -> LanceDB index.
+Query:     text/Hindi-audio -> bge-m3 -> LanceDB hybrid search -> bge-reranker -> results.
+"""
+
+__version__ = "0.1.0"

app/_cuda_bootstrap.py

@@ -0,0 +1,88 @@
+"""Make Windows able to find the CUDA / cuDNN DLLs that CTranslate2 needs.
+
+The single most common failure when running faster-whisper / WhisperX on Windows is:
+
+    RuntimeError: Library cudnn_ops64_9.dll is not found ...
+    (or: Could not locate cudnn_ops_infer64_8.dll)
+
+It happens because CTranslate2 loads cuDNN/cuBLAS by name via the OS loader, but the
+DLLs live inside pip wheels (``nvidia-cudnn-cu12`` / ``nvidia-cublas-cu12``) or inside
+``torch/lib`` (the cu128 wheel bundles them) — directories that are NOT on the default
+DLL search path.
+
+Importing this module **first** — before importing ``ctranslate2``, ``faster_whisper``
+or ``whisperx`` — registers those directories with the OS loader using
+``os.add_dll_directory`` (and prepends them to PATH as a belt-and-suspenders fallback).
+
+Usage::
+
+    from app import _cuda_bootstrap          # noqa: F401  (must come first)
+    from faster_whisper import WhisperModel   # now finds cuDNN
+
+This is a no-op on non-Windows platforms.
+"""
+from __future__ import annotations
+
+import importlib.util
+import os
+import sys
+
+# cuDNN must come last so its directory is searched first (add_dll_directory is LIFO-ish
+# in practice via PATH ordering); the order here is the order we *append* candidates.
+_NVIDIA_PKGS = (
+    "nvidia.cuda_runtime",
+    "nvidia.cuda_nvrtc",
+    "nvidia.cublas",
+    "nvidia.cudnn",
+)
+
+
+def _add_dll_dir(path: str) -> bool:
+    if not path or not os.path.isdir(path):
+        return False
+    try:
+        os.add_dll_directory(path)  # type: ignore[attr-defined]  (Windows only)
+    except (OSError, AttributeError):
+        return False
+    # Some libraries resolve via LoadLibrary(name) which consults PATH, not the
+    # add_dll_directory list — so prepend to PATH too.
+    if path not in os.environ.get("PATH", ""):
+        os.environ["PATH"] = path + os.pathsep + os.environ.get("PATH", "")
+    return True
+
+
+def _candidate_dirs() -> list[str]:
+    dirs: list[str] = []
+    for pkg in _NVIDIA_PKGS:
+        try:
+            spec = importlib.util.find_spec(pkg)
+        except (ImportError, ValueError, ModuleNotFoundError):
+            spec = None
+        if spec and spec.submodule_search_locations:
+            base = list(spec.submodule_search_locations)[0]
+            # Windows wheels put DLLs in /bin, Linux in /lib — add both, harmless if absent.
+            dirs.append(os.path.join(base, "bin"))
+            dirs.append(os.path.join(base, "lib"))
+    # torch's bundled CUDA libs (the cu128 wheel ships cudnn/cublas DLLs here).
+    try:
+        import torch  # noqa: WPS433 (local import on purpose)
+
+        dirs.append(os.path.join(os.path.dirname(torch.__file__), "lib"))
+    except Exception:  # noqa: BLE001 — torch may not be importable yet; ignore.
+        pass
+    return dirs
+
+
+def setup_cuda_dll_path() -> list[str]:
+    """Register CUDA/cuDNN DLL directories with the Windows loader. Returns dirs added."""
+    if sys.platform != "win32":
+        return []
+    added: list[str] = []
+    for d in _candidate_dirs():
+        if _add_dll_dir(d):
+            added.append(d)
+    return added
+
+
+# Run on import. Safe to import multiple times.
+ADDED_DLL_DIRS = setup_cuda_dll_path()

app/asr.py

@@ -0,0 +1,209 @@
+"""Speech-to-text with word-level timestamps, via WhisperX (faster-whisper backend).
+
+WhisperX gives us three things in one pipeline:
+  1. Silero VAD to slice a 1h+ talk into speech regions (kills long-form hallucination).
+  2. faster-whisper / CTranslate2 large-v3 transcription (Hindi, batched, on the GPU).
+  3. wav2vec2 **forced alignment** -> per-word [start, end] accurate to ~tens of ms,
+     which is what makes "jump to the exact moment" reliable.
+
+Blackwell / RTX 50-series note: use compute_type="float16". int8 crashes with
+CUBLAS_STATUS_NOT_SUPPORTED on sm_120; 12 GB VRAM fits float16 large-v3 comfortably.
+"""
+from __future__ import annotations
+
+# IMPORTANT: register CUDA/cuDNN DLL dirs BEFORE importing ctranslate2-backed libs.
+from app import _cuda_bootstrap  # noqa: F401  (side-effect import, must be first)
+
+import json
+import wave
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from app.config import Config, get_config
+
+SAMPLE_RATE = 16000
+
+
+def read_wav_mono16k(path: str | Path) -> "np.ndarray":
+    """Read a 16 kHz mono PCM WAV into a float32 array in [-1, 1].
+
+    We always pre-normalize inputs to this exact format with ffmpeg (audio_utils), so we
+    can decode with the stdlib instead of depending on ffmpeg-on-PATH / torchaudio codecs.
+    """
+    with wave.open(str(path), "rb") as w:
+        n_channels = w.getnchannels()
+        sampwidth = w.getsampwidth()
+        frames = w.readframes(w.getnframes())
+    if sampwidth != 2:
+        raise ValueError(f"expected 16-bit PCM wav, got sample width {sampwidth} bytes")
+    audio = np.frombuffer(frames, dtype=np.int16)
+    if n_channels > 1:
+        audio = audio.reshape(-1, n_channels).mean(axis=1)
+    return np.ascontiguousarray(audio.astype(np.float32) / 32768.0)
+
+
+class Transcriber:
+    """Lazy-loading wrapper around WhisperX. Load once, reuse for the whole run."""
+
+    def __init__(self, cfg: Optional[Config] = None):
+        self.cfg = cfg or get_config()
+        self._model = None
+        self._align_model = None
+        self._align_meta = None
+        self._align_lang: Optional[str] = None
+        self.device = self.cfg.asr["device"]
+        self.compute_type = self.cfg.asr["compute_type"]
+
+    # ---- model loading -------------------------------------------------
+    def _load_model(self):
+        if self._model is not None:
+            return self._model
+        import whisperx
+
+        a = self.cfg.asr
+        asr_options = {
+            "beam_size": a["beam_size"],
+            "condition_on_previous_text": a["condition_on_previous_text"],
+        }
+        # whisperx.load_model signatures differ slightly across versions; pass what we can.
+        kwargs: Dict[str, Any] = dict(
+            device=self.device,
+            compute_type=self.compute_type,
+            language=a["language"],
+            asr_options=asr_options,
+        )
+        if a.get("vad", True):
+            # Newer whisperx exposes vad_method; older uses default VAD. Try, then fall back.
+            try:
+                self._model = whisperx.load_model(a["model"], vad_method="silero", **kwargs)
+            except TypeError:
+                self._model = whisperx.load_model(a["model"], **kwargs)
+        else:
+            self._model = whisperx.load_model(a["model"], **kwargs)
+        return self._model
+
+    def _load_align(self, language: str):
+        if self._align_model is not None and self._align_lang == language:
+            return self._align_model, self._align_meta
+        import whisperx
+
+        model_name = self.cfg.asr.get("align_model")  # None -> whisperx default for the lang
+        self._align_model, self._align_meta = whisperx.load_align_model(
+            language_code=language, device=self.device, model_name=model_name
+        )
+        self._align_lang = language
+        return self._align_model, self._align_meta
+
+    # ---- transcription -------------------------------------------------
+    def transcribe(self, wav_path: str | Path) -> Dict[str, Any]:
+        """Full transcription + word alignment. Returns a transcript dict."""
+        import whisperx
+
+        wav_path = str(wav_path)
+        model = self._load_model()
+        audio = read_wav_mono16k(wav_path)
+        result = model.transcribe(
+            audio, batch_size=self.cfg.asr["batch_size"], language=self.cfg.asr["language"]
+        )
+        language = result.get("language", self.cfg.asr["language"])
+
+        if self.cfg.asr.get("align", True) and result.get("segments"):
+            try:
+                align_model, meta = self._load_align(language)
+                result = whisperx.align(
+                    result["segments"],
+                    align_model,
+                    meta,
+                    audio,
+                    self.device,
+                    return_char_alignments=False,
+                )
+            except Exception as exc:  # noqa: BLE001
+                print(f"[asr] alignment failed ({exc}); falling back to segment timestamps")
+                result["segments"] = _segments_to_pseudo_words(result["segments"])
+        else:
+            result["segments"] = _segments_to_pseudo_words(result.get("segments", []))
+
+        duration = float(len(audio)) / 16000.0
+        return {
+            "language": language,
+            "duration": duration,
+            "segments": _clean_segments(result.get("segments", [])),
+        }
+
+    def transcribe_query(self, wav_path: str | Path) -> str:
+        """Fast path for a short query clip: just the Hindi text, no alignment."""
+        import whisperx
+
+        model = self._load_model()
+        audio = read_wav_mono16k(wav_path)
+        result = model.transcribe(audio, batch_size=self.cfg.asr["batch_size"], language=self.cfg.asr["language"])
+        return " ".join(seg.get("text", "").strip() for seg in result.get("segments", [])).strip()
+
+
+# ---- helpers -----------------------------------------------------------
+def _segments_to_pseudo_words(segments: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """When alignment is unavailable, synthesize one 'word' per segment spanning it.
+
+    Search still works; jump-to-moment lands within a few seconds instead of ms.
+    """
+    out = []
+    for seg in segments:
+        if "start" not in seg or "end" not in seg:
+            continue
+        text = (seg.get("text") or "").strip()
+        seg = dict(seg)
+        seg["words"] = [{"word": text, "start": seg["start"], "end": seg["end"]}]
+        out.append(seg)
+    return out
+
+
+def _clean_segments(segments: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Keep only well-formed words (numeric start/end). Backfill missing word times."""
+    cleaned: List[Dict[str, Any]] = []
+    for seg in segments:
+        words_in = seg.get("words") or []
+        words_out: List[Dict[str, Any]] = []
+        # Pass 1: keep words that already have numeric timing.
+        last_end = seg.get("start")
+        for w in words_in:
+            start = w.get("start")
+            end = w.get("end")
+            token = (w.get("word") or w.get("text") or "").strip()
+            if not token:
+                continue
+            if isinstance(start, (int, float)) and isinstance(end, (int, float)):
+                words_out.append({"word": token, "start": float(start), "end": float(end)})
+                last_end = end
+        if not words_out:
+            # whole segment had no aligned words -> use the segment span
+            s = seg.get("start")
+            e = seg.get("end")
+            text = (seg.get("text") or "").strip()
+            if isinstance(s, (int, float)) and isinstance(e, (int, float)) and text:
+                words_out = [{"word": text, "start": float(s), "end": float(e)}]
+        if not words_out:
+            continue
+        cleaned.append(
+            {
+                "start": words_out[0]["start"],
+                "end": words_out[-1]["end"],
+                "text": (seg.get("text") or " ".join(w["word"] for w in words_out)).strip(),
+                "words": words_out,
+            }
+        )
+    return cleaned
+
+
+def save_transcript(transcript: Dict[str, Any], out_path: str | Path) -> None:
+    out_path = Path(out_path)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as fh:
+        json.dump(transcript, fh, ensure_ascii=False, indent=1)
+
+
+def load_transcript(path: str | Path) -> Dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as fh:
+        return json.load(fh)

app/audio_source.py

@@ -0,0 +1,36 @@
+"""Build the playable URL for a recording, for local serving or archive.org streaming.
+
+- ``local`` mode  -> ``/audio/<encoded-source_file>`` (served by StaticFiles from disk).
+- ``archive`` mode -> ``https://archive.org/download/<item>/<path>`` where the local
+  ``source_file`` (whose ``%5C`` are path separators) is remapped: drop the configured
+  local prefix, prepend the configured archive path prefix. Verified to range-seek (206).
+"""
+from __future__ import annotations
+
+from typing import Optional
+from urllib.parse import quote
+
+from app.config import Config, get_config
+
+
+def _archive_url(source_file: str, arch: dict) -> str:
+    rel = source_file.replace("%5C", "/")
+    prefix = (arch.get("strip_local_prefix") or "").strip("/")
+    if prefix and rel.startswith(prefix + "/"):
+        rel = rel[len(prefix) + 1:]
+    path_prefix = (arch.get("archive_path_prefix") or "").strip("/")
+    path = f"{path_prefix}/{rel}" if path_prefix else rel
+    base = (arch.get("base_url") or "https://archive.org/download").rstrip("/")
+    item = arch.get("item_id", "")
+    parts = ([item] if item else []) + path.split("/")
+    return base + "/" + "/".join(quote(seg) for seg in parts)
+
+
+def audio_url(source_file: str, cfg: Optional[Config] = None) -> str:
+    cfg = cfg or get_config()
+    audio = cfg.get("audio", {}) or {}
+    if audio.get("mode", "local") == "archive":
+        return _archive_url(source_file, audio.get("archive", {}) or {})
+    route = cfg.server["audio_route"]
+    encoded = "/".join(quote(seg) for seg in source_file.split("/"))
+    return f"{route}/{encoded}"

app/audio_utils.py

@@ -0,0 +1,56 @@
+"""ffmpeg helpers: locate the binary and normalize audio to 16 kHz mono WAV.
+
+Whisper/WhisperX expect 16 kHz mono; normalizing once up front also makes decoding of
+exotic inputs (m4a/opus/wma/video containers) reliable. We always call ffmpeg by an
+absolute path (missing-ffmpeg-on-PATH is the #1 cause of "the audio query does nothing").
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+from app.config import get_config
+
+AUDIO_EXTS = {
+    ".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg", ".opus",
+    ".wma", ".mp4", ".webm", ".mkv", ".mov", ".3gp",
+}
+
+_FFMPEG: Optional[str] = None
+
+
+def find_ffmpeg() -> str:
+    """Locate ffmpeg: PATH first, then a bundled project ``bin/ffmpeg.exe``."""
+    global _FFMPEG
+    if _FFMPEG:
+        return _FFMPEG
+    exe = shutil.which("ffmpeg")
+    if not exe:
+        binname = "ffmpeg.exe" if sys.platform == "win32" else "ffmpeg"
+        bundled = get_config().root / "bin" / binname
+        if bundled.exists():
+            exe = str(bundled)
+    if not exe:
+        raise FileNotFoundError(
+            "ffmpeg not found. Install it (winget install Gyan.FFmpeg) or place ffmpeg.exe in ./bin/."
+        )
+    _FFMPEG = exe
+    return exe
+
+
+def normalize_to_wav(src: str | Path, dst: str | Path) -> Path:
+    """Decode any input to 16 kHz mono 16-bit PCM WAV at ``dst``."""
+    dst = Path(dst)
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    cmd = [
+        find_ffmpeg(), "-y", "-hide_banner", "-loglevel", "error",
+        "-i", str(src), "-vn", "-ac", "1", "-ar", "16000",
+        "-c:a", "pcm_s16le", "-f", "wav", str(dst),
+    ]
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    if proc.returncode != 0 or not dst.exists():
+        raise RuntimeError(f"ffmpeg failed for {src}: {proc.stderr.strip()[:500]}")
+    return dst

app/chunking.py

@@ -0,0 +1,124 @@
+"""Turn word-timestamped ASR output into searchable passages.
+
+Strategy (robust + precise):
+  * Each ASR segment is one "unit" (Whisper/VAD segments already break near natural
+    pauses, i.e. roughly sentence boundaries). We never split *across* a unit when
+    packing, so passages start/end on sentence-ish boundaries.
+  * Units are packed greedily into ~target_seconds windows (hard cap at max_seconds),
+    carrying ``overlap_sentences`` trailing units into the next window so a topic that
+    straddles a boundary is still findable.
+  * A passage's [start_ms, end_ms] always comes from its first/last *word* timestamps,
+    so playback seeks to the exact spoken moment.
+  * If a single segment is longer than max_seconds (rare; a long VAD region), it is
+    split by word timing into target-sized sub-passages.
+
+``split_sentences`` (Devanagari/danda-aware, via Indic NLP when available) is exposed for
+reuse (e.g. snippet tidying / translation), with a regex fallback so it never hard-fails.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional
+
+from app.config import Config, get_config
+from app.models import Passage
+
+# Sentence-final punctuation for Hindi (danda, double danda) + Latin.
+_SENT_END = "।॥?!."
+_SENT_SPLIT_RE = re.compile(r"(?<=[।॥?!])\s+|(?<=[.?!])\s+(?=[A-Zऀ-ॿ])")
+
+
+def split_sentences(text: str) -> List[str]:
+    """Split Hindi/English text into sentences. Uses Indic NLP if installed, else regex."""
+    text = (text or "").strip()
+    if not text:
+        return []
+    try:
+        from indicnlp.tokenize import sentence_tokenize
+
+        sents = sentence_tokenize.sentence_split(text, lang="hi")
+        sents = [s.strip() for s in sents if s.strip()]
+        if sents:
+            return sents
+    except Exception:  # noqa: BLE001 — indicnlp optional / may not init; fall through
+        pass
+    parts = _SENT_SPLIT_RE.split(text)
+    return [p.strip() for p in parts if p.strip()]
+
+
+def _split_long_unit(unit: Dict[str, Any], target_s: float) -> List[Dict[str, Any]]:
+    """Split a too-long unit into ~target_s sub-units by word timing."""
+    words = unit["words"]
+    out: List[Dict[str, Any]] = []
+    buf: List[Dict[str, Any]] = []
+    start = words[0]["start"]
+    for w in words:
+        buf.append(w)
+        if w["end"] - start >= target_s:
+            out.append({"text": " ".join(x["word"] for x in buf), "words": buf})
+            buf = []
+            # next sub-unit starts at the next word
+            start = w["end"]
+    if buf:
+        out.append({"text": " ".join(x["word"] for x in buf), "words": buf})
+    return out
+
+
+def _segments_to_units(segments: List[Dict[str, Any]], max_s: float, target_s: float) -> List[Dict[str, Any]]:
+    units: List[Dict[str, Any]] = []
+    for seg in segments:
+        words = seg.get("words") or []
+        if not words:
+            continue
+        dur = words[-1]["end"] - words[0]["start"]
+        unit = {"text": (seg.get("text") or " ".join(w["word"] for w in words)).strip(), "words": words}
+        if dur > max_s:
+            units.extend(_split_long_unit(unit, target_s))
+        else:
+            units.append(unit)
+    return units
+
+
+def chunk_transcript(
+    transcript: Dict[str, Any],
+    recording_id: str,
+    source_file: str,
+    cfg: Optional[Config] = None,
+) -> List[Passage]:
+    cfg = cfg or get_config()
+    c = cfg.chunking
+    target_s = float(c["target_seconds"])
+    max_s = float(c["max_seconds"])
+    overlap = int(c["overlap_sentences"])
+
+    units = _segments_to_units(transcript.get("segments", []), max_s, target_s)
+    if not units:
+        return []
+
+    passages: List[Passage] = []
+    n = len(units)
+    i = 0
+    while i < n:
+        buf_words: List[Dict[str, Any]] = []
+        buf_texts: List[str] = []
+        start_time = units[i]["words"][0]["start"]
+        j = i
+        while j < n:
+            u = units[j]
+            buf_words.extend(u["words"])
+            buf_texts.append(u["text"])
+            cur_end = u["words"][-1]["end"]
+            j += 1
+            if cur_end - start_time >= target_s:
+                break  # reached target; break on this unit boundary
+        text = " ".join(t for t in buf_texts if t).strip()
+        if buf_words and text:
+            passages.append(Passage.from_words(recording_id, source_file, buf_words, text))
+        if j >= n:
+            break
+        i = max(j - overlap, i + 1)  # carry `overlap` trailing units; always progress
+    return passages
+
+
+def passages_text(passages: List[Passage]) -> List[str]:
+    return [p.hindi_text for p in passages]

app/config.py

@@ -0,0 +1,190 @@
+"""Load and resolve configuration from ``config.yaml`` at the project root.
+
+Exposes a single ``get_config()`` returning a ``Config`` object with:
+  - dotted/dict access to every setting (``cfg.asr["model"]``, ``cfg["asr"]["model"]``)
+  - absolute, resolved paths under ``cfg.paths`` (audio_dir, work_dir, index_dir, models_dir)
+  - convenience properties for the LanceDB dir and the SQLite manifest path.
+
+Defaults are baked in, so the app still runs if a key (or the whole file) is missing.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+CONFIG_PATH = PROJECT_ROOT / "config.yaml"
+
+# Minimal defaults mirrored from config.yaml so the system degrades gracefully.
+_DEFAULTS: Dict[str, Any] = {
+    "paths": {
+        "audio_dir": "data/audio",
+        "work_dir": "data/work",
+        "index_dir": "data/index",
+        "models_dir": "models",
+    },
+    "asr": {
+        "model": "large-v3",
+        "device": "cuda",
+        "compute_type": "float16",
+        "language": "hi",
+        "beam_size": 5,
+        "batch_size": 8,
+        "vad": True,
+        "condition_on_previous_text": False,
+        "align": True,
+        "align_model": None,
+    },
+    "chunking": {
+        "target_seconds": 45,
+        "max_seconds": 60,
+        "min_seconds": 8,
+        "overlap_sentences": 1,
+    },
+    "embedding": {
+        "model": "BAAI/bge-m3",
+        "device": "cuda",
+        "use_fp16": True,
+        "dim": 1024,
+        "batch_size": 32,
+        "max_length": 1024,
+    },
+    "reranker": {
+        "enabled": True,
+        "model": "BAAI/bge-reranker-v2-m3",
+        "device": "cuda",
+        "use_fp16": True,
+        "candidates": 80,
+        "batch_size": 16,
+    },
+    "translation": {
+        "enabled": False,
+        "model": "ai4bharat/indictrans2-indic-en-1B",
+        "device": "cuda",
+    },
+    "search": {"top_k": 20, "hybrid": True, "vector_weight": 0.7},
+    "server": {
+        "host": "127.0.0.1",
+        "port": 8000,
+        "audio_route": "/audio",
+    },
+    "audio": {
+        "mode": "local",
+        "archive": {
+            "base_url": "https://archive.org/download",
+            "item_id": "",
+            "strip_local_prefix": "",
+            "archive_path_prefix": "",
+        },
+    },
+}
+
+
+def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    out = dict(base)
+    for key, val in (override or {}).items():
+        if isinstance(val, dict) and isinstance(out.get(key), dict):
+            out[key] = _deep_merge(out[key], val)
+        else:
+            out[key] = val
+    return out
+
+
+class Config:
+    """Thin wrapper over the merged config dict with resolved absolute paths."""
+
+    def __init__(self, data: Dict[str, Any]):
+        self._data = data
+        self.root = PROJECT_ROOT
+        # Resolve every path to an absolute Path and ensure the directory exists.
+        self.paths = {
+            name: self._resolve(rel) for name, rel in data["paths"].items()
+        }
+
+    def _resolve(self, rel: str) -> Path:
+        p = Path(rel)
+        if not p.is_absolute():
+            p = PROJECT_ROOT / p
+        return p.resolve()
+
+    def ensure_dirs(self) -> None:
+        for p in self.paths.values():
+            p.mkdir(parents=True, exist_ok=True)
+
+    # ---- access helpers -------------------------------------------------
+    def __getitem__(self, key: str) -> Any:
+        return self._data[key]
+
+    def __getattr__(self, name: str) -> Any:
+        # Only called for attributes not found normally (so self._data etc. are safe).
+        try:
+            return self._data[name]
+        except KeyError as exc:  # pragma: no cover
+            raise AttributeError(name) from exc
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    # ---- convenience paths ---------------------------------------------
+    @property
+    def lancedb_dir(self) -> Path:
+        return self.paths["index_dir"] / "lancedb"
+
+    @property
+    def manifest_path(self) -> Path:
+        return self.paths["index_dir"] / "manifest.sqlite"
+
+    @property
+    def audio_dir(self) -> Path:
+        return self.paths["audio_dir"]
+
+    @property
+    def work_dir(self) -> Path:
+        return self.paths["work_dir"]
+
+    @property
+    def models_dir(self) -> Path:
+        return self.paths["models_dir"]
+
+    def as_dict(self) -> Dict[str, Any]:
+        return dict(self._data)
+
+
+@lru_cache(maxsize=1)
+def get_config() -> Config:
+    data = dict(_DEFAULTS)
+    if CONFIG_PATH.exists():
+        try:
+            import yaml  # local import: only needed when a config file is present
+
+            with open(CONFIG_PATH, "r", encoding="utf-8") as fh:
+                loaded = yaml.safe_load(fh) or {}
+            data = _deep_merge(_DEFAULTS, loaded)
+        except Exception as exc:  # noqa: BLE001
+            print(f"[config] WARNING: could not read {CONFIG_PATH}: {exc}; using defaults")
+    # Deployment can flip audio mode without editing the file (copy audio to avoid
+    # mutating the shared _DEFAULTS object).
+    env_mode = os.environ.get("SEARCHAUDIO_AUDIO_MODE")
+    if env_mode:
+        audio = dict(data.get("audio", {}) or {})
+        audio["mode"] = env_mode
+        data["audio"] = audio
+    cfg = Config(data)
+    # Point the HF cache at our local models dir so everything stays in the project
+    # and works fully offline (after a one-time download).
+    os.environ.setdefault("HF_HOME", str(cfg.models_dir))
+    os.environ.setdefault("HF_HUB_CACHE", str(cfg.models_dir / "hub"))
+    # Windows without Developer Mode/admin can't create symlinks (WinError 1314 during
+    # model downloads). Tell huggingface_hub to copy files instead.
+    if sys.platform == "win32":
+        os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS", "1")
+        os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1")
+    # Put the bundled ffmpeg on PATH so any library that shells out to `ffmpeg` by name
+    # (e.g. whisperx.load_audio) can find it, even though it lives in ./bin.
+    bin_dir = PROJECT_ROOT / "bin"
+    if bin_dir.is_dir() and str(bin_dir) not in os.environ.get("PATH", ""):
+        os.environ["PATH"] = str(bin_dir) + os.pathsep + os.environ.get("PATH", "")
+    return cfg

app/embed.py

@@ -0,0 +1,53 @@
+"""Dense text embeddings via BAAI/bge-m3.
+
+bge-m3 maps Hindi passages and an English query into the **same** vector space, so an
+English sentence retrieves Hindi content natively — no query-time translation. It needs
+no "query:"/"passage:" prefix (symmetric), and its dense vectors are unit-normalized, so
+cosine == dot product.
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+import numpy as np
+
+from app.config import Config, get_config
+
+
+class Embedder:
+    def __init__(self, cfg: Optional[Config] = None):
+        self.cfg = cfg or get_config()
+        self._model = None
+
+    def _load(self):
+        if self._model is not None:
+            return self._model
+        from FlagEmbedding import BGEM3FlagModel
+
+        e = self.cfg.embedding
+        # FlagEmbedding auto-selects CUDA when available; use_fp16 ~halves VRAM and ~2x speed.
+        self._model = BGEM3FlagModel(e["model"], use_fp16=bool(e["use_fp16"]))
+        return self._model
+
+    def embed_passages(self, texts: List[str]) -> np.ndarray:
+        """Return an (N, dim) float32 array of dense embeddings."""
+        if not texts:
+            return np.zeros((0, self.cfg.embedding["dim"]), dtype=np.float32)
+        model = self._load()
+        e = self.cfg.embedding
+        out = model.encode(
+            texts,
+            batch_size=e["batch_size"],
+            max_length=e["max_length"],
+            return_dense=True,
+            return_sparse=False,
+            return_colbert_vecs=False,
+        )
+        vecs = np.asarray(out["dense_vecs"], dtype=np.float32)
+        if vecs.ndim == 1:
+            vecs = vecs.reshape(1, -1)
+        return np.ascontiguousarray(vecs)
+
+    def embed_query(self, text: str) -> np.ndarray:
+        """Return a single (dim,) float32 vector for a query string."""
+        return self.embed_passages([text])[0]

app/ingest.py

@@ -0,0 +1,164 @@
+"""End-to-end ingestion: audio folder -> searchable index. Resumable & incremental.
+
+Per file:  normalize (ffmpeg) -> transcribe+align (WhisperX) -> chunk -> [translate]
+           -> embed (bge-m3) -> upsert (LanceDB).
+
+Resumability: the SQLite manifest records each file's furthest-completed status; the
+normalized WAV and transcript JSON are cached on disk. Re-running skips finished work and
+continues from where it stopped. One bad file is marked ``failed`` and never blocks the
+rest. Incremental ingest is just re-running ``run_ingest`` — only new content hashes are
+processed.
+"""
+from __future__ import annotations
+
+import traceback
+from pathlib import Path
+from typing import Optional
+
+from app.asr import Transcriber, load_transcript, save_transcript
+from app.audio_utils import AUDIO_EXTS, normalize_to_wav
+from app.chunking import chunk_transcript
+from app.config import Config, get_config
+from app.manifest import Manifest
+from app.models import Passage, file_content_hash, make_recording_id
+from app.store import Store
+
+
+class Pipeline:
+    """Holds the heavy models so they load once and are reused across all files."""
+
+    def __init__(self, cfg: Optional[Config] = None):
+        self.cfg = cfg or get_config()
+        self.cfg.ensure_dirs()
+        self.store = Store(self.cfg)
+        self._transcriber: Optional[Transcriber] = None
+        self._embedder = None
+        self._translator = None
+
+    @property
+    def transcriber(self) -> Transcriber:
+        if self._transcriber is None:
+            self._transcriber = Transcriber(self.cfg)
+        return self._transcriber
+
+    @property
+    def embedder(self):
+        if self._embedder is None:
+            from app.embed import Embedder
+
+            self._embedder = Embedder(self.cfg)
+        return self._embedder
+
+    @property
+    def translator(self):
+        if self._translator is None:
+            from app.translate import Translator
+
+            self._translator = Translator(self.cfg)
+        return self._translator
+
+    # ---- per-file processing -------------------------------------------
+    def process(self, content_hash: str, abs_path: str, rel_path: str, manifest: Manifest) -> int:
+        rid = make_recording_id(content_hash)
+        work = self.cfg.work_dir
+        wav_path = work / f"{rid}.wav"
+        transcript_path = work / f"{rid}.json"
+
+        # 1. normalize (cache)
+        if not wav_path.exists():
+            normalize_to_wav(abs_path, wav_path)
+        manifest.set_status(content_hash, "normalized")
+
+        # 2. transcribe + align (cache the transcript JSON)
+        if transcript_path.exists():
+            transcript = load_transcript(transcript_path)
+        else:
+            transcript = self.transcriber.transcribe(wav_path)
+            save_transcript(transcript, transcript_path)
+        manifest.set_status(content_hash, "transcribed", duration_s=transcript.get("duration"))
+
+        # 3. chunk
+        passages = chunk_transcript(transcript, rid, rel_path, self.cfg)
+        manifest.set_status(content_hash, "chunked", n_chunks=len(passages))
+        if not passages:
+            manifest.set_status(content_hash, "indexed", n_chunks=0)
+            return 0
+
+        # 4. optional translation for English snippets
+        if self.cfg.translation["enabled"]:
+            try:
+                glosses = self.translator.translate([p.hindi_text for p in passages])
+                for p, g in zip(passages, glosses):
+                    p.english_gloss = g
+            except Exception as exc:  # noqa: BLE001 — translation is non-essential
+                print(f"[ingest] translation skipped for {rel_path}: {exc}")
+
+        # 5. embed
+        vectors = self.embedder.embed_passages([p.hindi_text for p in passages])
+        manifest.set_status(content_hash, "embedded")
+
+        # 6. index (idempotent: clear any prior rows for this recording first)
+        self.store.delete_recording(rid)
+        self.store.upsert_passages(passages, vectors)
+        manifest.set_status(content_hash, "indexed", n_chunks=len(passages))
+        return len(passages)
+
+
+def scan_audio_dir(manifest: Manifest, cfg: Optional[Config] = None) -> int:
+    """Register any new audio files in the manifest. Returns count of newly added."""
+    cfg = cfg or get_config()
+    audio_dir = cfg.audio_dir
+    audio_dir.mkdir(parents=True, exist_ok=True)
+    new = 0
+    for path in sorted(audio_dir.rglob("*")):
+        if not path.is_file() or path.suffix.lower() not in AUDIO_EXTS:
+            continue
+        rel = path.relative_to(audio_dir).as_posix()
+        h = file_content_hash(str(path))
+        if manifest.upsert_file(h, rel, str(path)):
+            new += 1
+    return new
+
+
+def run_ingest(
+    cfg: Optional[Config] = None,
+    limit: Optional[int] = None,
+    optimize_every: int = 25,
+    include_failed: bool = False,
+) -> dict:
+    """Scan + process all pending files. Safe to interrupt and re-run."""
+    cfg = cfg or get_config()
+    cfg.ensure_dirs()
+    manifest = Manifest(cfg.manifest_path)
+    pipe = Pipeline(cfg)
+
+    added = scan_audio_dir(manifest, cfg)
+    pending = manifest.pending(include_failed=include_failed)
+    if limit:
+        pending = pending[:limit]
+    print(f"[ingest] {added} new file(s) found; {len(pending)} to process")
+
+    done = failed = 0
+    for idx, row in enumerate(pending, 1):
+        h, rel, ap = row["content_hash"], row["rel_path"], row["abs_path"]
+        print(f"[ingest] ({idx}/{len(pending)}) {rel}")
+        try:
+            n = pipe.process(h, ap, rel, manifest)
+            done += 1
+            print(f"          -> indexed {n} passage(s)")
+        except Exception as exc:  # noqa: BLE001 — isolate per-file failures
+            failed += 1
+            manifest.set_status(h, "failed", error=f"{exc}")
+            print(f"          -> FAILED: {exc}")
+            traceback.print_exc()
+        if idx % optimize_every == 0:
+            pipe.store.optimize()
+
+    pipe.store.optimize()
+    if cfg.search["hybrid"]:
+        pipe.store.ensure_fts_index()
+    counts = manifest.counts()
+    manifest.close()
+    summary = {"new_files": added, "processed": done, "failed": failed, "manifest": counts}
+    print(f"[ingest] done: {summary}")
+    return summary

app/manifest.py

@@ -0,0 +1,139 @@
+"""SQLite manifest — the source of truth for what has been ingested.
+
+Keyed on the file's **content hash** (not its path), so moving or renaming a recording
+never triggers a re-transcribe. Each file walks through a status ladder; the bulk
+ingest loop simply re-processes anything whose status is below ``indexed`` (and not
+``failed``), which makes the whole multi-day run trivially resumable: kill it any time,
+restart, and it continues where it left off.
+"""
+from __future__ import annotations
+
+import sqlite3
+import time
+from pathlib import Path
+from typing import Dict, List, Optional
+
+# Ordered ladder. A file is "done" only at INDEXED. FAILED is terminal (until retried).
+STATUS_LADDER = ["pending", "normalized", "transcribed", "chunked", "embedded", "indexed"]
+STATUS_FAILED = "failed"
+STATUS_DONE = "indexed"
+
+
+def _now() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%S")
+
+
+class Manifest:
+    def __init__(self, db_path: str | Path):
+        self.db_path = str(db_path)
+        Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
+        self.conn = sqlite3.connect(self.db_path)
+        self.conn.row_factory = sqlite3.Row
+        self.conn.execute("PRAGMA journal_mode=WAL;")
+        self._init_db()
+
+    def _init_db(self) -> None:
+        self.conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS files (
+                content_hash TEXT PRIMARY KEY,
+                rel_path     TEXT NOT NULL,
+                abs_path     TEXT NOT NULL,
+                duration_s   REAL,
+                status       TEXT NOT NULL DEFAULT 'pending',
+                error        TEXT,
+                n_chunks     INTEGER DEFAULT 0,
+                added_at     TEXT,
+                updated_at   TEXT
+            )
+            """
+        )
+        self.conn.execute("CREATE INDEX IF NOT EXISTS idx_status ON files(status);")
+        self.conn.commit()
+
+    # ---- writes ---------------------------------------------------------
+    def upsert_file(self, content_hash: str, rel_path: str, abs_path: str) -> bool:
+        """Register a file. Returns True if it's new (caller may process it)."""
+        row = self.get(content_hash)
+        now = _now()
+        if row is None:
+            self.conn.execute(
+                "INSERT INTO files (content_hash, rel_path, abs_path, status, added_at, updated_at) "
+                "VALUES (?, ?, ?, 'pending', ?, ?)",
+                (content_hash, rel_path, abs_path, now, now),
+            )
+            self.conn.commit()
+            return True
+        # Known file: keep status, but refresh path if it moved.
+        if row["abs_path"] != abs_path or row["rel_path"] != rel_path:
+            self.conn.execute(
+                "UPDATE files SET rel_path=?, abs_path=?, updated_at=? WHERE content_hash=?",
+                (rel_path, abs_path, now, content_hash),
+            )
+            self.conn.commit()
+        return False
+
+    def set_status(
+        self,
+        content_hash: str,
+        status: str,
+        *,
+        error: Optional[str] = None,
+        duration_s: Optional[float] = None,
+        n_chunks: Optional[int] = None,
+    ) -> None:
+        sets = ["status=?", "updated_at=?"]
+        vals: List[object] = [status, _now()]
+        if error is not None:
+            sets.append("error=?")
+            vals.append(error)
+        if duration_s is not None:
+            sets.append("duration_s=?")
+            vals.append(duration_s)
+        if n_chunks is not None:
+            sets.append("n_chunks=?")
+            vals.append(n_chunks)
+        vals.append(content_hash)
+        self.conn.execute(f"UPDATE files SET {', '.join(sets)} WHERE content_hash=?", vals)
+        self.conn.commit()
+
+    def remove(self, content_hash: str) -> None:
+        self.conn.execute("DELETE FROM files WHERE content_hash=?", (content_hash,))
+        self.conn.commit()
+
+    # ---- reads ----------------------------------------------------------
+    def get(self, content_hash: str) -> Optional[sqlite3.Row]:
+        cur = self.conn.execute("SELECT * FROM files WHERE content_hash=?", (content_hash,))
+        return cur.fetchone()
+
+    def pending(self, include_failed: bool = False) -> List[sqlite3.Row]:
+        """Files that still need work (status below 'indexed')."""
+        if include_failed:
+            cur = self.conn.execute(
+                "SELECT * FROM files WHERE status != ? ORDER BY added_at", (STATUS_DONE,)
+            )
+        else:
+            cur = self.conn.execute(
+                "SELECT * FROM files WHERE status != ? AND status != ? ORDER BY added_at",
+                (STATUS_DONE, STATUS_FAILED),
+            )
+        return cur.fetchall()
+
+    def all(self) -> List[sqlite3.Row]:
+        return self.conn.execute("SELECT * FROM files ORDER BY added_at").fetchall()
+
+    def known_hashes(self) -> set:
+        return {r["content_hash"] for r in self.conn.execute("SELECT content_hash FROM files")}
+
+    def counts(self) -> Dict[str, int]:
+        cur = self.conn.execute("SELECT status, COUNT(*) c FROM files GROUP BY status")
+        return {r["status"]: r["c"] for r in cur.fetchall()}
+
+    def close(self) -> None:
+        self.conn.close()
+
+    def __enter__(self) -> "Manifest":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()

app/models.py

@@ -0,0 +1,86 @@
+"""Shared data structures passed between pipeline stages.
+
+A ``Passage`` is one searchable unit: a sentence-packed window of transcript with a
+precise [start_ms, end_ms] span inside one recording. It is what we embed, index, and
+return to the UI (so the player can seek straight to ``start_ms``).
+"""
+from __future__ import annotations
+
+import hashlib
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+def make_recording_id(content_hash: str) -> str:
+    """Short, stable id for a recording, derived from its content hash."""
+    return content_hash[:16]
+
+
+def make_passage_id(recording_id: str, start_ms: int) -> str:
+    """Stable id for a passage (unique within the corpus, deterministic on re-ingest)."""
+    return f"{recording_id}:{start_ms:09d}"
+
+
+@dataclass
+class Passage:
+    id: str
+    recording_id: str
+    source_file: str          # path relative to the audio_dir (used to build the audio URL)
+    start_ms: int
+    end_ms: int
+    hindi_text: str
+    n_words: int = 0
+    english_gloss: str = ""    # filled only when translation is enabled
+
+    def to_row(self) -> Dict[str, Any]:
+        """Row dict for LanceDB (vector is added separately at index time)."""
+        return asdict(self)
+
+    @staticmethod
+    def from_words(
+        recording_id: str,
+        source_file: str,
+        words: List[Dict[str, Any]],
+        text: str,
+    ) -> "Passage":
+        start_ms = int(round(words[0]["start"] * 1000))
+        end_ms = int(round(words[-1]["end"] * 1000))
+        return Passage(
+            id=make_passage_id(recording_id, start_ms),
+            recording_id=recording_id,
+            source_file=source_file,
+            start_ms=start_ms,
+            end_ms=end_ms,
+            hindi_text=text.strip(),
+            n_words=len(words),
+        )
+
+
+@dataclass
+class SearchResult:
+    recording_id: str
+    source_file: str
+    start_ms: int
+    end_ms: int
+    hindi_text: str
+    english_gloss: str
+    score: float
+    rerank_score: Optional[float] = None
+
+    @property
+    def start_seconds(self) -> float:
+        return self.start_ms / 1000.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d["start_seconds"] = round(self.start_seconds, 2)
+        return d
+
+
+def file_content_hash(path: str, chunk_size: int = 1 << 20) -> str:
+    """SHA-256 of the file's bytes. Keys the manifest so renames don't re-transcribe."""
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(chunk_size), b""):
+            h.update(block)
+    return h.hexdigest()

app/query.py

@@ -0,0 +1,112 @@
+"""Query side: text or Hindi-audio -> ranked moments.
+
+  text query  -> bge-m3 embed -> LanceDB (dense-dominant hybrid) -> bge-reranker -> top-k
+  audio query -> ffmpeg -> faster-whisper(hi) -> Hindi text -> (same as above)
+
+An English query matches Hindi passages natively in bge-m3's shared space, so there is no
+query-time translation. The reranker reads (query, Hindi passage) pairs together and is
+the main precision lever.
+"""
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from app.config import Config, get_config
+from app.models import SearchResult
+from app.store import Store
+
+
+class Searcher:
+    def __init__(self, cfg: Optional[Config] = None):
+        self.cfg = cfg or get_config()
+        self.store = Store(self.cfg)
+        self._embedder = None
+        self._reranker = None
+        self._transcriber = None
+
+    @property
+    def embedder(self):
+        if self._embedder is None:
+            from app.embed import Embedder
+
+            self._embedder = Embedder(self.cfg)
+        return self._embedder
+
+    @property
+    def reranker(self):
+        if self._reranker is None:
+            from app.rerank import Reranker
+
+            self._reranker = Reranker(self.cfg)
+        return self._reranker
+
+    @property
+    def transcriber(self):
+        if self._transcriber is None:
+            from app.asr import Transcriber
+
+            self._transcriber = Transcriber(self.cfg)
+        return self._transcriber
+
+    # ---- text search ----------------------------------------------------
+    def search_text(self, query: str, top_k: Optional[int] = None) -> List[SearchResult]:
+        query = (query or "").strip()
+        if not query:
+            return []
+        top_k = top_k or self.cfg.search["top_k"]
+        use_rerank = self.reranker.enabled
+        pool = max(self.cfg.reranker["candidates"], top_k) if use_rerank else top_k
+
+        qvec = self.embedder.embed_query(query)
+        rows = self.store.search(
+            qvec,
+            query_text=query,
+            k=pool,
+            hybrid=bool(self.cfg.search["hybrid"]),
+            vector_weight=float(self.cfg.search["vector_weight"]),
+            candidate_pool=max(pool, 80),
+        )
+        if not rows:
+            return []
+
+        if use_rerank:
+            scores = self.reranker.scores(query, [r["hindi_text"] for r in rows])
+            for r, s in zip(rows, scores):
+                r["rerank_score"] = s
+            rows.sort(key=lambda r: r.get("rerank_score", 0.0), reverse=True)
+
+        rows = rows[:top_k]
+        return [self._to_result(r) for r in rows]
+
+    # ---- audio search ---------------------------------------------------
+    def search_audio(self, audio_path: str | Path, top_k: Optional[int] = None) -> Tuple[str, List[SearchResult]]:
+        """Transcribe a Hindi clip, then search. Returns (recognized_text, results)."""
+        from app.audio_utils import normalize_to_wav
+
+        with tempfile.TemporaryDirectory() as tmp:
+            wav = Path(tmp) / "query.wav"
+            normalize_to_wav(audio_path, wav)
+            text = self.transcriber.transcribe_query(wav)
+        results = self.search_text(text, top_k=top_k) if text.strip() else []
+        return text, results
+
+    # ---- helpers --------------------------------------------------------
+    @staticmethod
+    def _to_result(r: dict) -> SearchResult:
+        # Prefer the reranker score, else the dense cosine (nice 0..1 for display);
+        # fused RRF score is only a last resort (tiny values, ranking-only).
+        score = r.get("rerank_score")
+        if score is None:
+            score = r.get("score", r.get("fused_score", 0.0))
+        return SearchResult(
+            recording_id=r["recording_id"],
+            source_file=r["source_file"],
+            start_ms=int(r["start_ms"]),
+            end_ms=int(r["end_ms"]),
+            hindi_text=r.get("hindi_text", ""),
+            english_gloss=r.get("english_gloss", ""),
+            score=float(score),
+            rerank_score=(float(r["rerank_score"]) if "rerank_score" in r else None),
+        )

app/rerank.py

@@ -0,0 +1,44 @@
+"""Cross-encoder reranking via BAAI/bge-reranker-v2-m3.
+
+Dense retrieval is great for recall but ranks by a single vector dot-product. A
+cross-encoder reads (query, passage) **together** and scores true relevance — the single
+biggest precision lever for cross-lingual search. We only score the top ~80 candidates,
+so it's cheap. ``normalize=True`` squashes scores to 0..1 (sigmoid) for nice display.
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from app.config import Config, get_config
+
+
+class Reranker:
+    def __init__(self, cfg: Optional[Config] = None):
+        self.cfg = cfg or get_config()
+        self._model = None
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.cfg.reranker["enabled"])
+
+    def _load(self):
+        if self._model is not None:
+            return self._model
+        from FlagEmbedding import FlagReranker
+
+        r = self.cfg.reranker
+        self._model = FlagReranker(r["model"], use_fp16=bool(r["use_fp16"]))
+        return self._model
+
+    def scores(self, query: str, passages: List[str]) -> List[float]:
+        """Relevance score (0..1) for each passage against the query."""
+        if not passages:
+            return []
+        model = self._load()
+        pairs = [[query, p] for p in passages]
+        out = model.compute_score(
+            pairs, batch_size=self.cfg.reranker["batch_size"], normalize=True
+        )
+        if isinstance(out, (int, float)):
+            return [float(out)]
+        return [float(x) for x in out]

app/server.py

@@ -0,0 +1,135 @@
+"""Local FastAPI app: search box + clickable, seekable results.
+
+Endpoints
+  GET  /                 -> the search page
+  POST /api/search       -> {query, top_k} -> ranked moments (JSON)
+  POST /api/query_audio  -> multipart audio file -> {text, results}
+  GET  /api/stats        -> index / manifest stats
+  GET  {audio_route}/... -> the original recordings, served with HTTP Range so the
+                            <audio> element seeks instantly to a timestamp.
+
+Run:  python -m app.server     (or)    uvicorn app.server:app --host 127.0.0.1 --port 8000
+"""
+from __future__ import annotations
+
+import sys
+import tempfile
+from pathlib import Path
+from urllib.parse import quote
+
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from app.config import get_config
+from app.manifest import Manifest
+from app.query import Searcher
+from app import audio_source
+
+if sys.platform == "win32":  # make sure Devanagari prints fine in the console
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[attr-defined]
+    except Exception:  # noqa: BLE001
+        pass
+
+cfg = get_config()
+cfg.ensure_dirs()
+WEB_DIR = Path(__file__).parent / "web"
+AUDIO_ROUTE = cfg.server["audio_route"]
+AUDIO_MODE = (cfg.get("audio", {}) or {}).get("mode", "local")
+
+app = FastAPI(title="SearchAudio", version="0.1.0")
+_searcher = Searcher(cfg)
+
+# Static assets. StaticFiles speaks HTTP Range, so seeking is instant.
+app.mount("/static", StaticFiles(directory=str(WEB_DIR)), name="static")
+# Local audio is served from disk only in local mode; archive mode streams from archive.org.
+if AUDIO_MODE == "local":
+    app.mount(AUDIO_ROUTE, StaticFiles(directory=str(cfg.audio_dir)), name="audio")
+
+
+def _audio_url(source_file: str) -> str:
+    return audio_source.audio_url(source_file, cfg)
+
+
+def _result_payload(results) -> list:
+    out = []
+    for r in results:
+        d = r.to_dict()
+        d["audio_url"] = _audio_url(r.source_file)
+        out.append(d)
+    return out
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(str(WEB_DIR / "index.html"))
+
+
+@app.post("/api/search")
+def api_search(payload: dict) -> JSONResponse:
+    query = (payload or {}).get("query", "")
+    top_k = (payload or {}).get("top_k")
+    results = _searcher.search_text(query, top_k=top_k)
+    return JSONResponse({"query": query, "count": len(results), "results": _result_payload(results)})
+
+
+async def api_query_audio(file: UploadFile = File(...), top_k: int = Form(None)) -> JSONResponse:
+    suffix = Path(file.filename or "clip.webm").suffix or ".webm"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        tmp.write(await file.read())
+        tmp_path = tmp.name
+    try:
+        text, results = _searcher.search_audio(tmp_path, top_k=top_k)
+    finally:
+        try:
+            Path(tmp_path).unlink(missing_ok=True)
+        except Exception:  # noqa: BLE001
+            pass
+    return JSONResponse({"text": text, "count": len(results), "results": _result_payload(results)})
+
+
+# Register the audio-query route ONLY in local mode. In archive/online mode the route is
+# absent (POST -> 404) and app.asr / whisperx are never imported (keeps the image slim).
+if AUDIO_MODE == "local":
+    app.post("/api/query_audio")(api_query_audio)
+
+
+@app.get("/api/config")
+def api_config() -> JSONResponse:
+    return JSONResponse({"mode": AUDIO_MODE, "audio_query": AUDIO_MODE == "local"})
+
+
+@app.get("/api/stats")
+def api_stats() -> JSONResponse:
+    manifest = Manifest(cfg.manifest_path)
+    counts = manifest.counts()
+    manifest.close()
+    try:
+        n_passages = _searcher.store.count()
+    except Exception:  # noqa: BLE001
+        n_passages = 0
+    return JSONResponse(
+        {
+            "files": counts,
+            "passages": n_passages,
+            "reranker": bool(cfg.reranker["enabled"]),
+            "hybrid": bool(cfg.search["hybrid"]),
+        }
+    )
+
+
+def run() -> None:
+    import uvicorn
+
+    uvicorn.run(
+        "app.server:app",
+        host=cfg.server["host"],
+        port=int(cfg.server["port"]),
+        workers=1,  # ONE GPU worker: never load the models N times into VRAM
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    run()

app/store.py

@@ -0,0 +1,223 @@
+"""LanceDB vector store for transcript passages.
+
+Design choices:
+  * **Vector search is the reliable core** (exact/flat search is sub-second well past 1M
+    rows). Cross-lingual recall comes entirely from the dense bge-m3 vectors.
+  * **Hybrid (BM25) is a best-effort boost.** BM25 can't bridge English->Devanagari, so
+    if the FTS index can't be built on this LanceDB version it's simply skipped and we
+    fall back to pure vector search — still fully functional. When available, dense and
+    sparse hits are fused with a dense-dominant RRF in Python (no reliance on the
+    version-sensitive LanceDB hybrid+reranker API).
+  * Upsert via ``merge_insert`` keyed on the passage ``id`` (idempotent re-ingest);
+    delete-by-recording for clean re-processing.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from app.config import Config, get_config
+from app.models import Passage
+
+TABLE_NAME = "passages"
+
+
+def _schema(dim: int):
+    import pyarrow as pa
+
+    return pa.schema(
+        [
+            pa.field("id", pa.string()),
+            pa.field("recording_id", pa.string()),
+            pa.field("source_file", pa.string()),
+            pa.field("start_ms", pa.int64()),
+            pa.field("end_ms", pa.int64()),
+            pa.field("hindi_text", pa.string()),
+            pa.field("english_gloss", pa.string()),
+            pa.field("n_words", pa.int64()),
+            pa.field("vector", pa.list_(pa.float32(), dim)),
+        ]
+    )
+
+
+class Store:
+    def __init__(self, cfg: Optional[Config] = None):
+        self.cfg = cfg or get_config()
+        self.dim = int(self.cfg.embedding["dim"])
+        self.uri = str(self.cfg.lancedb_dir)
+        Path(self.uri).mkdir(parents=True, exist_ok=True)
+        self._db = None
+        self._table = None
+        self._fts_ready = False
+
+    # ---- connection -----------------------------------------------------
+    def _connect(self):
+        if self._db is None:
+            import lancedb
+
+            self._db = lancedb.connect(self.uri)
+        return self._db
+
+    def table(self):
+        if self._table is not None:
+            return self._table
+        db = self._connect()
+        if TABLE_NAME in db.table_names():
+            self._table = db.open_table(TABLE_NAME)
+        else:
+            self._table = db.create_table(TABLE_NAME, schema=_schema(self.dim))
+        return self._table
+
+    # ---- writes ---------------------------------------------------------
+    def _rows(self, passages: List[Passage], vectors: np.ndarray) -> List[Dict[str, Any]]:
+        rows = []
+        for p, v in zip(passages, vectors):
+            row = p.to_row()
+            row["vector"] = np.asarray(v, dtype=np.float32).tolist()
+            rows.append(row)
+        return rows
+
+    def upsert_passages(self, passages: List[Passage], vectors: np.ndarray) -> int:
+        """Insert or update passages keyed on id. Returns rows written."""
+        if not passages:
+            return 0
+        rows = self._rows(passages, vectors)
+        tbl = self.table()
+        try:
+            (
+                tbl.merge_insert("id")
+                .when_matched_update_all()
+                .when_not_matched_insert_all()
+                .execute(rows)
+            )
+        except Exception:  # noqa: BLE001 — older LanceDB: emulate upsert
+            ids = [r["id"] for r in rows]
+            id_list = ",".join("'" + i.replace("'", "''") + "'" for i in ids)
+            try:
+                tbl.delete(f"id IN ({id_list})")
+            except Exception:  # noqa: BLE001
+                pass
+            tbl.add(rows)
+        self._fts_ready = False  # index needs refresh after writes
+        return len(rows)
+
+    def delete_recording(self, recording_id: str) -> None:
+        tbl = self.table()
+        safe = recording_id.replace("'", "''")
+        tbl.delete(f"recording_id = '{safe}'")
+
+    def optimize(self) -> None:
+        try:
+            self.table().optimize()
+        except Exception:  # noqa: BLE001 — older versions: compact_files / no-op
+            try:
+                self.table().compact_files()
+            except Exception:  # noqa: BLE001
+                pass
+
+    def count(self) -> int:
+        try:
+            return self.table().count_rows()
+        except Exception:  # noqa: BLE001
+            return len(self.table().to_pandas())
+
+    def recording_ids(self) -> set:
+        try:
+            df = self.table().to_pandas()
+            return set(df["recording_id"].unique().tolist())
+        except Exception:  # noqa: BLE001
+            return set()
+
+    # ---- full-text index (best effort) ----------------------------------
+    def ensure_fts_index(self) -> bool:
+        """Create a BM25 FTS index on hindi_text (ICU tokenizer if supported)."""
+        if self._fts_ready:
+            return True
+        tbl = self.table()
+        attempts = [
+            dict(use_tantivy=False, tokenizer_name="icu", with_position=True, replace=True),
+            dict(use_tantivy=False, tokenizer_name="icu", replace=True),
+            dict(use_tantivy=False, replace=True),
+            dict(),  # bare default
+        ]
+        for kwargs in attempts:
+            try:
+                tbl.create_fts_index("hindi_text", **kwargs)
+                self._fts_ready = True
+                return True
+            except TypeError:
+                continue
+            except Exception:  # noqa: BLE001
+                continue
+        return False
+
+    # ---- search ---------------------------------------------------------
+    def search_vector(self, query_vec: np.ndarray, k: int) -> List[Dict[str, Any]]:
+        tbl = self.table()
+        q = np.asarray(query_vec, dtype=np.float32)
+        rows = tbl.search(q).limit(k).to_list()
+        for r in rows:
+            r.pop("vector", None)
+            dist = r.get("_distance")
+            # bge-m3 vectors are unit-norm -> cosine = 1 - L2^2 / 2
+            r["score"] = float(1.0 - dist / 2.0) if isinstance(dist, (int, float)) else 0.0
+        return rows
+
+    def search_fts(self, query_text: str, k: int) -> List[Dict[str, Any]]:
+        if not query_text.strip():
+            return []
+        if not self.ensure_fts_index():
+            return []
+        try:
+            rows = self.table().search(query_text, query_type="fts").limit(k).to_list()
+        except Exception:  # noqa: BLE001
+            return []
+        for r in rows:
+            r.pop("vector", None)
+        return rows
+
+    def search(
+        self,
+        query_vec: np.ndarray,
+        query_text: str = "",
+        k: int = 20,
+        hybrid: bool = True,
+        vector_weight: float = 0.7,
+        candidate_pool: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """Return up to k candidate rows (no rerank). Dense-dominant RRF fusion."""
+        pool = candidate_pool or max(k, 80)
+        dense = self.search_vector(query_vec, pool)
+        if not hybrid or not query_text.strip():
+            return dense[:k]
+        sparse = self.search_fts(query_text, pool)
+        if not sparse:
+            return dense[:k]
+        return _rrf_fuse(dense, sparse, vector_weight=vector_weight)[:k]
+
+
+def _rrf_fuse(
+    dense: List[Dict[str, Any]],
+    sparse: List[Dict[str, Any]],
+    rrf_k: int = 60,
+    vector_weight: float = 0.7,
+) -> List[Dict[str, Any]]:
+    scores: Dict[str, float] = {}
+    rows: Dict[str, Dict[str, Any]] = {}
+    for rank, r in enumerate(dense):
+        rid = r["id"]
+        rows[rid] = r
+        scores[rid] = scores.get(rid, 0.0) + vector_weight / (rrf_k + rank + 1)
+    for rank, r in enumerate(sparse):
+        rid = r["id"]
+        rows.setdefault(rid, r)
+        scores[rid] = scores.get(rid, 0.0) + (1.0 - vector_weight) / (rrf_k + rank + 1)
+    ordered = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)
+    out = []
+    for rid, s in ordered:
+        row = rows[rid]
+        row["fused_score"] = float(s)
+        out.append(row)
+    return out

app/translate.py

@@ -0,0 +1,78 @@
+"""Optional offline Hindi -> English translation via AI4Bharat IndicTrans2.
+
+Used ONLY to (a) show a readable English snippet next to each Hindi result so a
+non-Hindi reader can confirm relevance before listening, and (b) enable an English
+BM25 fallback. It is NOT used for primary retrieval (bge-m3 already matches English
+queries to Hindi text natively). Disabled by default; enable in config (``translation``)
+once IndicTrans2 + IndicTransToolkit are installed.
+
+Requires: ``transformers`` and ``IndicTransToolkit`` (``pip install IndicTransToolkit``).
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from app.config import Config, get_config
+
+_SRC_LANG = "hin_Deva"
+_TGT_LANG = "eng_Latn"
+
+
+class Translator:
+    def __init__(self, cfg: Optional[Config] = None):
+        self.cfg = cfg or get_config()
+        self._model = None
+        self._tok = None
+        self._proc = None
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.cfg.translation["enabled"])
+
+    def _load(self):
+        if self._model is not None:
+            return
+        import torch
+        from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+
+        try:
+            from IndicTransToolkit.processor import IndicProcessor
+        except Exception as exc:  # noqa: BLE001
+            raise RuntimeError(
+                "IndicTrans2 translation needs IndicTransToolkit. "
+                "Install it: pip install IndicTransToolkit"
+            ) from exc
+
+        name = self.cfg.translation["model"]
+        device = self.cfg.translation["device"]
+        self._tok = AutoTokenizer.from_pretrained(name, trust_remote_code=True)
+        model = AutoModelForSeq2SeqLM.from_pretrained(name, trust_remote_code=True)
+        if device == "cuda" and torch.cuda.is_available():
+            model = model.to("cuda").half()
+        self._model = model.eval()
+        self._proc = IndicProcessor(inference=True)
+        self._device = device if torch.cuda.is_available() else "cpu"
+
+    def translate(self, sentences: List[str], batch_size: int = 16) -> List[str]:
+        """Translate a list of Hindi sentences/passages to English."""
+        if not sentences:
+            return []
+        self._load()
+        import torch
+
+        results: List[str] = []
+        for i in range(0, len(sentences), batch_size):
+            batch = sentences[i : i + batch_size]
+            pre = self._proc.preprocess_batch(batch, src_lang=_SRC_LANG, tgt_lang=_TGT_LANG)
+            inputs = self._tok(
+                pre, truncation=True, padding="longest", return_tensors="pt", max_length=256
+            ).to(self._model.device)
+            with torch.no_grad():
+                generated = self._model.generate(
+                    **inputs, max_length=256, num_beams=5, num_return_sequences=1
+                )
+            decoded = self._tok.batch_decode(
+                generated, skip_special_tokens=True, clean_up_tokenization_spaces=True
+            )
+            results.extend(self._proc.postprocess_batch(decoded, lang=_TGT_LANG))
+        return results

app/web/app.js

@@ -0,0 +1,197 @@
+"use strict";
+
+const $ = (id) => document.getElementById(id);
+const qInput = $("q");
+const statusEl = $("status");
+const resultsEl = $("results");
+const playerBar = $("playerBar");
+const player = $("player");
+const npTitle = $("npTitle");
+
+// ---- helpers ----------------------------------------------------------
+function fmtTime(sec) {
+  sec = Math.max(0, Math.floor(sec));
+  const h = Math.floor(sec / 3600);
+  const m = Math.floor((sec % 3600) / 60);
+  const s = sec % 60;
+  const mm = String(m).padStart(2, "0");
+  const ss = String(s).padStart(2, "0");
+  return h > 0 ? `${h}:${mm}:${ss}` : `${m}:${ss}`;
+}
+
+function baseName(path) {
+  const p = path.split("/");
+  return decodeURIComponent(p[p.length - 1]);
+}
+
+function setStatus(html) { statusEl.innerHTML = html; }
+function busy(html) { setStatus(`<span class="spinner"></span> ${html}`); }
+
+// Escape user-/ASR-supplied text before putting it inside an innerHTML string.
+function esc(s) {
+  return String(s == null ? "" : s)
+    .replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+
+// ---- playback ---------------------------------------------------------
+function playAt(audioUrl, startSeconds, label) {
+  // The #t media-fragment makes the browser seek on load; Range requests make it instant.
+  player.src = `${audioUrl}#t=${startSeconds}`;
+  npTitle.textContent = `${label} @ ${fmtTime(startSeconds)}`;
+  playerBar.classList.remove("hidden");
+  player.load();
+  player.play().catch(() => {/* user gesture already present from the click */});
+}
+
+// ---- rendering --------------------------------------------------------
+function render(results) {
+  resultsEl.innerHTML = "";
+  if (!results || results.length === 0) {
+    resultsEl.innerHTML = `<div class="empty">No matching moments found. Try rephrasing the topic.</div>`;
+    return;
+  }
+  for (const r of results) {
+    const card = document.createElement("div");
+    card.className = "card";
+
+    const row1 = document.createElement("div");
+    row1.className = "row1";
+
+    const jump = document.createElement("button");
+    jump.className = "jump";
+    jump.textContent = `▶ ${fmtTime(r.start_seconds)}`;
+    jump.onclick = () => playAt(r.audio_url, r.start_seconds, baseName(r.source_file));
+
+    const file = document.createElement("span");
+    file.className = "file";
+    file.textContent = baseName(r.source_file);
+
+    const score = document.createElement("span");
+    score.className = "scorepill";
+    score.textContent = (r.score != null ? (r.score * 100).toFixed(0) : "--") + "%";
+    score.title = "relevance";
+
+    row1.append(jump, file, score);
+
+    const hi = document.createElement("div");
+    hi.className = "hi-text";
+    hi.textContent = r.hindi_text || "";
+
+    card.append(row1, hi);
+
+    if (r.english_gloss) {
+      const en = document.createElement("div");
+      en.className = "en-gloss";
+      en.textContent = r.english_gloss;
+      card.append(en);
+    }
+    // clicking anywhere on the card also jumps
+    card.onclick = (e) => { if (e.target !== jump) playAt(r.audio_url, r.start_seconds, baseName(r.source_file)); };
+    resultsEl.append(card);
+  }
+}
+
+// ---- text search ------------------------------------------------------
+async function doSearch() {
+  const query = qInput.value.trim();
+  if (!query) { qInput.focus(); return; }
+  busy(`Searching for “${esc(query)}”…`);
+  resultsEl.innerHTML = "";
+  try {
+    const resp = await fetch("/api/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query }),
+    });
+    const data = await resp.json();
+    setStatus(`Found <b>${data.count}</b> moment(s) for “${esc(query)}”.`);
+    render(data.results);
+  } catch (err) {
+    setStatus(`Search failed: ${err}`);
+  }
+}
+
+// ---- audio query (mic + upload) --------------------------------------
+let mediaRecorder = null;
+let chunks = [];
+
+async function toggleMic() {
+  const micBtn = $("micBtn");
+  if (mediaRecorder && mediaRecorder.state === "recording") {
+    mediaRecorder.stop();
+    return;
+  }
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    mediaRecorder = new MediaRecorder(stream);
+    chunks = [];
+    mediaRecorder.ondataavailable = (e) => { if (e.data.size > 0) chunks.push(e.data); };
+    mediaRecorder.onstop = async () => {
+      stream.getTracks().forEach((t) => t.stop());
+      micBtn.classList.remove("recording");
+      const blob = new Blob(chunks, { type: "audio/webm" });
+      await sendAudio(blob, "clip.webm");
+    };
+    mediaRecorder.start();
+    micBtn.classList.add("recording");
+    busy("Recording… click the mic again to stop and search.");
+  } catch (err) {
+    setStatus(`Microphone unavailable: ${err}`);
+  }
+}
+
+async function sendAudio(blob, filename) {
+  busy("Transcribing your Hindi clip and searching…");
+  resultsEl.innerHTML = "";
+  const fd = new FormData();
+  fd.append("file", blob, filename);
+  try {
+    const resp = await fetch("/api/query_audio", { method: "POST", body: fd });
+    const data = await resp.json();
+    const recog = data.text ? `Heard: <span class="recog">${esc(data.text)}</span> — ` : "";
+    setStatus(`${recog}found <b>${data.count}</b> moment(s).`);
+    if (data.text) qInput.value = data.text;
+    render(data.results);
+  } catch (err) {
+    setStatus(`Audio search failed: ${err}`);
+  }
+}
+
+// ---- stats ------------------------------------------------------------
+async function loadStats() {
+  try {
+    const data = await (await fetch("/api/stats")).json();
+    const indexed = (data.files && data.files.indexed) || 0;
+    const failed = (data.files && data.files.failed) || 0;
+    let s = `<b>${data.passages.toLocaleString()}</b> passages · <b>${indexed}</b> recordings indexed`;
+    if (failed) s += ` · ${failed} failed`;
+    s += data.reranker ? " · reranker on" : "";
+    $("stats").innerHTML = s;
+  } catch { /* ignore */ }
+}
+
+// ---- deployment config (hide audio-query controls when text-only) -----
+async function applyConfig() {
+  try {
+    const cfg = await (await fetch("/api/config")).json();
+    if (!cfg.audio_query) {
+      const mic = document.getElementById("micBtn");
+      const up = document.getElementById("uploadLabel");
+      if (mic) mic.style.display = "none";
+      if (up) up.style.display = "none";
+    }
+  } catch { /* default to showing controls */ }
+}
+
+// ---- wire up ----------------------------------------------------------
+$("searchBtn").onclick = doSearch;
+qInput.addEventListener("keydown", (e) => { if (e.key === "Enter") doSearch(); });
+$("micBtn").onclick = toggleMic;
+$("uploadInput").addEventListener("change", (e) => {
+  const f = e.target.files[0];
+  if (f) sendAudio(f, f.name);
+});
+applyConfig();
+loadStats();
+qInput.focus();

app/web/index.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>SearchAudio — find the moment</title>
+  <link rel="stylesheet" href="/static/styles.css" />
+</head>
+<body>
+  <header class="topbar">
+    <div class="brand">
+      <span class="logo">🎧</span>
+      <div>
+        <h1>SearchAudio</h1>
+        <p class="tagline">Search Hindi talks in English — jump straight to the moment.</p>
+      </div>
+    </div>
+    <div id="stats" class="stats"></div>
+  </header>
+
+  <main>
+    <section class="searchbar">
+      <input id="q" type="text" autocomplete="off"
+             placeholder="Describe a topic in English or Hindi… e.g. “What is the meaning of true happiness?”" />
+      <button id="searchBtn" class="primary">Search</button>
+      <button id="micBtn" title="Search by speaking a Hindi clip">🎤</button>
+      <label id="uploadLabel" class="ghost" title="Search by uploading a Hindi audio clip">
+        ⬆ Audio
+        <input id="uploadInput" type="file" accept="audio/*" hidden />
+      </label>
+    </section>
+
+    <p id="status" class="status"></p>
+    <div id="results" class="results"></div>
+  </main>
+
+  <div id="playerBar" class="playerbar hidden">
+    <div class="np">
+      <strong>Now playing:</strong> <span id="npTitle">—</span>
+    </div>
+    <audio id="player" controls preload="none"></audio>
+  </div>
+
+  <script src="/static/app.js"></script>
+</body>
+</html>