deeptutor-knowledge 1.7.0__py3-none-any.whl

deeptutor/services/rag/index_versioning.py

@@ -0,0 +1,387 @@
+"""Flat per-embedding index versions for knowledge bases.
+
+New layout::
+
+    data/knowledge_bases/<kb_name>/
+        raw/                         # source files (untouched)
+        version-1/                   # LlamaIndex storage files live directly here
+            docstore.json
+            index_store.json
+            default__vector_store.json
+            graph_store.json
+            image__vector_store.json
+            meta.json                # {"version", "signature", "model", ...}
+        version-2/
+            ...
+        metadata.json
+
+Older layouts remain readable for backward compatibility, but all new writes
+go to flat ``version-N`` directories:
+
+* ``llamaindex_storage/`` at KB root (legacy single-store)
+* ``index_versions/<signature>/llamaindex_storage`` (legacy nested versions)
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+import hashlib
+import json
+import logging
+from pathlib import Path
+import re
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+VERSION_PREFIX = "version-"
+LEGACY_VERSION_DIRNAME = "index_versions"
+LEGACY_STORAGE_DIRNAME = "llamaindex_storage"
+META_FILENAME = "meta.json"
+
+_VERSION_RE = re.compile(r"^version-(\d+)$")
+
+
+@dataclass(frozen=True)
+class EmbeddingSignature:
+    """Stable identity of an embedding configuration."""
+
+    binding: str
+    model: str
+    dimension: int
+    base_url: str
+    api_version: str
+    role_semantics: str = ""
+
+    def hash(self) -> str:
+        """Short hex digest used as the stable signature."""
+        fields = asdict(self)
+        role_semantics = fields.pop("role_semantics")
+        if role_semantics:
+            fields["role_semantics"] = role_semantics
+        canonical = json.dumps(fields, sort_keys=True, ensure_ascii=False)
+        return hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:16]
+
+
+def kb_versions_dir(kb_dir: Path) -> Path:
+    """Return the legacy nested versions directory."""
+    return kb_dir / LEGACY_VERSION_DIRNAME
+
+
+def legacy_storage_dir(kb_dir: Path) -> Path:
+    return kb_dir / LEGACY_STORAGE_DIRNAME
+
+
+def _legacy_version_dir_for_signature(kb_dir: Path, sig_hash: str) -> Path:
+    return kb_versions_dir(kb_dir) / sig_hash
+
+
+def _legacy_storage_dir_for_signature(kb_dir: Path, sig_hash: str) -> Path:
+    return _legacy_version_dir_for_signature(kb_dir, sig_hash) / LEGACY_STORAGE_DIRNAME
+
+
+def _is_storage_ready(storage_dir: Path) -> bool:
+    return storage_dir.is_dir() and any(
+        child.name != META_FILENAME for child in storage_dir.iterdir()
+    )
+
+
+def _read_json(path: Path) -> Optional[dict[str, Any]]:
+    if not path.exists():
+        return None
+    try:
+        with open(path, encoding="utf-8") as handle:
+            payload = json.load(handle)
+        return payload if isinstance(payload, dict) else None
+    except Exception as exc:
+        logger.warning(f"Failed to read version meta {path}: {exc}")
+        return None
+
+
+def _flat_version_number(path: Path) -> int:
+    match = _VERSION_RE.match(path.name)
+    return int(match.group(1)) if match else 0
+
+
+def _flat_version_dirs(kb_dir: Path) -> list[Path]:
+    if not kb_dir.is_dir():
+        return []
+    return sorted(
+        (child for child in kb_dir.iterdir() if child.is_dir() and _VERSION_RE.match(child.name)),
+        key=_flat_version_number,
+    )
+
+
+def _next_flat_version_dir(kb_dir: Path) -> Path:
+    existing = [_flat_version_number(path) for path in _flat_version_dirs(kb_dir)]
+    return kb_dir / f"{VERSION_PREFIX}{(max(existing) if existing else 0) + 1}"
+
+
+def _native_lightrag_output_ready(version_dir: Path, meta: dict[str, Any]) -> bool:
+    workspace = str(meta.get("workspace") or "").strip()
+    if workspace:
+        workspace_path = Path(workspace)
+        if workspace_path.is_absolute() or workspace_path.name != workspace:
+            return False
+        status_path = version_dir / workspace / "kv_store_doc_status.json"
+    else:
+        # Transitional/test layouts may still keep the status store flat.
+        status_path = version_dir / "kv_store_doc_status.json"
+    payload = _read_json(status_path)
+    if not payload:
+        return False
+    return any(
+        isinstance(row, dict)
+        and (str(row.get("status") or "").lower() == "processed" or bool(row.get("chunks_list")))
+        for row in payload.values()
+    )
+
+
+def _entry_from_flat_version(version_dir: Path) -> dict[str, Any]:
+    stored_meta = _read_json(version_dir / META_FILENAME)
+    meta = dict(stored_meta or {})
+    meta.setdefault("version", version_dir.name)
+    meta.setdefault("signature", meta.get("signature") or version_dir.name)
+    has_provider_output = _is_storage_ready(version_dir)
+    # Legacy flat stores from other providers predate metadata, so their
+    # established readiness rule remains output-based. A native LightRAG
+    # candidate is identifiable before publication by its doc-status/ingress
+    # files and must fail closed until schema-2 metadata is atomically written.
+    is_unpublished_lightrag_candidate = stored_meta is None and (
+        (version_dir / "kv_store_doc_status.json").exists()
+        or (version_dir / "deeptutor_ingress").exists()
+    )
+    ready = has_provider_output and not is_unpublished_lightrag_candidate
+    if (version_dir / ".building.json").exists():
+        ready = ready and bool(stored_meta and stored_meta.get("state") == "published")
+    if stored_meta is not None and stored_meta.get("provider") == "lightrag":
+        adapter_schema = stored_meta.get("lightrag_adapter_schema")
+        if adapter_schema is not None:
+            ready = bool(
+                adapter_schema == 2
+                and stored_meta.get("state") == "published"
+                and _native_lightrag_output_ready(version_dir, stored_meta)
+            )
+    meta["ready"] = ready
+    meta["storage_path"] = str(version_dir)
+    meta["version_path"] = str(version_dir)
+    meta["layout"] = "flat"
+    return meta
+
+
+def _entry_from_legacy_nested(kb_dir: Path, version_dir: Path) -> dict[str, Any]:
+    storage = version_dir / LEGACY_STORAGE_DIRNAME
+    meta = _read_json(version_dir / META_FILENAME) or {"signature": version_dir.name}
+    meta.setdefault("version", version_dir.name)
+    meta.setdefault("signature", version_dir.name)
+    meta["ready"] = _is_storage_ready(storage)
+    meta["storage_path"] = str(storage)
+    meta["version_path"] = str(version_dir)
+    meta["layout"] = "nested_legacy"
+    meta["legacy"] = True
+    # Keep the parent KB path discoverable for callers that want to migrate.
+    meta["kb_path"] = str(kb_dir)
+    return meta
+
+
+def _entry_from_root_legacy(kb_dir: Path) -> dict[str, Any]:
+    storage = legacy_storage_dir(kb_dir)
+    return {
+        "signature": "legacy",
+        "version": "legacy",
+        "ready": _is_storage_ready(storage),
+        "storage_path": str(storage),
+        "version_path": str(storage),
+        "layout": "root_legacy",
+        "legacy": True,
+    }
+
+
+def _sort_versions(versions: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    def key(entry: dict[str, Any]) -> tuple[str, int, int]:
+        layout_priority = 2 if entry.get("layout") == "flat" else 1
+        version_num = 0
+        version_name = str(entry.get("version") or "")
+        match = _VERSION_RE.match(version_name)
+        if match:
+            version_num = int(match.group(1))
+        return (str(entry.get("created_at", "")), layout_priority, version_num)
+
+    return sorted(versions, key=key, reverse=True)
+
+
+def list_kb_versions(kb_dir: Path) -> list[dict[str, Any]]:
+    """Return all index versions for a KB, newest first.
+
+    New flat ``version-N`` directories are returned alongside legacy nested and
+    root stores so older KBs stay queryable while new re-indexes use the simpler
+    flat layout.
+    """
+    versions: list[dict[str, Any]] = []
+
+    for version_dir in _flat_version_dirs(kb_dir):
+        versions.append(_entry_from_flat_version(version_dir))
+
+    legacy_versions_root = kb_versions_dir(kb_dir)
+    if legacy_versions_root.is_dir():
+        for child in sorted(legacy_versions_root.iterdir(), key=lambda path: path.name):
+            if child.is_dir():
+                versions.append(_entry_from_legacy_nested(kb_dir, child))
+
+    root_legacy = legacy_storage_dir(kb_dir)
+    if root_legacy.is_dir() and any(root_legacy.iterdir()):
+        versions.append(_entry_from_root_legacy(kb_dir))
+
+    return _sort_versions(versions)
+
+
+def _find_flat_version_by_signature(
+    kb_dir: Path, sig_hash: str, *, ready_only: bool
+) -> Optional[dict[str, Any]]:
+    for entry in list_kb_versions(kb_dir):
+        if entry.get("layout") != "flat":
+            continue
+        if entry.get("signature") != sig_hash:
+            continue
+        if ready_only and not entry.get("ready"):
+            continue
+        return entry
+    return None
+
+
+def _latest_ready_flat_version(kb_dir: Path) -> Optional[dict[str, Any]]:
+    for entry in list_kb_versions(kb_dir):
+        if entry.get("layout") == "flat" and entry.get("ready"):
+            return entry
+    return None
+
+
+def read_version_meta(kb_dir: Path, sig_hash: str) -> Optional[dict[str, Any]]:
+    """Read metadata for a matching signature from any supported layout."""
+    for entry in list_kb_versions(kb_dir):
+        if entry.get("signature") == sig_hash:
+            return entry
+    return None
+
+
+def find_matching_version(kb_dir: Path, signature: EmbeddingSignature) -> Optional[dict[str, Any]]:
+    """Return a ready version whose signature matches ``signature``.
+
+    Prefer the new flat layout when both flat and legacy entries exist for the
+    same signature.
+    """
+    target = signature.hash()
+    matches = [
+        entry
+        for entry in list_kb_versions(kb_dir)
+        if entry.get("signature") == target and entry.get("ready")
+    ]
+    if not matches:
+        return None
+    flat_matches = [entry for entry in matches if entry.get("layout") == "flat"]
+    return flat_matches[0] if flat_matches else matches[0]
+
+
+def version_dir_for_signature(kb_dir: Path, sig_hash: str) -> Path:
+    """Return the existing flat version dir for a signature, or the next flat dir."""
+    entry = _find_flat_version_by_signature(kb_dir, sig_hash, ready_only=False)
+    if entry:
+        return Path(str(entry["version_path"]))
+    return _next_flat_version_dir(kb_dir)
+
+
+def storage_dir_for_signature(kb_dir: Path, sig_hash: str) -> Path:
+    """Return a storage dir for a signature in any supported layout.
+
+    This helper is kept for backward-compatible imports. New write paths should
+    use ``resolve_storage_dir_for_write``.
+    """
+    for entry in list_kb_versions(kb_dir):
+        if entry.get("signature") == sig_hash:
+            return Path(str(entry["storage_path"]))
+    legacy = _legacy_storage_dir_for_signature(kb_dir, sig_hash)
+    if legacy.exists():
+        return legacy
+    return version_dir_for_signature(kb_dir, sig_hash)
+
+
+def write_version_meta(
+    kb_dir: Path, signature: EmbeddingSignature, storage_dir: Path | None = None
+) -> None:
+    """Persist metadata next to the LlamaIndex store."""
+    target = storage_dir or resolve_storage_dir_for_write(kb_dir, signature)
+    target.mkdir(parents=True, exist_ok=True)
+    payload: dict[str, Any] = {
+        "version": target.name,
+        "signature": signature.hash(),
+        **asdict(signature),
+        "layout": "flat" if target.parent == kb_dir else "nested_legacy",
+        "created_at": datetime.now(timezone.utc).replace(tzinfo=None).isoformat() + "Z",
+    }
+    from deeptutor.services.file_io import atomic_write_json
+
+    if (target / ".building.json").exists():
+        payload.update(provider="llamaindex", state="published", readiness_verified=True)
+    atomic_write_json(target / META_FILENAME, payload)
+
+
+def resolve_storage_dir_for_read(
+    kb_dir: Path, signature: Optional[EmbeddingSignature]
+) -> Optional[Path]:
+    """Return the storage dir to read for the active embedding signature."""
+    if signature is not None:
+        match = find_matching_version(kb_dir, signature)
+        if match:
+            return Path(str(match["storage_path"]))
+    else:
+        latest_flat = _latest_ready_flat_version(kb_dir)
+        if latest_flat:
+            return Path(str(latest_flat["storage_path"]))
+
+    root_legacy = legacy_storage_dir(kb_dir)
+    if _is_storage_ready(root_legacy):
+        return root_legacy
+
+    return None
+
+
+def resolve_storage_dir_for_write(kb_dir: Path, signature: Optional[EmbeddingSignature]) -> Path:
+    """Return the flat storage dir to write for the active embedding signature.
+
+    Existing flat versions are reused. Legacy nested/root stores are never used
+    for new writes so re-indexing naturally converges KBs onto the flat layout.
+    """
+    if signature is None:
+        target = _next_flat_version_dir(kb_dir)
+    else:
+        entry = _find_flat_version_by_signature(kb_dir, signature.hash(), ready_only=False)
+        target = Path(str(entry["storage_path"])) if entry else _next_flat_version_dir(kb_dir)
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+def resolve_storage_dir_for_rebuild(
+    kb_dir: Path, signature: Optional[EmbeddingSignature], *, publication_guard: bool = False
+) -> Path:
+    """Return a fresh flat storage dir for a full index rebuild.
+
+    Incremental writes reuse a matching flat version, but a full rebuild should
+    not overwrite the last matching version until the new index has been
+    persisted successfully. Keeping the old version in place lets a failed
+    rebuild remain diagnosable and avoids stale vector-store files.
+    """
+    _ = signature
+    kb_dir.mkdir(parents=True, exist_ok=True)
+    while True:
+        target = _next_flat_version_dir(kb_dir)
+        try:
+            target.mkdir()
+            break
+        except FileExistsError:
+            continue
+    from deeptutor.services.file_io import atomic_write_json
+
+    if publication_guard:
+        atomic_write_json(target / ".building.json", {"state": "building"})
+    return target

deeptutor/services/rag/kb_paths.py

@@ -0,0 +1,50 @@
+"""Resolve the on-disk directory backing a knowledge base.
+
+Ordinary KBs live at ``<kb_base_dir>/<kb_name>``. A *linked* KB is a pointer to
+an engine index the user already built elsewhere: its ``kb_config.json`` entry
+carries an ``external_path`` we resolve to instead, so retrieval reads that
+folder in place — no copy, no re-index.
+
+This is the single seam every pipeline goes through to find a KB's storage
+root. Pipelines must never compute ``Path(kb_base_dir) / kb_name`` directly, or
+linked KBs would resolve to a non-existent local folder and silently return no
+results.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from deeptutor.knowledge.kb_types import external_root_of
+
+KB_CONFIG_FILENAME = "kb_config.json"
+
+
+def resolve_kb_dir(kb_base_dir: str | Path, kb_name: str) -> Path:
+    """Return the directory holding ``kb_name``'s index.
+
+    For a linked KB this is the user's external folder; for every other KB it
+    is the conventional ``<kb_base_dir>/<kb_name>``.
+    """
+    base = Path(kb_base_dir)
+    external = _external_path(base, kb_name)
+    if external:
+        return Path(external).expanduser()
+    return base / kb_name
+
+
+def _external_path(base: Path, kb_name: str) -> str | None:
+    """Read a KB entry's external pointer from ``kb_config.json``, if any."""
+    cfg = base / KB_CONFIG_FILENAME
+    if not cfg.exists():
+        return None
+    try:
+        with open(cfg, encoding="utf-8") as handle:
+            entry = json.load(handle).get("knowledge_bases", {}).get(kb_name, {})
+    except Exception:
+        return None
+    return external_root_of(entry)
+
+
+__all__ = ["resolve_kb_dir"]

