vector-inspector 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

vector_inspector/core/connections/qdrant_connection.py

@@ -1,27 +1,22 @@
 """Qdrant connection manager."""
 
-from typing import Optional, List, Dict, Any
 import uuid
+from typing import Any, Optional
+
 from qdrant_client import QdrantClient
 from qdrant_client.models import (
     Distance,
-    VectorParams,
-    PointStruct,
     Filter,
-    FieldCondition,
-    MatchValue,
-    MatchText,
-    MatchAny,
-    MatchExcept,
-    Range,
+    PointStruct,
+    VectorParams,
 )
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
-from vector_inspector.core.logging import log_info, log_error, log_debug
-from vector_inspector.core.connections.qdrant_helpers.qdrant_filter_builder import build_filter
 from vector_inspector.core.connections.qdrant_helpers.qdrant_embedding_resolver import (
     resolve_embedding_model,
 )
+from vector_inspector.core.connections.qdrant_helpers.qdrant_filter_builder import build_filter
+from vector_inspector.core.logging import log_error, log_info
 
 
 class QdrantConnection(VectorDBConnection):
@@ -133,7 +128,7 @@ class QdrantConnection(VectorDBConnection):
         except Exception:
             return 0
 
-    def get_items(self, name: str, ids: List[str]) -> Dict[str, Any]:
+    def get_items(self, name: str, ids: list[str]) -> dict[str, Any]:
         """
         Get items by IDs (implementation for compatibility).
 
@@ -162,7 +157,7 @@ class QdrantConnection(VectorDBConnection):
             log_error("Failed to get items: %s", e)
             return {"documents": [], "metadatas": []}
 
-    def list_collections(self) -> List[str]:
+    def list_collections(self) -> list[str]:
         """
         Get list of all collections.
 
@@ -178,7 +173,7 @@ class QdrantConnection(VectorDBConnection):
             log_error("Failed to list collections: %s", e)
             return []
 
-    def get_collection_info(self, name: str) -> Optional[Dict[str, Any]]:
+    def get_collection_info(self, name: str) -> Optional[dict[str, Any]]:
         """
         Get collection metadata and statistics.
 
@@ -296,7 +291,7 @@ class QdrantConnection(VectorDBConnection):
             model = load_embedding_model(model_name, model_type)
             return (model, model_name, model_type)
 
-    def _build_qdrant_filter(self, where: Optional[Dict[str, Any]] = None) -> Optional[Filter]:
+    def _build_qdrant_filter(self, where: Optional[dict[str, Any]] = None) -> Optional[Filter]:
         """Delegate filter construction to helper module."""
         try:
             return build_filter(where)
@@ -307,12 +302,12 @@ class QdrantConnection(VectorDBConnection):
     def query_collection(
         self,
         collection_name: str,
-        query_texts: Optional[List[str]] = None,
-        query_embeddings: Optional[List[List[float]]] = None,
+        query_texts: Optional[list[str]] = None,
+        query_embeddings: Optional[list[list[float]]] = None,
         n_results: int = 10,
-        where: Optional[Dict[str, Any]] = None,
-        where_document: Optional[Dict[str, Any]] = None,
-    ) -> Optional[Dict[str, Any]]:
+        where: Optional[dict[str, Any]] = None,
+        where_document: Optional[dict[str, Any]] = None,
+    ) -> Optional[dict[str, Any]]:
         """
         Query a collection for similar vectors.
 
@@ -357,9 +352,9 @@ class QdrantConnection(VectorDBConnection):
             for query in queries:
                 # Embed text queries if needed
                 if isinstance(query, str):
-                    # Generate embeddings for text query using appropriate model for this collection
+                    # Generate embeddings for text query using inherited method
                     try:
