getbased-rag 0.6.1__py3-none-any.whl

lens/config.py

@@ -0,0 +1,147 @@
+"""Configuration for getbased Lens."""
+
+import os
+import sys
+from pathlib import Path
+from dataclasses import dataclass, field
+
+
+def _default_data_dir() -> Path:
+    """Default data directory — platform-specific, matches what Tauri's
+    dirs::data_dir() crate returns so the CLI and the desktop app share one
+    location. A user running `lens serve` from their shell sees the same DB
+    that the Tauri app writes to.
+
+      Linux:   $XDG_DATA_HOME/getbased/lens  or  ~/.local/share/getbased/lens
+      macOS:   ~/Library/Application Support/getbased/lens
+      Windows: %APPDATA%\\getbased\\lens
+
+    If the legacy ~/.getbased/lens/ exists (pre-v1.21 installs) and the new
+    path does not, we honor the legacy path to avoid orphaning user data.
+    """
+    home = Path.home()
+    legacy = home / ".getbased" / "lens"
+
+    if sys.platform == "darwin":
+        new_default = home / "Library" / "Application Support" / "getbased" / "lens"
+    elif sys.platform.startswith("win"):
+        appdata = os.environ.get("APPDATA")
+        new_default = (Path(appdata) if appdata else home / "AppData" / "Roaming") / "getbased" / "lens"
+    else:
+        xdg = os.environ.get("XDG_DATA_HOME")
+        new_default = (Path(xdg) if xdg else home / ".local" / "share") / "getbased" / "lens"
+
+    if not new_default.exists() and legacy.exists():
+        return legacy
+    return new_default
+
+
+@dataclass
+class LensConfig:
+    """All Lens configuration, loaded from environment variables."""
+
+    # Server. Default to loopback only — exposing RAG to LAN by default would
+    # leak knowledge-base queries to anyone on the local network. Override via
+    # LENS_HOST=0.0.0.0 if you explicitly want LAN access.
+    host: str = "127.0.0.1"
+    port: int = 8322
+
+    # Data
+    data_dir: Path = field(default_factory=_default_data_dir)
+    api_key_file: Path = field(default_factory=lambda: _default_data_dir() / "api_key")
+
+    # Collection
+    collection: str = "knowledge"
+
+    # Embeddings. Fully-qualified HF repo id so sentence-transformers always
+    # resolves to the same model regardless of where the lens runs (local
+    # shell vs Tauri-spawned). The bare "all-MiniLM-L6-v2" short name is
+    # also accepted by ST but routes through a different lookup path.
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"  # ~90MB, 384d, fast on CPU
+    similarity_floor: float = 0.55
+
+    # Qdrant backend
+    qdrant_mode: str = "local"  # "local" or "cloud"
+    qdrant_cloud_url: str = ""
+    qdrant_cloud_key: str = ""
+
+    # Cloud inference (Qdrant Cloud embeds for you — no local model needed)
+    cloud_inference: bool = False
+
+    # ONNX Runtime acceleration (set by Tauri wrapper)
+    onnx_provider: str = ""  # "cuda", "rocm", "openvino", "coreml", "cpu", or "" (auto)
+
+    # Reranker (optional, heavy on CPU)
+    reranker: bool = False
+    reranker_candidates: int = 30
+
+    # Response constraints
+    max_chunks: int = 10
+    max_chunk_chars: int = 4000
+    max_source_chars: int = 200
+    max_response_bytes: int = 32768
+
+    # Chunking
+    chunk_max_size: int = 800
+    chunk_min_size: int = 50
+    chunk_overlap: int = 50
+
+    @classmethod
+    def from_env(cls) -> "LensConfig":
+        """Load config from environment variables."""
+        data_dir = Path(os.environ.get("LENS_DATA_DIR", str(_default_data_dir())))
+
+        return cls(
+            host=os.environ.get("LENS_HOST", "127.0.0.1"),
+            port=int(os.environ.get("LENS_PORT", "8322")),
+            data_dir=data_dir,
+            api_key_file=Path(os.environ.get("LENS_API_KEY_FILE", str(data_dir / "api_key"))),
+            collection=os.environ.get("LENS_COLLECTION", "knowledge"),
+            embedding_model=os.environ.get(
+                "LENS_EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2"
+            ),
+            similarity_floor=float(os.environ.get("LENS_SIMILARITY_FLOOR", "0.55")),
+            qdrant_mode=os.environ.get("LENS_QDRANT_MODE", "local"),
+            qdrant_cloud_url=os.environ.get("LENS_QDRANT_CLOUD_URL", ""),
+            qdrant_cloud_key=os.environ.get("LENS_QDRANT_CLOUD_KEY", ""),
+            cloud_inference=os.environ.get("LENS_CLOUD_INFERENCE", "").lower() in ("1", "true", "yes"),
+            onnx_provider=os.environ.get("LENS_ONNX_PROVIDER", ""),
+            reranker=os.environ.get("LENS_RERANKER", "").lower() in ("1", "true", "yes"),
+            reranker_candidates=int(os.environ.get("LENS_RERANKER_CANDIDATES", "30")),
+            chunk_max_size=int(os.environ.get("LENS_CHUNK_MAX_SIZE", "800")),
+            chunk_min_size=int(os.environ.get("LENS_CHUNK_MIN_SIZE", "50")),
+            chunk_overlap=int(os.environ.get("LENS_CHUNK_OVERLAP", "50")),
+        )
+
+    @property
+    def qdrant_path(self) -> Path:
+        """Local Qdrant storage path."""
+        return self.data_dir / "qdrant"
+
+    @property
+    def is_cloud(self) -> bool:
+        return self.qdrant_mode == "cloud"
+
+    def ensure_dirs(self):
+        """Create data directories if they don't exist."""
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        self.api_key_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def display(self) -> str:
+        """Human-readable config display."""
+        lines = [
+            f"  host:              {self.host}",
+            f"  port:              {self.port}",
+            f"  data_dir:          {self.data_dir}",
+            f"  collection:        {self.collection}",
+            f"  embedding_model:   {self.embedding_model}",
+            f"  similarity_floor:  {self.similarity_floor}",
+            f"  qdrant_mode:       {self.qdrant_mode}",
+        ]
+        if self.is_cloud:
+            lines.append(f"  qdrant_cloud_url:  {self.qdrant_cloud_url}")
+            lines.append(f"  cloud_inference:   {self.cloud_inference}")
+        else:
+            lines.append(f"  qdrant_path:       {self.qdrant_path}")
+        lines.append(f"  reranker:          {self.reranker}")
+        return "getbased Lens Configuration:\n" + "\n".join(lines)