deeptutor/services/rag/linked_kb.py

@@ -0,0 +1,237 @@
+"""Probe an external folder before mounting it as a *linked* knowledge base.
+
+Linking reuses a self-contained index a user already built — no copy, no
+re-index (see :data:`deeptutor.knowledge.kb_types.LINKED_KB_TYPE`). Before we
+register a pointer we must answer two questions for the user:
+
+1. **Does this folder actually hold a ready index for the chosen engine?**
+   We reuse the standard version discovery (``list_kb_versions``) so the same
+   "is this KB ready?" logic that lists ordinary KBs decides linkability.
+2. **Was that index built with a compatible embedding model?** A local vector /
+   graph index is only queryable by the embedding model that built it. A
+   mismatch makes LlamaIndex error loudly and the graph engines fail silently,
+   so we surface a clear verdict the UI can confirm.
+
+PageIndex is deliberately not linkable: its index lives in the cloud (the local
+folder holds only a doc-id manifest), so there is nothing self-contained to
+mount.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+# Optional ops-set allowlist of filesystem roots a linked folder must live
+# under, as an ``os.pathsep``-separated list. Unset (the default) means no
+# restriction, which is correct for the local/self-hosted single-trust-domain
+# deployments this feature targets. Shared multi-user servers should set it so a
+# non-admin cannot point a KB at another user's data or system paths.
+LINK_ROOTS_ENV = "DEEPTUTOR_LINKED_FOLDER_ROOTS"
+
+from deeptutor.services.rag.factory import (
+    DEFAULT_PROVIDER,
+    GRAPHRAG_PROVIDER,
+    LIGHTRAG_PROVIDER,
+    PAGEINDEX_PROVIDER,
+    normalize_provider_name,
+)
+
+# Engines whose index is self-contained on disk and therefore mountable. The
+# cloud-backed PageIndex is excluded — see module docstring.
+LINKABLE_PROVIDERS = frozenset({DEFAULT_PROVIDER, GRAPHRAG_PROVIDER, LIGHTRAG_PROVIDER})
+
+
+@dataclass
+class EmbeddingCompat:
+    # True/False once both signatures are known; None when it can't be verified.
+    compatible: Optional[bool] = None
+    index_model: Optional[str] = None
+    current_model: Optional[str] = None
+
+
+@dataclass
+class ProbeResult:
+    provider: str
+    external_path: str
+    ok: bool = False
+    version: Optional[str] = None
+    doc_count: Optional[int] = None
+    embedding: EmbeddingCompat = field(default_factory=EmbeddingCompat)
+    warnings: list[str] = field(default_factory=list)
+    error: Optional[str] = None
+
+    def to_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        return data
+
+
+def provider_is_linkable(provider: str) -> bool:
+    return normalize_provider_name(provider) in LINKABLE_PROVIDERS
+
+
+def allowed_link_roots() -> list[Path]:
+    """Resolved allowlist of roots a linked folder may live under (may be empty)."""
+    raw = os.environ.get(LINK_ROOTS_ENV, "").strip()
+    if not raw:
+        return []
+    roots: list[Path] = []
+    for chunk in raw.split(os.pathsep):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        try:
+            roots.append(Path(chunk).expanduser().resolve())
+        except OSError:
+            continue
+    return roots
+
+
+def assert_path_allowed(folder_path: str) -> Path:
+    """Resolve ``folder_path`` and enforce the optional root allowlist.
+
+    Returns the resolved absolute path. Raises ``ValueError`` if the folder is
+    missing/not a directory, or escapes the configured allowlist (symlinks are
+    resolved first so they can't tunnel out). With no allowlist set, any
+    existing directory is permitted — the self-hosted default.
+    """
+    folder = Path(folder_path).expanduser()
+    if not folder.exists():
+        raise ValueError(f"Folder does not exist: {folder}")
+    if not folder.is_dir():
+        raise ValueError(f"Not a directory: {folder}")
+    resolved = folder.resolve()
+
+    roots = allowed_link_roots()
+    if roots and not any(_is_within(resolved, root) for root in roots):
+        raise ValueError("This folder is outside the locations allowed for linking.")
+    return resolved
+
+
+def _is_within(path: Path, root: Path) -> bool:
+    try:
+        return path == root or root in path.parents
+    except OSError:
+        return False
+
+
+def probe_linked_folder(folder_path: str, provider: str) -> ProbeResult:
+    """Inspect ``folder_path`` for a ready ``provider`` index.
+
+    Always returns a :class:`ProbeResult` (never raises): ``error`` set means
+    the folder cannot be linked; ``warnings`` are non-fatal cautions the user
+    confirms. The caller is responsible for any path-jail / access checks.
+    """
+    provider = normalize_provider_name(provider)
+    folder = Path(folder_path).expanduser()
+    result = ProbeResult(provider=provider, external_path=str(folder))
+
+    if provider == PAGEINDEX_PROVIDER:
+        result.error = (
+            "PageIndex indexes live in the cloud, not in a local folder, so they "
+            "cannot be linked. Create a PageIndex knowledge base instead."
+        )
+        return result
+    if provider not in LINKABLE_PROVIDERS:
+        result.error = f"Engine '{provider}' does not support linking an existing folder."
+        return result
+
+    if not folder.exists():
+        result.error = f"Folder does not exist: {folder}"
+        return result
+    if not folder.is_dir():
+        result.error = f"Not a directory: {folder}"
+        return result
+
+    result.external_path = str(folder.resolve())
+
+    from deeptutor.services.rag.index_probe import inspect_kb_versions
+
+    versions = inspect_kb_versions(folder, provider)
+    ready = [v for v in versions if v.get("ready")]
+    if not ready:
+        failure = next(
+            (str(v.get("failure_summary") or "") for v in versions if v.get("failure_summary")),
+            "",
+        )
+        result.error = (
+            failure
+            or "No ready index found in this folder. Point at a knowledge base folder "
+            "that contains a built index (a 'version-N' directory)."
+        )
+        return result
+
+    latest = ready[0]  # inspect_kb_versions preserves newest-first ordering.
+    result.version = str(latest.get("version") or "")
+    _check_embedding(provider, latest, result)
+    doc_count = latest.get("doc_count")
+    result.doc_count = (
+        int(doc_count) if isinstance(doc_count, int) else _best_effort_doc_count(folder)
+    )
+    result.ok = result.error is None
+    return result
+
+
+def _check_embedding(provider: str, version: dict, result: ProbeResult) -> None:
+    """Compare the index's embedding identity against the active config."""
+    from deeptutor.services.rag.embedding_signature import signature_from_embedding_config
+
+    current = signature_from_embedding_config()
+    compat = result.embedding
+    compat.current_model = current.model if current else None
+
+    # LlamaIndex stores the embedding hash in the version signature; the graph
+    # engines stamp it separately (see embedding_meta_fields).
+    if provider == DEFAULT_PROVIDER:
+        index_hash = str(version.get("signature") or "")
+    else:
+        index_hash = str(version.get("embedding_signature") or "")
+    compat.index_model = version.get("embedding_model") or version.get("model")
+
+    if current is None:
+        compat.compatible = None
+        result.warnings.append(
+            "No embedding model is configured, so embedding compatibility could not "
+            "be verified. Configure one under Settings before querying."
+        )
+        return
+    if not index_hash:
+        compat.compatible = None
+        result.warnings.append(
+            "This index does not record which embedding model built it. Make sure it "
+            "matches your current embedding model, or retrieval may fail."
+        )
+        return
+
+    compat.compatible = index_hash == current.hash()
+    if not compat.compatible:
+        built_with = compat.index_model or "a different model"
+        result.warnings.append(
+            f"This index was built with {built_with}, which differs from your current "
+            f"embedding model ({compat.current_model}). Retrieval will not work until "
+            "you switch back to the matching embedding model."
+        )
+
+
+def _best_effort_doc_count(folder: Path) -> Optional[int]:
+    """Count source files under ``raw/`` if the linked folder ships them."""
+    raw = folder / "raw"
+    if not raw.is_dir():
+        return None
+    try:
+        return sum(1 for p in raw.rglob("*") if p.is_file())
+    except OSError:
+        return None
+
+
+__all__ = [
+    "LINKABLE_PROVIDERS",
+    "EmbeddingCompat",
+    "ProbeResult",
+    "probe_linked_folder",
+    "provider_is_linkable",
+    "allowed_link_roots",
+    "assert_path_allowed",
+]

deeptutor/services/rag/pipelines/__init__.py

@@ -0,0 +1,7 @@
+"""Pre-configured RAG pipelines.
+
+DeepTutor currently ships with a single built-in provider (`llamaindex`).
+Additional providers can still be registered dynamically via the factory layer.
+"""
+
+__all__: list[str] = []