-                        model, model_name, model_type = self._get_embedding_model_for_collection(
+                        model, model_name, model_type = self.load_embedding_model_for_collection(
                             collection_name
                         )
 
@@ -425,8 +420,8 @@ class QdrantConnection(VectorDBConnection):
         collection_name: str,
         limit: Optional[int] = None,
         offset: Optional[int] = None,
-        where: Optional[Dict[str, Any]] = None,
-    ) -> Optional[Dict[str, Any]]:
+        where: Optional[dict[str, Any]] = None,
+    ) -> Optional[dict[str, Any]]:
         """
         Get all items from a collection.
 
@@ -492,10 +487,10 @@ class QdrantConnection(VectorDBConnection):
     def add_items(
         self,
         collection_name: str,
-        documents: List[str],
-        metadatas: Optional[List[Dict[str, Any]]] = None,
-        ids: Optional[List[str]] = None,
-        embeddings: Optional[List[List[float]]] = None,
+        documents: list[str],
+        metadatas: Optional[list[dict[str, Any]]] = None,
+        ids: Optional[list[str]] = None,
+        embeddings: Optional[list[list[float]]] = None,
     ) -> bool:
         """
         Add items to a collection.
@@ -532,9 +527,7 @@ class QdrantConnection(VectorDBConnection):
                 embeddings = self.compute_embeddings_for_documents(
                     collection_name,
                     documents,
-                    getattr(self, "path", None)
-                    or getattr(self, "url", None)
-                    or getattr(self, "host", None),
+                    getattr(self, "profile_name", None),
                 )
             except Exception as e:
                 log_error("Embeddings are required for Qdrant and computing them failed: %s", e)
@@ -569,10 +562,10 @@ class QdrantConnection(VectorDBConnection):
     def update_items(
         self,
         collection_name: str,
-        ids: List[str],
-        documents: Optional[List[str]] = None,
-        metadatas: Optional[List[Dict[str, Any]]] = None,
-        embeddings: Optional[List[List[float]]] = None,
+        ids: list[str],
+        documents: Optional[list[str]] = None,
+        metadatas: Optional[list[dict[str, Any]]] = None,
+        embeddings: Optional[list[list[float]]] = None,
     ) -> bool:
         """
         Update items in a collection.
@@ -627,9 +620,7 @@ class QdrantConnection(VectorDBConnection):
                         computed = self.compute_embeddings_for_documents(
                             collection_name,
                             [documents[i]],
-                            getattr(self, "path", None)
-                            or getattr(self, "url", None)
-                            or getattr(self, "host", None),
+                            getattr(self, "profile_name", None),
                         )
                         vector = computed[0] if computed else vector
                     except Exception as e:
@@ -651,8 +642,8 @@ class QdrantConnection(VectorDBConnection):
     def delete_items(
         self,
         collection_name: str,
-        ids: Optional[List[str]] = None,
-        where: Optional[Dict[str, Any]] = None,
+        ids: Optional[list[str]] = None,
+        where: Optional[dict[str, Any]] = None,
     ) -> bool:
         """
         Delete items from a collection.
@@ -739,7 +730,7 @@ class QdrantConnection(VectorDBConnection):
             log_error(f"Failed to create collection: {e}")
             return False
 
-    def prepare_restore(self, metadata: Dict[str, Any], data: Dict[str, Any]) -> bool:
+    def prepare_restore(self, metadata: dict[str, Any], data: dict[str, Any]) -> bool:
         """Provider-specific hook invoked before restoring data.
 
         The connection can use metadata and data to pre-create collections,
@@ -832,9 +823,9 @@ class QdrantConnection(VectorDBConnection):
             log_error("prepare_restore failed: %s", e)
             return False
 
-    def get_connection_info(self) -> Dict[str, Any]:
+    def get_connection_info(self) -> dict[str, Any]:
         """Get information about the current connection."""
-        info: Dict[str, Any] = {
+        info: dict[str, Any] = {
             "provider": "Qdrant",
             "connected": self.is_connected,
         }
@@ -852,7 +843,7 @@ class QdrantConnection(VectorDBConnection):
             info["mode"] = "memory"
         return info
 
-    def get_supported_filter_operators(self) -> List[Dict[str, Any]]:
+    def get_supported_filter_operators(self) -> list[dict[str, Any]]:
         """Get filter operators supported by Qdrant."""
         return [
             {"name": "=", "server_side": True},

vector_inspector/core/embedding_utils.py

@@ -1,7 +1,9 @@
 """Utilities for managing embedding models and vector dimensions."""
 
-from typing import Optional, Union, Tuple
-from sentence_transformers import SentenceTransformer
+from __future__ import annotations  # Allows us to use class names in typehints while lazyloading
+from typing import Optional, Tuple, Any
+
+# Lazy import: see below
 from vector_inspector.core.logging import log_info
 
 from vector_inspector.core.model_registry import get_model_registry
@@ -101,7 +103,7 @@ def get_available_models_for_dimension(dimension: int) -> list:
     return models
 
 
-def load_embedding_model(model_name: str, model_type: str) -> Union[SentenceTransformer, any]:
+def load_embedding_model(model_name: str, model_type: str) -> SentenceTransformer | Any:
     """
     Load an embedding model (sentence-transformer or CLIP).
 
