vector-inspector 0.2.4.3__tar.gz → 0.2.6__tar.gz

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vector-inspector
-Version: 0.2.4.3
+Version: 0.2.6
 Summary: A comprehensive desktop application for visualizing, querying, and managing vector database data
 Author-Email: Anthony Dawson <anthonypdawson+github@gmail.com>
 License: MIT
@@ -8,7 +8,7 @@ Project-URL: Homepage, https://vector-inspector.divinedevops.com
 Project-URL: Source, https://github.com/anthonypdawson/vector-inspector
 Project-URL: Issues, https://github.com/anthonypdawson/vector-inspector/issues
 Project-URL: Documentation, https://github.com/anthonypdawson/vector-inspector#readme
-Requires-Python: ==3.12.*
+Requires-Python: <3.13,>=3.10
 Requires-Dist: chromadb>=0.4.22
 Requires-Dist: qdrant-client>=1.7.0
 Requires-Dist: pyside6>=6.6.0
@@ -26,6 +26,9 @@ Description-Content-Type: text/markdown
 
 
 # Vector Inspector
+
+> **Disclaimer:** This tool is currently under active development and is **not production ready**. Not all features have been thoroughly tested and code is released frequently. Use with caution in critical or production environments.
+
 ![PyPI](https://img.shields.io/pypi/v/vector-inspector)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/vector-inspector?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/vector-inspector)
 

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/README.md

@@ -1,5 +1,8 @@
 
 # Vector Inspector
+
+> **Disclaimer:** This tool is currently under active development and is **not production ready**. Not all features have been thoroughly tested and code is released frequently. Use with caution in critical or production environments.
+
 ![PyPI](https://img.shields.io/pypi/v/vector-inspector)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/vector-inspector?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/vector-inspector)
 

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vector-inspector"
-version = "0.2.4.3"
+version = "0.2.6"
 description = "A comprehensive desktop application for visualizing, querying, and managing vector database data"
 authors = [
     { name = "Anthony Dawson", email = "anthonypdawson+github@gmail.com" },
@@ -20,7 +20,7 @@ dependencies = [
     "pyarrow>=14.0.0",
     "pinecone>=8.0.0",
 ]
-requires-python = "==3.12.*"
+requires-python = ">=3.10,<3.13"
 readme = "README.md"
 
 [project.license]

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/core/connections/chroma_connection.py

@@ -125,16 +125,42 @@ class ChromaDBConnection(VectorDBConnection):
         
         try:
             count = collection.count()
-            # Get a sample to determine metadata fields
-            sample = collection.get(limit=1, include=["metadatas"])
+            # Get a sample to determine metadata fields and vector dimensions
+            sample = collection.get(limit=1, include=["metadatas", "embeddings"])
             metadata_fields = []
+            vector_dimension = "Unknown"
+            
             if sample and sample["metadatas"]:
                 metadata_fields = list(sample["metadatas"][0].keys()) if sample["metadatas"][0] else []
             
+            # Determine vector dimensions from embeddings
+            embeddings = sample.get("embeddings") if sample else None
+            if embeddings is not None and len(embeddings) > 0 and embeddings[0] is not None:
+                vector_dimension = len(embeddings[0])
+            
+            # ChromaDB uses cosine distance by default (or can be configured)
+            # Try to get metadata from collection if available
+            distance_metric = "Cosine (default)"
+            try:
+                # ChromaDB collections may have metadata about distance function
+                col_metadata = collection.metadata
+                if col_metadata and "hnsw:space" in col_metadata:
+                    space = col_metadata["hnsw:space"]
+                    if space == "l2":
+                        distance_metric = "Euclidean (L2)"
+                    elif space == "ip":
+                        distance_metric = "Inner Product"
+                    elif space == "cosine":
+                        distance_metric = "Cosine"
+            except:
+                pass  # Use default if unable to determine
+            
             return {
                 "name": name,
                 "count": count,
                 "metadata_fields": metadata_fields,
+                "vector_dimension": vector_dimension,
+                "distance_metric": distance_metric,
             }
         except Exception as e:
             print(f"Failed to get collection info: {e}")

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/core/connections/qdrant_connection.py

@@ -191,11 +191,71 @@ class QdrantConnection(VectorDBConnection):
                     # Extract metadata fields, excluding 'document' if present
                     metadata_fields = [k for k in point.payload.keys() if k != 'document']
             
-            return {
+            # Extract vector configuration
+            vector_dimension = "Unknown"
+            distance_metric = "Unknown"
+            config_details = {}
+            
+            if collection_info.config:
+                # Get vector parameters
+                if hasattr(collection_info.config, 'params'):
+                    params = collection_info.config.params
+                    if hasattr(params, 'vectors'):
+                        vectors = params.vectors
+                        # Handle both dict and object access
+                        if isinstance(vectors, dict):
+                            # Named vectors
+                            first_vector = next(iter(vectors.values()), None)
+                            if first_vector:
+                                vector_dimension = getattr(first_vector, 'size', 'Unknown')
+                                distance = getattr(first_vector, 'distance', None)
+                        else:
+                            # Single vector config
+                            vector_dimension = getattr(vectors, 'size', 'Unknown')
+                            distance = getattr(vectors, 'distance', None)
+                        
+                        # Map distance enum to readable name
+                        if distance:
+                            distance_str = str(distance)
+                            if 'COSINE' in distance_str.upper():
+                                distance_metric = "Cosine"
+                            elif 'EUCLID' in distance_str.upper():
+                                distance_metric = "Euclidean"
+                            elif 'DOT' in distance_str.upper():
+                                distance_metric = "Dot Product"
+                            elif 'MANHATTAN' in distance_str.upper():
+                                distance_metric = "Manhattan"
+                            else:
+                                distance_metric = distance_str
+                
+                # Get HNSW config if available
+                if hasattr(collection_info.config, 'hnsw_config'):
+                    hnsw = collection_info.config.hnsw_config
+                    config_details['hnsw_config'] = {
+                        'm': getattr(hnsw, 'm', None),
+                        'ef_construct': getattr(hnsw, 'ef_construct', None),
+                    }
+                
+                # Get optimizer config if available
+                if hasattr(collection_info.config, 'optimizer_config'):
+                    opt = collection_info.config.optimizer_config
+                    config_details['optimizer_config'] = {
+                        'indexing_threshold': getattr(opt, 'indexing_threshold', None),
+                    }
+            
+            result = {
                 "name": name,
                 "count": collection_info.points_count,
                 "metadata_fields": metadata_fields,
+                "vector_dimension": vector_dimension,
+                "distance_metric": distance_metric,
             }
+            
+            if config_details:
+                result['config'] = config_details
+            
+            return result
+            
         except Exception as e:
             print(f"Failed to get collection info: {e}")
             return None

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/services/settings_service.py

@@ -10,7 +10,7 @@ class SettingsService:
     
     def __init__(self):
         """Initialize settings service."""
-        self.settings_dir = Path.home() / ".vector-viewer"
+        self.settings_dir = Path.home() / ".vector-inspector"
         self.settings_file = self.settings_dir / "settings.json"
         self.settings: Dict[str, Any] = {}
         self._load_settings()

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/services/visualization_service.py

@@ -1,10 +1,7 @@
 """Visualization service for dimensionality reduction."""
 
-from typing import Optional, List, Tuple
-import numpy as np
-from sklearn.decomposition import PCA
-from sklearn.manifold import TSNE
-import umap
+from typing import Optional, List, Tuple, Any
+import warnings
 
 
 class VisualizationService:
@@ -16,7 +13,7 @@ class VisualizationService:
         method: str = "pca",
         n_components: int = 2,
         **kwargs
-    ) -> Optional[np.ndarray]:
+    ) -> Optional[Any]:
         """
         Reduce dimensionality of embeddings.
         
@@ -33,13 +30,19 @@ class VisualizationService:
             return None
             
         try:
+            # Lazy import numpy and models
+            from vector_inspector.utils.lazy_imports import get_numpy, get_sklearn_model
+            np = get_numpy()
+            
             X = np.array(embeddings)
             
-            if method == "pca":
+            if method.lower() == "pca":
+                PCA = get_sklearn_model('PCA')
                 reducer = PCA(n_components=n_components)
                 reduced = reducer.fit_transform(X)
                 
-            elif method == "tsne":
+            elif method.lower() in ["t-sne", "tsne"]:
+                TSNE = get_sklearn_model('TSNE')
                 perplexity = kwargs.get("perplexity", min(30, len(embeddings) - 1))
                 reducer = TSNE(
                     n_components=n_components,
@@ -48,14 +51,18 @@ class VisualizationService:
                 )
                 reduced = reducer.fit_transform(X)
                 
-            elif method == "umap":
+            elif method.lower() == "umap":
+                UMAP = get_sklearn_model('UMAP')
                 n_neighbors = kwargs.get("n_neighbors", min(15, len(embeddings) - 1))
-                reducer = umap.UMAP(
-                    n_components=n_components,
-                    n_neighbors=n_neighbors,
-                    random_state=42
-                )
-                reduced = reducer.fit_transform(X)
+                # Suppress n_jobs warning when using random_state
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", message=".*n_jobs.*overridden.*")
+                    reducer = UMAP(
+                        n_components=n_components,
+                        n_neighbors=n_neighbors,
+                        random_state=42
+                    )
+                    reduced = reducer.fit_transform(X)
                 
             else:
                 print(f"Unknown method: {method}")
@@ -69,11 +76,11 @@ class VisualizationService:
     
     @staticmethod
     def prepare_plot_data(
-        reduced_embeddings: np.ndarray,
+        reduced_embeddings: Any,
         labels: Optional[List[str]] = None,
         metadata: Optional[List[dict]] = None,
         color_by: Optional[str] = None
-    ) -> Tuple[np.ndarray, List[str], List[str]]:
+    ) -> Tuple[Any, List[str], List[str]]:
         """
         Prepare data for plotting.
         

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/ui/main_window.py

@@ -5,17 +5,18 @@ from PySide6.QtWidgets import (
     QSplitter, QTabWidget, QStatusBar, QToolBar,
     QMessageBox, QInputDialog, QFileDialog
 )
-from PySide6.QtCore import Qt, Signal
+from PySide6.QtCore import Qt, Signal, QTimer
 from PySide6.QtGui import QAction
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.connections.chroma_connection import ChromaDBConnection
 from vector_inspector.ui.views.connection_view import ConnectionView
 from vector_inspector.ui.views.collection_browser import CollectionBrowser
+from vector_inspector.ui.views.info_panel import InfoPanel
 from vector_inspector.ui.views.metadata_view import MetadataView
 from vector_inspector.ui.views.search_view import SearchView
-from vector_inspector.ui.views.visualization_view import VisualizationView
 from vector_inspector.ui.components.backup_restore_dialog import BackupRestoreDialog
+from vector_inspector.ui.components.loading_dialog import LoadingDialog
 
 
 class MainWindow(QMainWindow):
@@ -27,6 +28,7 @@ class MainWindow(QMainWindow):
         super().__init__()
         self.connection: VectorDBConnection = ChromaDBConnection()
         self.current_collection: str = ""
+        self.loading_dialog = LoadingDialog("Loading collection...", self)
         
         self.setWindowTitle("Vector Inspector")
         self.setGeometry(100, 100, 1400, 900)
@@ -63,13 +65,21 @@ class MainWindow(QMainWindow):
         # Right panel - Tabbed views
         self.tab_widget = QTabWidget()
         
+        self.info_panel = InfoPanel(self.connection)
         self.metadata_view = MetadataView(self.connection)
         self.search_view = SearchView(self.connection)
-        self.visualization_view = VisualizationView(self.connection)
+        self.visualization_view = None  # Lazy loaded
         
+        self.tab_widget.addTab(self.info_panel, "Info")
         self.tab_widget.addTab(self.metadata_view, "Data Browser")
         self.tab_widget.addTab(self.search_view, "Search")
-        self.tab_widget.addTab(self.visualization_view, "Visualization")
+        self.tab_widget.addTab(QWidget(), "Visualization")  # Placeholder
+        
+        # Set Info tab as default
+        self.tab_widget.setCurrentIndex(0)
+        
+        # Connect to tab change to lazy load visualization
+        self.tab_widget.currentChanged.connect(self._on_tab_changed)
         
         # Add panels to splitter
         main_splitter.addWidget(left_panel)
@@ -167,14 +177,34 @@ class MainWindow(QMainWindow):
         self.connection_view.connection_created.connect(self._on_connection_created)
         self.collection_browser.collection_selected.connect(self._on_collection_selected)
     
+    def _on_tab_changed(self, index: int):
+        """Handle tab change - lazy load visualization tab."""
+        if index == 3 and self.visualization_view is None:
+            # Lazy load visualization view
+            from vector_inspector.ui.views.visualization_view import VisualizationView
+            self.visualization_view = VisualizationView(self.connection)
+            # Replace placeholder with actual view
+            self.tab_widget.removeTab(3)
+            self.tab_widget.insertTab(3, self.visualization_view, "Visualization")
+            self.tab_widget.setCurrentIndex(3)
+            # Set collection if one is already selected
+            if self.current_collection:
+                self.visualization_view.set_collection(self.current_collection)
+    
     def _on_connection_created(self, new_connection: VectorDBConnection):
         """Handle when a new connection instance is created."""
         self.connection = new_connection
         # Update all views with new connection
         self.collection_browser.connection = new_connection
+        self.info_panel.connection = new_connection
         self.metadata_view.connection = new_connection
         self.search_view.connection = new_connection
-        self.visualization_view.connection = new_connection
+        # Only update visualization if it's been created
+        if self.visualization_view is not None:
+            self.visualization_view.connection = new_connection
+        # Refresh the collection browser to show new database's collections
+        if new_connection.is_connected:
+            self.collection_browser.refresh()
         
     def _on_connect(self):
         """Handle connect action."""
@@ -187,6 +217,11 @@ class MainWindow(QMainWindow):
             self.statusBar.showMessage("Disconnected")
             self.connection_changed.emit(False)
             self.collection_browser.clear()
+            # Clear info panel
+            self.info_panel.refresh_database_info()
+        else:
+            # Always clear collection browser on disconnect
+            self.collection_browser.clear()
             
     def _on_connection_status_changed(self, connected: bool):
         """Handle connection status change."""
@@ -194,24 +229,45 @@ class MainWindow(QMainWindow):
             self.statusBar.showMessage("Connected")
             self.connection_changed.emit(True)
             self._on_refresh_collections()
+            # Refresh info panel with new connection
+            self.info_panel.refresh_database_info()
         else:
             self.statusBar.showMessage("Connection failed")
             self.connection_changed.emit(False)
+            # Clear info panel and collection browser
+            self.info_panel.refresh_database_info()
+            self.collection_browser.clear()
             
     def _on_collection_selected(self, collection_name: str):
         """Handle collection selection."""
         self.current_collection = collection_name
         self.statusBar.showMessage(f"Collection: {collection_name}")
         
+        # Show loading dialog immediately
+        self.loading_dialog.show_loading(f"Loading collection '{collection_name}'...")
+        
+        # Update views with new collection - use QTimer to allow loading dialog to appear first
+        QTimer.singleShot(10, lambda: self._update_views_for_collection(collection_name))
+    
+    def _update_views_for_collection(self, collection_name: str):
+        """Update all views with the selected collection."""
         # Update all views with new collection
+        self.info_panel.set_collection(collection_name)
         self.metadata_view.set_collection(collection_name)
         self.search_view.set_collection(collection_name)
-        self.visualization_view.set_collection(collection_name)
+        # Only update visualization if it's been created
+        if self.visualization_view is not None:
+            self.visualization_view.set_collection(collection_name)
+        
+        # Hide loading dialog
+        self.loading_dialog.hide_loading()
         
     def _on_refresh_collections(self):
         """Refresh collection list."""
         if self.connection.is_connected:
             self.collection_browser.refresh()
+            # Also refresh database info (collection count may have changed)
+            self.info_panel.refresh_database_info()
             
     def _on_new_collection(self):
         """Create a new collection."""

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/ui/views/connection_view.py

@@ -5,7 +5,7 @@ from PySide6.QtWidgets import (
     QPushButton, QDialog, QFormLayout, QLineEdit,
     QRadioButton, QButtonGroup, QGroupBox, QFileDialog, QComboBox, QApplication, QCheckBox
 )
-from PySide6.QtCore import Signal
+from PySide6.QtCore import Signal, QThread
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.connections.chroma_connection import ChromaDBConnection
@@ -14,6 +14,28 @@ from vector_inspector.ui.components.loading_dialog import LoadingDialog
 from vector_inspector.services.settings_service import SettingsService
 
 
+class ConnectionThread(QThread):
+    """Background thread for connecting to database."""
+    
+    finished = Signal(bool, list)  # success, collections
+    
+    def __init__(self, connection):
+        super().__init__()
+        self.connection = connection
+        
+    def run(self):
+        """Connect to database and get collections."""
+        try:
+            success = self.connection.connect()
+            if success:
+                collections = self.connection.list_collections()
+                self.finished.emit(True, collections)
+            else:
+                self.finished.emit(False, [])
+        except Exception:
+            self.finished.emit(False, [])
+
+
 class ConnectionDialog(QDialog):
     """Dialog for configuring database connection."""
     
@@ -175,6 +197,9 @@ class ConnectionDialog(QDialog):
         
     def get_connection_config(self):
         """Get connection configuration from dialog."""
+        # Get current provider from combo box to ensure it's up to date
+        self.provider = self.provider_combo.currentData()
+        
         config = {"provider": self.provider}
         
         if self.persistent_radio.isChecked():
@@ -294,6 +319,7 @@ class ConnectionView(QWidget):
         self.connection = connection
         self.loading_dialog = LoadingDialog("Connecting to database...", self)
         self.settings_service = SettingsService()
+        self.connection_thread = None
         self._setup_ui()
         
         # Try to auto-connect if enabled in settings
@@ -339,7 +365,6 @@ class ConnectionView(QWidget):
     def _connect_with_config(self, config: dict):
         """Connect to database with given configuration."""
         self.loading_dialog.show_loading("Connecting to database...")
-        QApplication.processEvents()
         
         provider = config.get("provider", "chromadb")
         conn_type = config.get("type")
@@ -367,11 +392,25 @@ class ConnectionView(QWidget):
             else:  # ephemeral
                 self.connection = ChromaDBConnection()
                 
+        # Store config for later use
+        self._pending_config = config
+        
         # Notify parent that connection instance changed
         self.connection_created.emit(self.connection)
-        success = self.connection.connect()
-            
+        
+        # Start background thread to connect
+        self.connection_thread = ConnectionThread(self.connection)
+        self.connection_thread.finished.connect(self._on_connection_finished)
+        self.connection_thread.start()
+    
+    def _on_connection_finished(self, success: bool, collections: list):
+        """Handle connection thread completion."""
+        self.loading_dialog.hide_loading()
+        
         if success:
+            config = self._pending_config
+            provider = config.get("provider", "chromadb")
+            
             # Show provider, path/host + collection count for clarity
             details = []
             details.append(f"provider: {provider}")
@@ -380,7 +419,6 @@ class ConnectionView(QWidget):
             if hasattr(self.connection, 'host') and self.connection.host:
                 port = getattr(self.connection, 'port', None)
                 details.append(f"host: {self.connection.host}:{port}")
-            collections = self.connection.list_collections()
             count_text = f"collections: {len(collections)}"
             info = ", ".join(details)
             self.status_label.setText(f"Status: Connected ({info}, {count_text})")
@@ -401,9 +439,6 @@ class ConnectionView(QWidget):
             self.disconnect_button.setEnabled(False)
             self.connection_changed.emit(False)
         
-        # Close loading dialog after everything is complete
-        self.loading_dialog.hide_loading()
-        
     def _disconnect(self):
         """Disconnect from database."""
         self.connection.disconnect()

vector_inspector-0.2.6/src/vector_inspector/ui/views/info_panel.py

@@ -0,0 +1,287 @@
+"""Information panel for displaying database and collection metadata."""
+
+from typing import Optional, Dict, Any
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QLabel,
+    QGroupBox, QScrollArea, QFrame
+)
+from PySide6.QtCore import Qt, QObject
+
+from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.connections.chroma_connection import ChromaDBConnection
+from vector_inspector.core.connections.qdrant_connection import QdrantConnection
+
+
+class InfoPanel(QWidget):
+    """Panel for displaying database and collection information."""
+    
+    def __init__(self, connection: VectorDBConnection, parent=None):
+        super().__init__(parent)
+        self.connection = connection
+        self.current_collection: str = ""
+        self._setup_ui()
+        
+    def _setup_ui(self):
+        """Setup widget UI."""
+        layout = QVBoxLayout(self)
+        
+        # Create scroll area for content
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        
+        # Container for all info sections
+        container = QWidget()
+        container_layout = QVBoxLayout(container)
+        container_layout.setSpacing(10)
+        
+        # Database Information Section
+        self.db_group = QGroupBox("Database Information")
+        db_layout = QVBoxLayout()
+        
+        self.provider_label = self._create_info_row("Provider:", "Not connected")
+        self.connection_type_label = self._create_info_row("Connection Type:", "N/A")
+        self.endpoint_label = self._create_info_row("Endpoint:", "N/A")
+        self.api_key_label = self._create_info_row("API Key:", "N/A")
+        self.status_label = self._create_info_row("Status:", "Disconnected")
+        self.collections_count_label = self._create_info_row("Total Collections:", "0")
+        
+        db_layout.addWidget(self.provider_label)
+        db_layout.addWidget(self.connection_type_label)
+        db_layout.addWidget(self.endpoint_label)
+        db_layout.addWidget(self.api_key_label)
+        db_layout.addWidget(self.status_label)
+        db_layout.addWidget(self.collections_count_label)
+        
+        self.db_group.setLayout(db_layout)
+        container_layout.addWidget(self.db_group)
+        
+        # Collection Information Section
+        self.collection_group = QGroupBox("Collection Information")
+        collection_layout = QVBoxLayout()
+        
+        self.collection_name_label = self._create_info_row("Name:", "No collection selected")
+        self.vector_dim_label = self._create_info_row("Vector Dimension:", "N/A")
+        self.distance_metric_label = self._create_info_row("Distance Metric:", "N/A")
+        self.total_points_label = self._create_info_row("Total Points:", "0")
+        
+        collection_layout.addWidget(self.collection_name_label)
+        collection_layout.addWidget(self.vector_dim_label)
+        collection_layout.addWidget(self.distance_metric_label)
+        collection_layout.addWidget(self.total_points_label)
+        
+        # Payload Schema subsection
+        schema_label = QLabel("<b>Payload Schema:</b>")
+        collection_layout.addWidget(schema_label)
+        
+        self.schema_label = QLabel("N/A")
+        self.schema_label.setWordWrap(True)
+        self.schema_label.setStyleSheet("color: gray; padding-left: 20px;")
+        collection_layout.addWidget(self.schema_label)
+        
+        # Provider-specific details
+        provider_details_label = QLabel("<b>Provider-Specific Details:</b>")
+        collection_layout.addWidget(provider_details_label)
+        
+        self.provider_details_label = QLabel("N/A")
+        self.provider_details_label.setWordWrap(True)
+        self.provider_details_label.setStyleSheet("color: gray; padding-left: 20px;")
+        collection_layout.addWidget(self.provider_details_label)
+        
+        self.collection_group.setLayout(collection_layout)
+        container_layout.addWidget(self.collection_group)
+        
+        # Add stretch to push content to top
+        container_layout.addStretch()
+        
+        scroll.setWidget(container)
+        layout.addWidget(scroll)
+        
+        # Initial state
+        self.refresh_database_info()
+        
+    def _create_info_row(self, label: str, value: str) -> QWidget:
+        """Create a row with label and value."""
+        row = QWidget()
+        row_layout = QHBoxLayout(row)
+        row_layout.setContentsMargins(0, 2, 0, 2)
+        
+        label_widget = QLabel(f"<b>{label}</b>")
+        label_widget.setMinimumWidth(150)
+        row_layout.addWidget(label_widget)
+        
+        value_widget = QLabel(value)
+        value_widget.setWordWrap(True)
+        value_widget.setStyleSheet("color: white;")
+        row_layout.addWidget(value_widget, stretch=1)
+        
+        # Store value widget for later updates (use setProperty for type safety)
+        row.setProperty("value_label", value_widget)
+        
+        return row
+        
+    def refresh_database_info(self):
+        """Refresh database connection information."""
+        if not self.connection or not self.connection.is_connected:
+            self._update_label(self.provider_label, "Not connected")
+            self._update_label(self.connection_type_label, "N/A")
+            self._update_label(self.endpoint_label, "N/A")
+            self._update_label(self.api_key_label, "N/A")
+            self._update_label(self.status_label, "Disconnected")
+            self._update_label(self.collections_count_label, "0")
+            # Also clear collection info
+            self._update_label(self.collection_name_label, "No collection selected")
+            self._update_label(self.vector_dim_label, "N/A")
+            self._update_label(self.distance_metric_label, "N/A")
+            self._update_label(self.total_points_label, "0")
+            self.schema_label.setText("N/A")
+            self.provider_details_label.setText("N/A")
+            return
+            
+        # Get provider name
+        provider_name = self.connection.__class__.__name__.replace("Connection", "")
+        self._update_label(self.provider_label, provider_name)
+        
+        # Get connection details
+        if isinstance(self.connection, ChromaDBConnection):
+            if self.connection.path:
+                self._update_label(self.connection_type_label, "Persistent (Local)")
+                self._update_label(self.endpoint_label, self.connection.path)
+            elif self.connection.host and self.connection.port:
+                self._update_label(self.connection_type_label, "HTTP (Remote)")
+                self._update_label(self.endpoint_label, f"{self.connection.host}:{self.connection.port}")
+            else:
+                self._update_label(self.connection_type_label, "Ephemeral (In-Memory)")
+                self._update_label(self.endpoint_label, "N/A")
+            self._update_label(self.api_key_label, "Not required")
+            
+        elif isinstance(self.connection, QdrantConnection):
+            if self.connection.path:
+                self._update_label(self.connection_type_label, "Embedded (Local)")
+                self._update_label(self.endpoint_label, self.connection.path)
+            elif self.connection.url:
+                self._update_label(self.connection_type_label, "Remote (URL)")
+                self._update_label(self.endpoint_label, self.connection.url)
+            elif self.connection.host:
+                self._update_label(self.connection_type_label, "Remote (Host)")
+                self._update_label(self.endpoint_label, f"{self.connection.host}:{self.connection.port}")
+            else:
+                self._update_label(self.connection_type_label, "In-Memory")
+                self._update_label(self.endpoint_label, "N/A")
+                
+            if self.connection.api_key:
+                self._update_label(self.api_key_label, "Present (hidden)")
+            else:
+                self._update_label(self.api_key_label, "Not configured")
+        else:
+            self._update_label(self.connection_type_label, "Unknown")
+            self._update_label(self.endpoint_label, "N/A")
+            self._update_label(self.api_key_label, "Unknown")
+        
+        # Status
+        self._update_label(self.status_label, "Connected" if self.connection.is_connected else "Disconnected")
+        
+        # Count collections
+        try:
+            collections = self.connection.list_collections()
+            self._update_label(self.collections_count_label, str(len(collections)))
+        except Exception as e:
+            self._update_label(self.collections_count_label, "Error")
+    
+    def refresh_collection_info(self):
+        """Refresh collection-specific information."""
+        if not self.current_collection or not self.connection or not self.connection.is_connected:
+            self._update_label(self.collection_name_label, "No collection selected")
+            self._update_label(self.vector_dim_label, "N/A")
+            self._update_label(self.distance_metric_label, "N/A")
+            self._update_label(self.total_points_label, "0")
+            self.schema_label.setText("N/A")
+            self.provider_details_label.setText("N/A")
+            return
+            
+        try:
+            # Get collection info
+            collection_info = self.connection.get_collection_info(self.current_collection)
+            
+            if not collection_info:
+                self._update_label(self.collection_name_label, self.current_collection)
+                self._update_label(self.vector_dim_label, "Unable to retrieve")
+                self._update_label(self.distance_metric_label, "Unable to retrieve")
+                self._update_label(self.total_points_label, "Unable to retrieve")
+                self.schema_label.setText("Unable to retrieve collection info")
+                self.provider_details_label.setText("N/A")
+                return
+            
+            # Update basic info
+            self._update_label(self.collection_name_label, self.current_collection)
+            
+            # Vector dimension
+            vector_dim = collection_info.get("vector_dimension", "Unknown")
+            self._update_label(self.vector_dim_label, str(vector_dim))
+            
+            # Distance metric
+            distance = collection_info.get("distance_metric", "Unknown")
+            self._update_label(self.distance_metric_label, distance)
+            
+            # Total points
+            count = collection_info.get("count", 0)
+            self._update_label(self.total_points_label, f"{count:,}")
+            
+            # Metadata schema
+            metadata_fields = collection_info.get("metadata_fields", [])
+            if metadata_fields:
+                schema_text = "\n".join([f"• {field}" for field in sorted(metadata_fields)])
+                self.schema_label.setText(schema_text)
+                self.schema_label.setStyleSheet("color: white; padding-left: 20px; font-family: monospace;")
+            else:
+                self.schema_label.setText("No metadata fields found")
+                self.schema_label.setStyleSheet("color: gray; padding-left: 20px;")
+            
+            # Provider-specific details
+            details_list = []
+            
+            if isinstance(self.connection, ChromaDBConnection):
+                details_list.append("• Provider: ChromaDB")
+                details_list.append("• Supports: Documents, Metadata, Embeddings")
+                details_list.append("• Default embedding: all-MiniLM-L6-v2")
+                
+            elif isinstance(self.connection, QdrantConnection):
+                details_list.append("• Provider: Qdrant")
+                details_list.append("• Supports: Points, Payload, Vectors")
+                # Get additional Qdrant-specific info if available
+                if "config" in collection_info:
+                    config = collection_info["config"]
+                    if "hnsw_config" in config:
+                        hnsw = config["hnsw_config"]
+                        details_list.append(f"• HNSW M: {hnsw.get('m', 'N/A')}")
+                        details_list.append(f"• HNSW ef_construct: {hnsw.get('ef_construct', 'N/A')}")
+                    if "optimizer_config" in config:
+                        opt = config["optimizer_config"]
+                        details_list.append(f"• Indexing threshold: {opt.get('indexing_threshold', 'N/A')}")
+            
+            if details_list:
+                self.provider_details_label.setText("\n".join(details_list))
+                self.provider_details_label.setStyleSheet("color: white; padding-left: 20px; font-family: monospace;")
+            else:
+                self.provider_details_label.setText("No additional details available")
+                self.provider_details_label.setStyleSheet("color: gray; padding-left: 20px;")
+                
+        except Exception as e:
+            self._update_label(self.collection_name_label, self.current_collection)
+            self._update_label(self.vector_dim_label, "Error")
+            self._update_label(self.distance_metric_label, "Error")
+            self._update_label(self.total_points_label, "Error")
+            self.schema_label.setText(f"Error: {str(e)}")
+            self.schema_label.setStyleSheet("color: red; padding-left: 20px;")
+            self.provider_details_label.setText("N/A")
+    
+    def set_collection(self, collection_name: str):
+        """Set the current collection and refresh its information."""
+        self.current_collection = collection_name
+        self.refresh_collection_info()
+    
+    def _update_label(self, row_widget: QWidget, value: str):
+        """Update the value label in an info row."""
+        value_label = row_widget.property("value_label")
+        if value_label and isinstance(value_label, QLabel):
+            value_label.setText(value)

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/ui/views/metadata_view.py

@@ -7,7 +7,7 @@ from PySide6.QtWidgets import (
     QLineEdit, QComboBox, QGroupBox, QHeaderView, QMessageBox, QDialog,
     QFileDialog, QMenu
 )
-from PySide6.QtCore import Qt, QTimer
+from PySide6.QtCore import Qt, QTimer, QThread, Signal
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.ui.components.item_dialog import ItemDialog
@@ -19,6 +19,37 @@ from vector_inspector.services.settings_service import SettingsService
 from PySide6.QtWidgets import QApplication
 
 
+class DataLoadThread(QThread):
+    """Background thread for loading collection data."""
+    
+    finished = Signal(dict)
+    error = Signal(str)
+    
+    def __init__(self, connection, collection, page_size, offset, server_filter):
+        super().__init__()
+        self.connection = connection
+        self.collection = collection
+        self.page_size = page_size
+        self.offset = offset
+        self.server_filter = server_filter
+        
+    def run(self):
+        """Load data from database."""
+        try:
+            data = self.connection.get_all_items(
+                self.collection,
+                limit=self.page_size,
+                offset=self.offset,
+                where=self.server_filter
+            )
+            if data:
+                self.finished.emit(data)
+            else:
+                self.error.emit("Failed to load data")
+        except Exception as e:
+            self.error.emit(str(e))
+
+
 class MetadataView(QWidget):
     """View for browsing collection data and metadata."""
     
@@ -31,6 +62,7 @@ class MetadataView(QWidget):
         self.current_page = 0
         self.loading_dialog = LoadingDialog("Loading data...", self)
         self.settings_service = SettingsService()
+        self.load_thread: Optional[DataLoadThread] = None
         
         # Debounce timer for filter changes
         self.filter_reload_timer = QTimer()
@@ -145,21 +177,11 @@ class MetadataView(QWidget):
         self.current_collection = collection_name
         self.current_page = 0
         
-        # Show loading dialog at the start
-        self.loading_dialog.show_loading("Loading collection data...")
-        QApplication.processEvents()
+        # Update filter builder with supported operators
+        operators = self.connection.get_supported_filter_operators()
+        self.filter_builder.set_operators(operators)
         
-        try:
-            # Update filter builder with supported operators
-            operators = self.connection.get_supported_filter_operators()
-            self.filter_builder.set_operators(operators)
-            
-            self._load_data_internal()
-            
-            # Ensure UI is fully updated before hiding loading dialog
-            QApplication.processEvents()
-        finally:
-            self.loading_dialog.hide_loading()
+        self._load_data_internal()
         
     def _load_data(self):
         """Load data from current collection (with loading dialog)."""
@@ -182,35 +204,53 @@ class MetadataView(QWidget):
             self.table.setRowCount(0)
             return
         
+        # Cancel any existing load thread
+        if self.load_thread and self.load_thread.isRunning():
+            self.load_thread.quit()
+            self.load_thread.wait()
+        
         offset = self.current_page * self.page_size
         
         # Get filters split into server-side and client-side
         server_filter = None
-        client_filters = []
+        self.client_filters = []
         if self.filter_group.isChecked() and self.filter_builder.has_filters():
-            server_filter, client_filters = self.filter_builder.get_filters_split()
+            server_filter, self.client_filters = self.filter_builder.get_filters_split()
         
-        data = self.connection.get_all_items(
+        # Start background thread to load data
+        self.load_thread = DataLoadThread(
+            self.connection,
             self.current_collection,
-            limit=self.page_size,
-            offset=offset,
-            where=server_filter
+            self.page_size,
+            offset,
+            server_filter
         )
-        
+        self.load_thread.finished.connect(self._on_data_loaded)
+        self.load_thread.error.connect(self._on_load_error)
+        self.load_thread.start()
+    
+    def _on_data_loaded(self, data: Dict[str, Any]):
+        """Handle data loaded from background thread."""
         # Apply client-side filters if any
-        if client_filters and data:
-            data = apply_client_side_filters(data, client_filters)
+        if self.client_filters and data:
+            data = apply_client_side_filters(data, self.client_filters)
         
         if not data:
-            self.status_label.setText("Failed to load data")
+            self.status_label.setText("No data after filtering")
             self.table.setRowCount(0)
             return
+            
         self.current_data = data
         self._populate_table(data)
         self._update_pagination_controls()
         
         # Update filter builder with available metadata fields
         self._update_filter_fields(data)
+    
+    def _on_load_error(self, error_msg: str):
+        """Handle error from background thread."""
+        self.status_label.setText(f"Failed to load data: {error_msg}")
+        self.table.setRowCount(0)
         
     def _update_filter_fields(self, data: Dict[str, Any]):
         """Update filter builder with available metadata field names."""

{vector_inspector-0.2.4.3 → vector_inspector-0.2.6}/src/vector_inspector/ui/views/visualization_view.py

@@ -1,5 +1,6 @@
 """Vector visualization view with dimensionality reduction."""
 
+from __future__ import annotations
 from typing import Optional, Dict, Any
 import traceback
 from PySide6.QtWidgets import (
@@ -8,7 +9,6 @@ from PySide6.QtWidgets import (
 )
 from PySide6.QtCore import Qt, QThread, Signal
 from PySide6.QtWebEngineWidgets import QWebEngineView
-import plotly.graph_objects as go
 import numpy as np
 
 from vector_inspector.core.connections.base_connection import VectorDBConnection
@@ -154,7 +154,7 @@ class VisualizationView(QWidget):
         self.visualization_thread.error.connect(self._on_reduction_error)
         self.visualization_thread.start()
         
-    def _on_reduction_finished(self, reduced_data: np.ndarray):
+    def _on_reduction_finished(self, reduced_data: Any):
         """Handle dimensionality reduction completion."""
         self.reduced_data = reduced_data
         self._create_plot()
@@ -172,6 +172,10 @@ class VisualizationView(QWidget):
         """Create plotly visualization."""
         if self.reduced_data is None or self.current_data is None:
             return
+        
+        # Lazy import plotly
+        from vector_inspector.utils.lazy_imports import get_plotly
+        go = get_plotly()
             
         ids = self.current_data.get("ids", [])
         documents = self.current_data.get("documents", [])

vector_inspector-0.2.6/src/vector_inspector/utils/__init__.py

@@ -0,0 +1 @@
+"""Utilities for Vector Inspector."""

vector_inspector-0.2.6/src/vector_inspector/utils/lazy_imports.py

@@ -0,0 +1,49 @@
+"""Lazy import utilities for performance optimization."""
+
+from typing import Any
+
+_plotly_cache = None
+_sklearn_cache = {}
+_numpy_cache = None
+
+
+def get_plotly():
+    """Lazy import plotly graph_objects."""
+    global _plotly_cache
+    if _plotly_cache is None:
+        import plotly.graph_objects as go
+        _plotly_cache = go
+    return _plotly_cache
+
+
+def get_numpy():
+    """Lazy import numpy."""
+    global _numpy_cache
+    if _numpy_cache is None:
+        import numpy as np
+        _numpy_cache = np
+    return _numpy_cache
+
+
+def get_sklearn_model(model_name: str) -> Any:
+    """
+    Lazy import sklearn models.
+    
+    Args:
+        model_name: Name of the model ('PCA', 'TSNE', 'UMAP')
+        
+    Returns:
+        The model class
+    """
+    global _sklearn_cache
+    if model_name not in _sklearn_cache:
+        if model_name == 'PCA':
+            from sklearn.decomposition import PCA
+            _sklearn_cache['PCA'] = PCA
+        elif model_name == 'TSNE':
+            from sklearn.manifold import TSNE
+            _sklearn_cache['TSNE'] = TSNE
+        elif model_name == 'UMAP':
+            import umap
+            _sklearn_cache['UMAP'] = umap.UMAP
+    return _sklearn_cache[model_name]