lens/embedder.py

@@ -0,0 +1,524 @@
+"""Embedding backends — ONNX Runtime, sentence-transformers, or Qdrant Cloud Inference.
+
+ABC design with lazy-loading, caching, and a factory function.
+The ONNX backend is preferred when available (set via LENS_ONNX_PROVIDER env var)
+because it's lighter than PyTorch and supports GPU acceleration directly.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from .config import LensConfig
+
+log = logging.getLogger("lens.embedder")
+
+
+def _platform_getbased_data_dirs() -> list[Path]:
+    """Default getbased data directories per platform — matches what Tauri uses.
+    Returns multiple candidates to handle dev (XDG) and bundled (platform-default) layouts.
+    """
+    home = Path.home()
+    paths = []
+    if sys.platform == "darwin":
+        # Tauri's dirs::data_dir() on macOS = ~/Library/Application Support
+        paths.append(home / "Library" / "Application Support" / "getbased" / "lens" / "models")
+    elif sys.platform.startswith("win"):
+        # Tauri's dirs::data_dir() on Windows = %APPDATA% (Roaming)
+        appdata = os.environ.get("APPDATA")
+        if appdata:
+            paths.append(Path(appdata) / "getbased" / "lens" / "models")
+    else:
+        # Linux: dirs::data_dir() = $XDG_DATA_HOME or ~/.local/share
+        xdg = os.environ.get("XDG_DATA_HOME")
+        if xdg:
+            paths.append(Path(xdg) / "getbased" / "lens" / "models")
+        paths.append(home / ".local" / "share" / "getbased" / "lens" / "models")
+    # Always include the legacy ~/.getbased/lens/models for back-compat
+    paths.append(home / ".getbased" / "lens" / "models")
+    return paths
+
+# ── ABC ────────────────────────────────────────────────────────────
+
+class Embedder(ABC):
+    """Abstract embedding interface."""
+
+    @abstractmethod
+    def encode(self, texts: list[str]) -> list[list[float]]:
+        """Encode a batch of texts into normalized vectors."""
+        ...
+
+    @abstractmethod
+    def dimension(self) -> int:
+        """Return the embedding dimensionality."""
+        ...
+
+    def info(self) -> dict:
+        """Return a small dict describing this backend — which engine,
+        which model, active provider, etc. Surfaces to the dashboard so
+        users can see at a glance what's doing the embedding work.
+        Subclasses override; default reports engine name only."""
+        return {"engine": self.__class__.__name__, "dimension": self.dimension()}
+
+
+# ── Known model dimensions ────────────────────────────────────────
+
+_MODEL_DIMS: dict[str, int] = {
+    "all-MiniLM-L6-v2": 384,
+    "all-MiniLM-L12-v2": 384,
+    "BAAI/bge-m3": 1024,
+    "BAAI/bge-small-en-v1.5": 384,
+    "BAAI/bge-base-en-v1.5": 768,
+    "BAAI/bge-large-en-v1.5": 1024,
+}
+
+
+# ── ONNX Runtime (preferred) ─────────────────────────────────────
+
+class OnnxEmbedder(Embedder):
+    """Embedding via ONNX Runtime — light, fast, GPU-accelerated.
+
+    Uses optimum (HuggingFace) to load ONNX-exported models with
+    provider selection: CUDA, ROCm, OpenVINO, CoreML, or CPU.
+
+    Provider is set via LENS_ONNX_PROVIDER env var (by Tauri wrapper).
+    Falls back to CPU if the requested provider isn't available.
+    """
+
+    # Map our provider names to onnxruntime provider strings
+    _PROVIDER_MAP: dict[str, list[str]] = {
+        "cuda": ["CUDAExecutionProvider", "CPUExecutionProvider"],
+        "rocm": ["ROCmExecutionProvider", "CPUExecutionProvider"],
+        "openvino": ["OpenVINOExecutionProvider", "CPUExecutionProvider"],
+        "coreml": ["CoreMLExecutionProvider", "CPUExecutionProvider"],
+        "cpu": ["CPUExecutionProvider"],
+    }
+
+    def __init__(self, model_name: str = "BAAI/bge-m3", provider: str = ""):
+        self._model_name = model_name
+        self._provider_name = provider
+        self._session = None
+        self._tokenizer = None
+        self._dim: int | None = None
+
+    # lazy init --------------------------------------------------------
+
+    def _load(self) -> None:
+        if self._session is not None:
+            return
+
+        import onnxruntime as ort
+
+        # Resolve provider
+        providers = self._resolve_providers(ort)
+        log.info(
+            "Loading ONNX model: %s (providers=%s)",
+            self._model_name, providers,
+        )
+
+        # Find or download ONNX model files
+        model_dir = self._resolve_model_dir()
+
+        # Look for ONNX files
+        onnx_file = model_dir / "model.onnx"
+        if not onnx_file.exists():
+            onnx_file = model_dir / "model_optimized.onnx"
+        if not onnx_file.exists():
+            # Try any .onnx file
+            onnx_files = list(model_dir.glob("*.onnx"))
+            if onnx_files:
+                onnx_file = onnx_files[0]
+            else:
+                raise FileNotFoundError(
+                    f"No ONNX model files found in {model_dir}. "
+                    "Run setup or download model manually."
+                )
+
+        # Create session
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+        self._session = ort.InferenceSession(
+            str(onnx_file),
+            sess_options=sess_options,
+            providers=providers,
+        )
+
+        # Log actual provider
+        active = self._session.get_providers()
+        log.info("ONNX session active providers: %s", active)
+
+        # Load tokenizer
+        self._load_tokenizer(model_dir)
+
+        # Detect dimension from model output
+        self._dim = self._detect_dimension()
+        log.info("ONNX model ready (dim=%d, provider=%s)", self._dim, active[0])
+
+    def _resolve_providers(self, ort) -> list[str]:
+        """Resolve the ONNX provider chain from config + available providers."""
+        available = ort.get_available_providers()
+        log.debug("Available ONNX providers: %s", available)
+
+        if self._provider_name and self._provider_name in self._PROVIDER_MAP:
+            requested = self._PROVIDER_MAP[self._provider_name]
+            # Filter to only what's actually available
+            resolved = [p for p in requested if p in available]
+            if resolved:
+                return resolved
+            log.warning(
+                "Requested provider '%s' not available (have: %s), falling back to CPU",
+                self._provider_name, available,
+            )
+
+        # Auto-detect: pick best available
+        for provider_key in ("cuda", "rocm", "openvino", "coreml"):
+            chain = self._PROVIDER_MAP[provider_key]
+            if any(p in available for p in chain):
+                return [p for p in chain if p in available]
+
+        return ["CPUExecutionProvider"]
+
+    def _resolve_model_dir(self) -> Path:
+        """Find the ONNX model directory.
+
+        Checks (in order):
+        1. LENS_DATA_DIR env var (set by Tauri wrapper) — most reliable
+        2. Platform-correct getbased data dir (Linux/Mac/Windows)
+        3. HuggingFace hub cache (~/.cache/huggingface)
+        4. Optimum auto-download as last resort
+        """
+        # 1. Tauri wrapper sets LENS_DATA_DIR explicitly — trust it
+        env_dir = os.environ.get("LENS_DATA_DIR")
+        candidates_to_search = []
+        if env_dir:
+            candidates_to_search.append(Path(env_dir) / "models")
+
+        # 2. Fallback to platform-correct default getbased data dir
+        candidates_to_search.extend(_platform_getbased_data_dirs())
+
+        for tauri_models in candidates_to_search:
+            if not tauri_models.exists():
+                continue
+            # huggingface_hub snapshot_download creates models--{slug}/snapshots/{rev}/
+            for cached_model in tauri_models.glob("models--*"):
+                snapshots = cached_model / "snapshots"
+                if not snapshots.exists():
+                    continue
+                snap_dirs = sorted(snapshots.iterdir(), reverse=True)
+                for snap in snap_dirs:
+                    if (snap / "model.onnx").exists() or list(snap.glob("*.onnx")):
+                        return snap
+
+        # Check HuggingFace cache
+        hf_cache = Path.home() / ".cache" / "huggingface" / "hub"
+        if hf_cache.exists():
+            # Normalize model name: BAAI/bge-m3 → models--BAAI--bge-m3
+            model_slug = self._model_name.replace("/", "--")
+            model_hub_dir = hf_cache / f"models--{model_slug}"
+            if model_hub_dir.exists():
+                snapshots = model_hub_dir / "snapshots"
+                if snapshots.exists():
+                    snap_dirs = sorted(snapshots.iterdir(), reverse=True)
+                    for snap in snap_dirs:
+                        if list(snap.glob("*.onnx")):
+                            return snap
+
+        # Fallback: try loading via optimum which handles download
+        return self._download_via_optimum()
+
+    def _download_via_optimum(self) -> Path:
+        """Download model via optimum if not found locally."""
+        try:
+            from optimum.onnxruntime import ORTModelForFeatureExtraction
+            from transformers import AutoTokenizer
+
+            log.info("Downloading ONNX model via optimum: %s", self._model_name)
+            model = ORTModelForFeatureExtraction.from_pretrained(
+                self._model_name, export=True
+            )
+            tokenizer = AutoTokenizer.from_pretrained(self._model_name)
+
+            # Save to a local cache
+            cache_dir = (
+                Path.home() / ".cache" / "getbased" / "onnx_models" / self._model_name.replace("/", "--")
+            )
+            cache_dir.mkdir(parents=True, exist_ok=True)
+            model.save_pretrained(cache_dir)
+            tokenizer.save_pretrained(cache_dir)
+            log.info("ONNX model cached to %s", cache_dir)
+            return cache_dir
+        except ImportError:
+            raise ImportError(
+                "optimum not installed. Install with: pip install optimum[onnxruntime]"
+            )
+
+    def _load_tokenizer(self, model_dir: Path) -> None:
+        """Load the tokenizer for the model."""
+        from transformers import AutoTokenizer
+        self._tokenizer = AutoTokenizer.from_pretrained(str(model_dir))
+
+    def _detect_dimension(self) -> int:
+        """Detect embedding dimension from model output shape."""
+        # Try known dimensions first
+        if self._model_name in _MODEL_DIMS:
+            return _MODEL_DIMS[self._model_name]
+
+        # Probe with a dummy input
+        import numpy as np
+
+        encoded = self._tokenizer("test", padding=True, truncation=True, return_tensors="np")
+        outputs = self._session.run(None, dict(encoded))
+        # Last hidden state shape: [batch, seq_len, dim]
+        return outputs[0].shape[-1]
+
+    # public API -------------------------------------------------------
+
+    def encode(self, texts: list[str]) -> list[list[float]]:
+        self._load()
+        import numpy as np
+
+        # Per-model max_length: BGE-M3 supports 8192; most others top at 512.
+        # Truncating BGE-M3 at 512 throws away its main long-context advantage.
+        max_len = 8192 if "bge-m3" in self._model_name.lower() else 512
+
+        encoded = self._tokenizer(
+            texts,
+            padding=True,
+            truncation=True,
+            max_length=max_len,
+            return_tensors="np",
+        )
+
+        outputs = self._session.run(None, dict(encoded))
+        # outputs[0] = last_hidden_state: [batch, seq_len, dim]
+        embeddings = outputs[0]
+
+        # Pooling: BGE-M3 + most modern embedding models use mean pooling.
+        # CLS pooling is correct for original BERT but produces wrong vectors here.
+        if len(embeddings.shape) == 3:
+            mask = encoded.get("attention_mask")
+            if mask is not None:
+                # Masked mean: only average non-padding tokens
+                mask_expanded = np.expand_dims(mask, -1).astype(embeddings.dtype)
+                summed = (embeddings * mask_expanded).sum(axis=1)
+                counts = np.clip(mask_expanded.sum(axis=1), a_min=1e-9, a_max=None)
+                embeddings = summed / counts
+            else:
+                embeddings = embeddings.mean(axis=1)
+
+        # L2 normalize for cosine similarity
+        norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+        norms = np.where(norms == 0, 1, norms)
+        embeddings = embeddings / norms
+
+        return embeddings.tolist()
+
+    def dimension(self) -> int:
+        if self._dim is not None:
+            return self._dim
+        if self._model_name in _MODEL_DIMS:
+            return _MODEL_DIMS[self._model_name]
+        self._load()
+        return self._dim  # type: ignore[return-value]
+
+    def info(self) -> dict:
+        # Prefer the actually-active provider from the live ORT session
+        # if the model is loaded; fall back to the configured name so
+        # the UI has something to show even before the first encode().
+        active = None
+        if self._session is not None:
+            try:
+                providers = self._session.get_providers()
+                if providers:
+                    active = providers[0]
+            except Exception:
+                pass
+        return {
+            "engine": "onnx",
+            "model": self._model_name,
+            "provider": active or (self._provider_name or "auto"),
+            "dimension": self.dimension(),
+            "loaded": self._session is not None,
+        }
+
+
+# ── Local (sentence-transformers, fallback) ──────────────────────
+
+class LocalEmbedder(Embedder):
+    """Local embedding via sentence-transformers.
+
+    Model is lazy-loaded on first ``encode()`` / ``dimension()`` call
+    and cached for the lifetime of the instance.
+    """
+
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+        self._model_name = model_name
+        self._model = None
+        self._dim: int | None = None
+
+    # lazy init --------------------------------------------------------
+
+    def _load(self) -> None:
+        if self._model is not None:
+            return
+        from sentence_transformers import SentenceTransformer
+
+        log.info("Loading embedding model: %s …", self._model_name)
+        self._model = SentenceTransformer(self._model_name)
+        self._model.eval()
+        self._dim = self._model.get_sentence_embedding_dimension()
+        log.info("Model ready (dim=%d)", self._dim)
+
+    # public API -------------------------------------------------------
+
+    def encode(self, texts: list[str]) -> list[list[float]]:
+        self._load()
+        embeddings = self._model.encode(
+            texts,
+            normalize_embeddings=True,
+            show_progress_bar=False,
+        )
+        return embeddings.tolist()
+
+    def dimension(self) -> int:
+        if self._dim is not None:
+            return self._dim
+        if self._model_name in _MODEL_DIMS:
+            return _MODEL_DIMS[self._model_name]
+        self._load()
+        return self._dim  # type: ignore[return-value]
+
+    def info(self) -> dict:
+        # Detect whether torch thinks it has a GPU — sentence-transformers
+        # picks it up automatically, so reporting this matches what's
+        # actually running. Best-effort: the torch import is cheap once
+        # the model has loaded.
+        device = "cpu"
+        try:
+            import torch  # noqa: PLC0415
+
+            if torch.cuda.is_available():
+                device = "cuda"
+            elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                device = "mps"
+        except Exception:
+            pass
+        return {
+            "engine": "pytorch",
+            "model": self._model_name,
+            "device": device,
+            "dimension": self.dimension(),
+            "loaded": self._model is not None,
+        }
+
+
+# ── Cloud Inference (Qdrant Cloud) ────────────────────────────────
+
+class CloudInferenceEmbedder(Embedder):
+    """Delegates embedding to Qdrant Cloud's built-in inference API.
+
+    No local model is loaded — vectors come from the cloud endpoint.
+    """
+
+    def __init__(self, url: str, api_key: str, model_name: str = "all-MiniLM-L6-v2"):
+        self._url = url
+        self._api_key = api_key
+        self._model_name = model_name
+        self._client = None
+        self._dim: int = _MODEL_DIMS.get(model_name, 384)
+
+    def _ensure_client(self):
+        if self._client is not None:
+            return
+        from qdrant_client import QdrantClient
+
+        self._client = QdrantClient(url=self._url, api_key=self._api_key)
+        log.info("Cloud inference client ready via %s", self._url)
+
+    def encode(self, texts: list[str]) -> list[list[float]]:
+        self._ensure_client()
+        from qdrant_client.models import Document
+
+        vectors: list[list[float]] = []
+        batch_size = 32
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i : i + batch_size]
+            docs = [
+                Document(text=t, model=self._model_name) for t in batch
+            ]
+            result = self._client.infer("", docs)
+            vectors.extend([list(v) for v in result])
+        return vectors
+
+    def dimension(self) -> int:
+        return self._dim
+
+    def info(self) -> dict:
+        # URL might be sensitive if it encodes the workspace — strip the
+        # host-tail so the UI gets a hint without leaking the full
+        # endpoint. The api_key is never surfaced.
+        from urllib.parse import urlparse
+
+        host = ""
+        try:
+            host = urlparse(self._url).hostname or ""
+        except Exception:
+            pass
+        return {
+            "engine": "qdrant-cloud",
+            "model": self._model_name,
+            "host": host,
+            "dimension": self.dimension(),
+            "loaded": self._client is not None,
+        }
+
+
+# ── Factory ────────────────────────────────────────────────────────
+
+def create_embedder(config: LensConfig) -> Embedder:
+    """Create the appropriate embedder from a LensConfig.
+
+    Priority:
+    1. Cloud inference (if enabled) — no local model needed
+    2. ONNX Runtime (if onnx_provider set or optimum available) — GPU-accelerated
+    3. sentence-transformers (fallback) — always works
+    """
+    if config.cloud_inference:
+        if not config.qdrant_cloud_url:
+            raise ValueError(
+                "LENS_QDRANT_CLOUD_URL required when cloud_inference=True"
+            )
+        return CloudInferenceEmbedder(
+            url=config.qdrant_cloud_url,
+            api_key=config.qdrant_cloud_key,
+            model_name=config.embedding_model,
+        )
+
+    # Try ONNX backend if provider is set or optimum is available
+    if config.onnx_provider or _onnx_available():
+        log.info(
+            "Using ONNX backend (provider=%s)",
+            config.onnx_provider or "auto",
+        )
+        return OnnxEmbedder(
+            model_name=config.embedding_model,
+            provider=config.onnx_provider,
+        )
+
+    # Fallback to sentence-transformers
+    log.info("ONNX not available, falling back to sentence-transformers")
+    return LocalEmbedder(model_name=config.embedding_model)
+
+
+def _onnx_available() -> bool:
+    """Check if onnxruntime is importable."""
+    try:
+        import onnxruntime  # noqa: F401
+        return True
+    except ImportError:
+        return False