vector-inspector 0.2.4__tar.gz → 0.2.5__tar.gz

{vector_inspector-0.2.4 → vector_inspector-0.2.5}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: vector-inspector
-Version: 0.2.4
+Version: 0.2.5
 Summary: A comprehensive desktop application for visualizing, querying, and managing vector database data
 Author-Email: Anthony Dawson <anthonypdawson+github@gmail.com>
 License: MIT
 Project-URL: Homepage, https://vector-inspector.divinedevops.com
-Project-URL: Source, https://github.com/anthony-dawson/vector-inspector
-Project-URL: Issues, https://github.com/anthony-dawson/vector-inspector/issues
-Project-URL: Documentation, https://github.com/anthony-dawson/vector-inspector#readme
+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-Dist: chromadb>=0.4.22
 Requires-Dist: qdrant-client>=1.7.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. 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 → vector_inspector-0.2.5}/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. 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 → vector_inspector-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vector-inspector"
-version = "0.2.4"
+version = "0.2.5"
 description = "A comprehensive desktop application for visualizing, querying, and managing vector database data"
 authors = [
     { name = "Anthony Dawson", email = "anthonypdawson+github@gmail.com" },
@@ -28,9 +28,9 @@ text = "MIT"
 
 [project.urls]
 Homepage = "https://vector-inspector.divinedevops.com"
-Source = "https://github.com/anthony-dawson/vector-inspector"
-Issues = "https://github.com/anthony-dawson/vector-inspector/issues"
-Documentation = "https://github.com/anthony-dawson/vector-inspector#readme"
+Source = "https://github.com/anthonypdawson/vector-inspector"
+Issues = "https://github.com/anthonypdawson/vector-inspector/issues"
+Documentation = "https://github.com/anthonypdawson/vector-inspector#readme"
 
 [project.scripts]
 vector-inspector = "vector_inspector.main:main"

{vector_inspector-0.2.4 → vector_inspector-0.2.5}/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 → vector_inspector-0.2.5}/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 → vector_inspector-0.2.5}/src/vector_inspector/services/visualization_service.py

@@ -1,10 +1,6 @@
 """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
 
 
 class VisualizationService:
@@ -16,7 +12,7 @@ class VisualizationService:
         method: str = "pca",
         n_components: int = 2,
         **kwargs
-    ) -> Optional[np.ndarray]:
+    ) -> Optional[Any]:
         """
         Reduce dimensionality of embeddings.
         
@@ -33,13 +29,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() == "t-sne":
+                TSNE = get_sklearn_model('TSNE')
                 perplexity = kwargs.get("perplexity", min(30, len(embeddings) - 1))
                 reducer = TSNE(
                     n_components=n_components,
@@ -48,9 +50,10 @@ 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(
+                reducer = UMAP(
                     n_components=n_components,
                     n_neighbors=n_neighbors,
                     random_state=42
@@ -69,11 +72,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 → vector_inspector-0.2.5}/src/vector_inspector/ui/main_window.py

@@ -12,9 +12,9 @@ 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
 
 
@@ -63,13 +63,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 +175,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 +215,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,9 +227,14 @@ 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."""
@@ -204,14 +242,19 @@ class MainWindow(QMainWindow):
         self.statusBar.showMessage(f"Collection: {collection_name}")
         
         # 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)
         
     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.5/src/vector_inspector/ui/views/info_panel.py

@@ -0,0 +1,311 @@
+"""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)
+        
+        # Collections List Section
+        self.collections_group = QGroupBox("Available Collections")
+        collections_layout = QVBoxLayout()
+        
+        self.collections_list_label = QLabel("No collections")
+        self.collections_list_label.setWordWrap(True)
+        self.collections_list_label.setStyleSheet("color: gray; padding: 10px;")
+        collections_layout.addWidget(self.collections_list_label)
+        
+        self.collections_group.setLayout(collections_layout)
+        container_layout.addWidget(self.collections_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")
+            self.collections_list_label.setText("No collections")
+            self.collections_list_label.setStyleSheet("color: gray; padding: 10px;")
+            # 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")
+        
+        # List collections
+        try:
+            collections = self.connection.list_collections()
+            self._update_label(self.collections_count_label, str(len(collections)))
+            
+            if collections:
+                collections_text = "\n".join([f"• {name}" for name in sorted(collections)])
+                self.collections_list_label.setText(collections_text)
+                self.collections_list_label.setStyleSheet("color: white; padding: 10px; font-family: monospace;")
+            else:
+                self.collections_list_label.setText("No collections found")
+                self.collections_list_label.setStyleSheet("color: gray; padding: 10px;")
+        except Exception as e:
+            self._update_label(self.collections_count_label, "Error")
+            self.collections_list_label.setText(f"Error loading collections: {str(e)}")
+            self.collections_list_label.setStyleSheet("color: red; padding: 10px;")
+    
+    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 → vector_inspector-0.2.5}/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.5/src/vector_inspector/utils/__init__.py

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

vector_inspector-0.2.5/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]