@@ -117,12 +119,16 @@ def load_embedding_model(model_name: str, model_type: str) -> Union[SentenceTran
 
         model = CLIPModel.from_pretrained(model_name)
         processor = CLIPProcessor.from_pretrained(model_name)
+        # Returns a tuple: (CLIPModel, CLIPProcessor)
         return (model, processor)
     else:
+        from sentence_transformers import SentenceTransformer
+
+        # Returns a SentenceTransformer instance
         return SentenceTransformer(model_name)
 
 
-def encode_text(text: str, model: Union[SentenceTransformer, Tuple], model_type: str) -> list:
+def encode_text(text: str, model: "SentenceTransformer" | Tuple, model_type: str) -> list:
     """
     Encode text using the appropriate model.
 
@@ -146,13 +152,15 @@ def encode_text(text: str, model: Union[SentenceTransformer, Tuple], model_type:
         return text_features[0].cpu().numpy().tolist()
     else:
         # sentence-transformer
+        # Lazy import for type hint only
+        # from sentence_transformers import SentenceTransformer
         embedding = model.encode(text)
         return embedding.tolist()
 
 
 def get_embedding_model_for_dimension(
     dimension: int,
-) -> Tuple[Union[SentenceTransformer, Tuple], str, str]:
+) -> Tuple["SentenceTransformer" | Tuple, str, str]:
     """
     Get a loaded embedding model for a specific dimension.
 
@@ -164,4 +172,5 @@ def get_embedding_model_for_dimension(
     """
     model_name, model_type = get_model_for_dimension(dimension)
     model = load_embedding_model(model_name, model_type)
+    # Returns a tuple: (loaded_model, model_name, model_type)
     return (model, model_name, model_type)

vector_inspector/core/logging.py

@@ -3,6 +3,7 @@
 Provides `log_info`, `log_error`, and `log_debug` helpers that delegate
 to the standard `logging` module but keep call sites concise.
 """
+
 import logging
 from typing import Any
 
@@ -12,7 +13,8 @@ if not _logger.handlers:
     formatter = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
     handler.setFormatter(formatter)
     _logger.addHandler(handler)
-    _logger.setLevel(logging.INFO)
+    # Default to WARNING to reduce console noise; set to DEBUG for troubleshooting
+    _logger.setLevel(logging.WARNING)
 
 
 def log_info(msg: str, *args: Any, **kwargs: Any) -> None:

vector_inspector/main.py

@@ -1,10 +1,13 @@
 """Main entry point for Vector Inspector application."""
 
-import sys
 import os
+import sys
+
+from PySide6.QtCore import QTimer
 from PySide6.QtWidgets import QApplication
-from vector_inspector.ui.main_window import MainWindow
-from vector_inspector.core.logging import log_error
+
+from vector_inspector import get_version
+from vector_inspector.ui.loading_screen import show_loading_screen
 
 # Ensures the app looks in its own folder for the raw libraries
 sys.path.append(os.path.dirname(sys.executable))
@@ -16,24 +19,48 @@ def main():
     app.setApplicationName("Vector Inspector")
     app.setOrganizationName("Vector Inspector")
 
-    # Telemetry: send launch ping if enabled
-    try:
-        from vector_inspector.services.telemetry_service import TelemetryService
-        from vector_inspector import get_version, __version__
+    # Get version once for all uses
+    app_version = get_version()
+
+    # Show loading screen (if not disabled in settings)
+    loading = show_loading_screen(
+        app_name="Vector Inspector",
+        version=f"v{app_version}",
+        tagline="The missing toolset for your vector data",
+        loading_text="Initializing providers…"
+    )
+
+    # Heavy imports after loading screen is visible
+    if loading:
+        loading.set_loading_text("Loading main window...")
+        app.processEvents()
 
-        app_version = None
+    from vector_inspector.core.logging import log_error
+    from vector_inspector.ui.main_window import MainWindow
+
+    def send_ping():
+        # Telemetry: send launch ping if enabled
         try:
-            app_version = get_version()
-        except Exception:
-            app_version = __version__
-        telemetry = TelemetryService()
-        telemetry.send_launch_ping(app_version=app_version)
-    except Exception as e:
-        log_error(f"[Telemetry] Failed to send launch ping: {e}")
+            from vector_inspector.services.telemetry_service import TelemetryService
+
+            telemetry = TelemetryService()
+            telemetry.send_launch_ping(app_version=app_version)
+        except Exception as e:
+            log_error(f"[Telemetry] Failed to send launch ping: {e}")
+
+    if loading:
+        loading.set_loading_text("Preparing interface...")
+        app.processEvents()
 
     window = MainWindow()
     window.show()
 
+    # Always fade out loading screen automatically
+    if loading:
+        loading.fade_out()
+
+    QTimer.singleShot(0, lambda: send_ping())
+
     sys.exit(app.exec())
 
 

vector_inspector/services/backup_restore_service.py

@@ -1,13 +1,12 @@
 """Service for backing up and restoring collections."""
 
-import json
-from typing import Dict, Any, Optional
+from datetime import datetime, timezone
 from pathlib import Path
-from datetime import datetime
-import shutil
+from typing import Optional
 
-from vector_inspector.core.logging import log_info, log_error, log_debug
-from .backup_helpers import write_backup_zip, read_backup_zip, normalize_embeddings
+from vector_inspector.core.logging import log_debug, log_error, log_info
+
+from .backup_helpers import normalize_embeddings, read_backup_zip, write_backup_zip
 
 
 class BackupRestoreService:
@@ -15,7 +14,11 @@ class BackupRestoreService:
 
     @staticmethod
     def backup_collection(
-        connection, collection_name: str, backup_dir: str, include_embeddings: bool = True
+        connection,
+        collection_name: str,
+        backup_dir: str,
+        include_embeddings: bool = True,
+        profile_name: Optional[str] = None,
     ) -> Optional[str]:
         """
         Backup a collection to a directory.
@@ -25,6 +28,7 @@ class BackupRestoreService:
             collection_name: Name of collection to backup
             backup_dir: Directory to store backups
             include_embeddings: Whether to include embedding vectors
+            connection_id: Optional connection ID for retrieving model config from settings
 
         Returns:
             Path to backup file or None if failed
@@ -50,13 +54,51 @@ class BackupRestoreService:
 
             backup_metadata = {
                 "collection_name": collection_name,
-                "backup_timestamp": datetime.now().isoformat(),
+                "backup_timestamp": datetime.now(tz=timezone.utc).isoformat(),
                 "item_count": len(all_data["ids"]),
                 "collection_info": collection_info,
                 "include_embeddings": include_embeddings,
             }
-
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            # Include embedding model info when available to assist accurate restores
+            try:
+                embed_model = None
+                embed_model_type = None
+                # Prefer explicit collection_info entries
+                if collection_info and collection_info.get("embedding_model"):
+                    embed_model = collection_info.get("embedding_model")
+                    embed_model_type = collection_info.get("embedding_model_type")
+                else:
+                    # Ask connection for a model hint (may consult settings/service)
+                    try:
+                        embed_model = connection.get_embedding_model(collection_name)
+                    except Exception:
+                        embed_model = None
+
+                # If not found yet, check app settings as a fallback
+                if not embed_model and profile_name:
+                    try:
+                        from vector_inspector.services.settings_service import SettingsService
+
+                        settings = SettingsService()
+                        model_info = settings.get_embedding_model(
+                            profile_name,
+                            collection_name,
+                        )
+                        if model_info:
+                            embed_model = model_info.get("model")
+                            embed_model_type = model_info.get("type", "sentence-transformer")
+                    except Exception:
+                        pass
+
+                if embed_model:
+                    backup_metadata["embedding_model"] = embed_model
+                if embed_model_type:
+                    backup_metadata["embedding_model_type"] = embed_model_type
+            except Exception as e:
+                # Embedding metadata is optional; log failure but do not abort backup.
+                log_debug("Failed to populate embedding metadata for %s: %s", collection_name, e)
+
+            timestamp = datetime.now(tz=timezone.utc).strftime("%Y%m%d_%H%M%S")
             backup_filename = f"{collection_name}_backup_{timestamp}.zip"
             backup_path = Path(backup_dir) / backup_filename
 
@@ -67,9 +109,14 @@ class BackupRestoreService:
             log_error("Backup failed: %s", e)
             return None
 
-    @staticmethod
     def restore_collection(
-        connection, backup_file: str, collection_name: Optional[str] = None, overwrite: bool = False
+        self,
+        connection,
+        backup_file: str,
+        collection_name: Optional[str] = None,
+        overwrite: bool = False,
+        recompute_embeddings: Optional[bool] = None,
+        profile_name: Optional[str] = None,
     ) -> bool:
         """
         Restore a collection from a backup file.
@@ -79,6 +126,11 @@ class BackupRestoreService:
             backup_file: Path to backup zip file
             collection_name: Optional new name for restored collection
             overwrite: Whether to overwrite existing collection
+            recompute_embeddings: How to handle embeddings during restore:
+                - None (default): Use stored embeddings as-is from backup (safest, fastest)
+                - True: Force recompute embeddings from documents using model metadata
+                - False: Omit embeddings entirely (documents/metadata only)
+            connection_id: Optional connection ID for saving model config to app settings
 
         Returns:
             True if successful, False otherwise
@@ -96,8 +148,48 @@ class BackupRestoreService:
                         restore_collection_name,
                     )
                     return False
-                else:
-                    connection.delete_collection(restore_collection_name)
+                connection.delete_collection(restore_collection_name)
+            else:
+                # Collection does not exist on target; attempt to create it.
+                # Try to infer vector size from metadata or embedded vectors in backup.
+                try:
+                    inferred_size = None
+                    col_info = metadata.get("collection_info") if metadata else None
+                    if (
+                        col_info
+                        and col_info.get("vector_dimension")
+                        and isinstance(col_info.get("vector_dimension"), int)
+                    ):
+                        inferred_size = int(col_info.get("vector_dimension"))
+
+                    # Fallback: inspect embeddings in backup data
+                    if inferred_size is None and data and data.get("embeddings"):
+                        first_emb = data.get("embeddings")[0]
+                        if first_emb is not None:
+                            inferred_size = len(first_emb)
+
+                    # Final fallback: common default
+                    if inferred_size is None:
+                        log_error(
+                            "Unable to infer vector dimension for collection %s from metadata or backup data; restore aborted.",
+                            restore_collection_name,
+                        )
+                        return False
+
+                    created = True
+                    if hasattr(connection, "create_collection"):
+                        created = connection.create_collection(
+                            restore_collection_name, inferred_size
+                        )
+
+                    if not created:
+                        log_error(
+                            "Failed to create collection %s before restore", restore_collection_name
+                        )
+                        return False
+                except Exception as e:
+                    log_error("Error while creating collection %s: %s", restore_collection_name, e)
+                    return False
 
             # Provider-specific preparation hook
             if hasattr(connection, "prepare_restore"):
@@ -109,17 +201,138 @@ class BackupRestoreService:
             # Ensure embeddings normalized
             data = normalize_embeddings(data)
 
+            # Decide how to handle embeddings based on user choice
+            embeddings_to_use = None
+            stored_embeddings = data.get("embeddings")
+
+            if recompute_embeddings is False:
+                # User explicitly chose to omit embeddings
+                log_info("Restoring without embeddings (user choice)")
+                embeddings_to_use = None
+
+            elif recompute_embeddings is True:
+                # User explicitly chose to recompute embeddings
+                log_info("Recomputing embeddings from documents")
+                try:
+                    from vector_inspector.core.embedding_utils import (
+                        encode_text,
+                        load_embedding_model,
+                    )
+
+                    model_name = metadata.get("embedding_model") if metadata else None
+                    docs = data.get("documents", [])
+
+                    if not model_name:
+                        log_error(
+                            "Cannot recompute: No embedding model available in backup metadata"
+                        )
+                        embeddings_to_use = None
+                    elif not docs:
+                        log_error("Cannot recompute: No documents available in backup")
+                        embeddings_to_use = None
+                    else:
+                        model_type = metadata.get("embedding_model_type", "sentence-transformer")
+                        log_info("Loading embedding model: %s (%s)", model_name, model_type)
+                        model = load_embedding_model(model_name, model_type)
+                        new_embeddings = []
+                        if model_type == "clip":
+                            # CLIP: encode per-document
+                            for d in docs:
+                                new_embeddings.append(encode_text(d, model, model_type))
+                        else:
+                            # sentence-transformer supports batch encode
+                            new_embeddings = model.encode(docs, show_progress_bar=False).tolist()
+
+                        embeddings_to_use = new_embeddings
+                        log_info("Successfully recomputed %d embeddings", len(new_embeddings))
+                except Exception as e:
+                    log_error("Failed to recompute embeddings: %s", e)
+                    embeddings_to_use = None
+
+            else:
+                # Default (None): Use stored embeddings as-is if available
+                if stored_embeddings:
+                    # Check dimension compatibility with target collection
+                    try:
+                        if stored_embeddings and len(stored_embeddings) > 0:
+                            stored_dim = len(stored_embeddings[0])
+                            target_dim = inferred_size  # We already calculated this above
+
+                            if stored_dim == target_dim:
+                                log_info(
+                                    "Using stored embeddings from backup (dimension: %d)",
+                                    stored_dim,
+                                )
+                                embeddings_to_use = stored_embeddings
+                            else:
+                                log_error(
+                                    "Dimension mismatch: backup has %d, target needs %d. Omitting embeddings.",
+                                    stored_dim,
+                                    target_dim,
+                                )
+                                embeddings_to_use = None
+                        else:
+                            embeddings_to_use = stored_embeddings
+                    except Exception as e:
+                        log_error("Error checking embedding dimensions: %s", e)
+                        # Try to use them anyway
+                        embeddings_to_use = stored_embeddings
+                else:
+                    log_info("No embeddings in backup to restore")
+                    embeddings_to_use = None
+
             success = connection.add_items(
                 restore_collection_name,
                 documents=data.get("documents", []),
                 metadatas=data.get("metadatas"),
                 ids=data.get("ids"),
-                embeddings=data.get("embeddings"),
+                embeddings=embeddings_to_use,
             )
 
             if success:
                 log_info("Collection '%s' restored from backup", restore_collection_name)
                 log_info("Restored %d items", len(data.get("ids", [])))
+
+                # Save model config to app settings if available
+                if profile_name and restore_collection_name and metadata:
+                    try:
+                        embed_model = metadata.get("embedding_model")
+                        embed_model_type = metadata.get(
+                            "embedding_model_type", "sentence-transformer"
+                        )
+                        if embed_model:
+                            from vector_inspector.services.settings_service import SettingsService
+
+                            settings = SettingsService()
+                            settings.save_embedding_model(
+                                profile_name,
+                                restore_collection_name,
+                                embed_model,
+                                embed_model_type,
+                            )
+                            log_info(
+                                "Saved model config to settings: %s (%s)",
+                                embed_model,
+                                embed_model_type,
+                            )
+                    except Exception as e:
+                        log_error("Failed to save model config to settings: %s", e)
+
+                # Clear the cache for this collection so the info panel gets fresh data
+                if profile_name and restore_collection_name:
+                    try:
+                        from vector_inspector.core.cache_manager import get_cache_manager
+
+                        cache = get_cache_manager()
+                        # Use profile_name as the database identifier for cache
+                        cache.invalidate(profile_name, restore_collection_name)
+                        log_info(
+                            "Cleared cache for restored collection: %s",
+                            restore_collection_name,
+                        )
+                    except Exception as e:
+                        log_error("Failed to clear cache after restore: %s", e)
+
                 return True
 
             # Failure: attempt cleanup