vector-inspector 0.3.7__py3-none-any.whl → 0.3.8__py3-none-any.whl

vector_inspector/core/provider_factory.py

@@ -0,0 +1,97 @@
+"""Factory for creating vector database connections from provider configs."""
+
+from typing import Dict, Any
+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
+from vector_inspector.core.connections.pinecone_connection import PineconeConnection
+from vector_inspector.core.connections.pgvector_connection import PgVectorConnection
+
+
+class ProviderFactory:
+    """Factory for creating database connections from configuration."""
+
+    @staticmethod
+    def create(
+        provider: str, config: Dict[str, Any], credentials: Dict[str, Any] = None
+    ) -> VectorDBConnection:
+        """Create a connection object for the specified provider.
+
+        Args:
+            provider: Provider type (chromadb, qdrant, pinecone, pgvector)
+            config: Provider-specific configuration
+            credentials: Optional credentials (API keys, passwords, etc.)
+
+        Returns:
+            VectorDBConnection instance
+
+        Raises:
+            ValueError: If provider is unsupported or configuration is invalid
+        """
+        credentials = credentials or {}
+
+        if provider == "chromadb":
+            return ProviderFactory._create_chroma(config, credentials)
+        elif provider == "qdrant":
+            return ProviderFactory._create_qdrant(config, credentials)
+        elif provider == "pinecone":
+            return ProviderFactory._create_pinecone(config, credentials)
+        elif provider == "pgvector":
+            return ProviderFactory._create_pgvector(config, credentials)
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+    @staticmethod
+    def _create_chroma(config: Dict[str, Any], credentials: Dict[str, Any]) -> ChromaDBConnection:
+        """Create a ChromaDB connection."""
+        conn_type = config.get("type")
+
+        if conn_type == "persistent":
+            return ChromaDBConnection(path=config.get("path"))
+        elif conn_type == "http":
+            return ChromaDBConnection(host=config.get("host"), port=config.get("port"))
+        else:  # ephemeral
+            return ChromaDBConnection()
+
+    @staticmethod
+    def _create_qdrant(config: Dict[str, Any], credentials: Dict[str, Any]) -> QdrantConnection:
+        """Create a Qdrant connection."""
+        conn_type = config.get("type")
+        api_key = credentials.get("api_key")
+
+        if conn_type == "persistent":
+            return QdrantConnection(path=config.get("path"))
+        elif conn_type == "http":
+            return QdrantConnection(
+                host=config.get("host"), port=config.get("port"), api_key=api_key
+            )
+        else:  # ephemeral
+            return QdrantConnection()
+
+    @staticmethod
+    def _create_pinecone(config: Dict[str, Any], credentials: Dict[str, Any]) -> PineconeConnection:
+        """Create a Pinecone connection."""
+        api_key = credentials.get("api_key")
+        if not api_key:
+            raise ValueError("Pinecone requires an API key")
+
+        return PineconeConnection(api_key=api_key)
+
+    @staticmethod
+    def _create_pgvector(config: Dict[str, Any], credentials: Dict[str, Any]) -> PgVectorConnection:
+        """Create a PgVector/Postgres connection."""
+        conn_type = config.get("type")
+
+        if conn_type == "http":
+            host = config.get("host", "localhost")
+            port = int(config.get("port", 5432))
+            database = config.get("database")
+            user = config.get("user")
+            # Prefer password from credentials
+            password = credentials.get("password")
+
+            return PgVectorConnection(
+                host=host, port=port, database=database, user=user, password=password
+            )
+
+        raise ValueError("Unsupported connection type for PgVector profile")

vector_inspector/ui/components/splash_window.py

@@ -34,10 +34,22 @@ class SplashWindow(QDialog):
         layout.addWidget(github)
 
         # About info (reuse About dialog text)
-        from vector_inspector.ui.main_window import get_about_html
+        from vector_inspector.utils.version import get_app_version
 
         about = QTextBrowser()
-        about.setHtml(get_about_html())
+        version = get_app_version()
+        version_html = (
+            f"<h2>Vector Inspector {version}</h2>" if version else "<h2>Vector Inspector</h2>"
+        )
+        about_text = (
+            version_html + "<p>A comprehensive desktop application for visualizing, "
+            "querying, and managing multiple vector databases simultaneously.</p>"
+            '<p><a href="https://github.com/anthonypdawson/vector-inspector" style="color:#2980b9;">GitHub Project Page</a></p>'
+            "<hr />"
+            "<p>Built with PySide6</p>"
+            "<p><b>New:</b> Pinecone support!</p>"
+        )
+        about.setHtml(about_text)
         about.setOpenExternalLinks(True)
         about.setMaximumHeight(160)
         layout.addWidget(about)

vector_inspector/ui/controllers/__init__.py

@@ -0,0 +1 @@
+"""UI controllers for managing application logic."""

vector_inspector/ui/controllers/connection_controller.py

@@ -0,0 +1,177 @@
+"""Controller for managing connection lifecycle and threading."""
+
+from typing import Dict, Optional
+from PySide6.QtCore import QObject, Signal, QThread
+from PySide6.QtWidgets import QMessageBox, QWidget
+
+from vector_inspector.core.connection_manager import ConnectionManager, ConnectionState
+from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.provider_factory import ProviderFactory
+from vector_inspector.services.profile_service import ProfileService
+from vector_inspector.ui.components.loading_dialog import LoadingDialog
+
+
+class ConnectionThread(QThread):
+    """Background thread for connecting to database."""
+
+    finished = Signal(bool, list, str)  # success, collections, error_message
+
+    def __init__(self, connection: VectorDBConnection):
+        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, [], "Connection failed")
+        except Exception as e:
+            self.finished.emit(False, [], str(e))
+
+
+class ConnectionController(QObject):
+    """Controller for managing connection operations and lifecycle.
+
+    This handles:
+    - Creating connections from profiles
+    - Starting connection threads
+    - Handling connection results
+    - Managing loading dialogs
+    - Emitting signals for UI updates
+    """
+
+    connection_completed = Signal(
+        str, bool, list, str
+    )  # connection_id, success, collections, error
+
+    def __init__(
+        self,
+        connection_manager: ConnectionManager,
+        profile_service: ProfileService,
+        parent: Optional[QWidget] = None,
+    ):
+        super().__init__(parent)
+        self.connection_manager = connection_manager
+        self.profile_service = profile_service
+        self.parent_widget = parent
+
+        # State
+        self._connection_threads: Dict[str, ConnectionThread] = {}
+        self.loading_dialog = LoadingDialog("Loading...", parent)
+
+    def connect_to_profile(self, profile_id: str) -> bool:
+        """Connect to a profile.
+
+        Args:
+            profile_id: ID of the profile to connect to
+
+        Returns:
+            True if connection initiated successfully, False otherwise
+        """
+        profile_data = self.profile_service.get_profile_with_credentials(profile_id)
+        if not profile_data:
+            QMessageBox.warning(self.parent_widget, "Error", "Profile not found.")
+            return False
+
+        # Check connection limit
+        if self.connection_manager.get_connection_count() >= ConnectionManager.MAX_CONNECTIONS:
+            QMessageBox.warning(
+                self.parent_widget,
+                "Connection Limit",
+                f"Maximum number of connections ({ConnectionManager.MAX_CONNECTIONS}) reached. "
+                "Please close a connection first.",
+            )
+            return False
+
+        # Create connection
+        provider = profile_data["provider"]
+        config = profile_data["config"]
+        credentials = profile_data.get("credentials", {})
+
+        try:
+            # Create connection object using factory
+            connection = ProviderFactory.create(provider, config, credentials)
+
+            # Register with connection manager, using profile_id as connection_id for persistence
+            connection_id = self.connection_manager.create_connection(
+                name=profile_data["name"],
+                provider=provider,
+                connection=connection,
+                config=config,
+                connection_id=profile_data["id"],
+            )
+
+            # Update state to connecting
+            self.connection_manager.update_connection_state(
+                connection_id, ConnectionState.CONNECTING
+            )
+
+            # Connect in background thread
+            thread = ConnectionThread(connection)
+            thread.finished.connect(
+                lambda success, collections, error: self._on_connection_finished(
+                    connection_id, success, collections, error
+                )
+            )
+            self._connection_threads[connection_id] = thread
+            thread.start()
+
+            # Show loading dialog
+            self.loading_dialog.show_loading(f"Connecting to {profile_data['name']}...")
+            return True
+
+        except Exception as e:
+            QMessageBox.critical(
+                self.parent_widget, "Connection Error", f"Failed to create connection: {e}"
+            )
+            return False
+
+    def _on_connection_finished(
+        self, connection_id: str, success: bool, collections: list, error: str
+    ):
+        """Handle connection thread completion."""
+        self.loading_dialog.hide_loading()
+
+        # Clean up thread
+        thread = self._connection_threads.pop(connection_id, None)
+        if thread:
+            thread.wait()  # Wait for thread to fully finish
+            thread.deleteLater()
+
+        if success:
+            # Update state to connected
+            self.connection_manager.update_connection_state(
+                connection_id, ConnectionState.CONNECTED
+            )
+
+            # Mark connection as opened first (will show in UI)
+            self.connection_manager.mark_connection_opened(connection_id)
+
+            # Then update collections (UI item now exists to receive them)
+            self.connection_manager.update_collections(connection_id, collections)
+        else:
+            # Update state to error
+            self.connection_manager.update_connection_state(
+                connection_id, ConnectionState.ERROR, error
+            )
+
+            QMessageBox.warning(
+                self.parent_widget, "Connection Failed", f"Failed to connect: {error}"
+            )
+
+            # Remove the failed connection
+            self.connection_manager.close_connection(connection_id)
+
+        # Emit signal for UI updates
+        self.connection_completed.emit(connection_id, success, collections, error)
+
+    def cleanup(self):
+        """Clean up connection threads on shutdown."""
+        for thread in list(self._connection_threads.values()):
+            if thread.isRunning():
+                thread.quit()
+                thread.wait(1000)  # Wait up to 1 second

vector_inspector/ui/main_window.py

@@ -1,63 +1,29 @@
 """Updated main window with multi-database support."""
 
 from PySide6.QtWidgets import (
-    QMainWindow,
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QSplitter,
-    QTabWidget,
-    QStatusBar,
-    QToolBar,
     QMessageBox,
-    QInputDialog,
     QLabel,
-    QDockWidget,
     QApplication,
     QDialog,
+    QToolBar,
+    QStatusBar,
 )
-from PySide6.QtCore import Qt, Signal, QTimer, QThread
+from PySide6.QtCore import Qt, QTimer
 from PySide6.QtGui import QAction
 
-from vector_inspector.core.connection_manager import ConnectionManager, ConnectionState
+from vector_inspector.core.connection_manager import ConnectionManager
 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
-from vector_inspector.core.connections.pinecone_connection import PineconeConnection
-from vector_inspector.core.connections.pgvector_connection import PgVectorConnection
 from vector_inspector.services.profile_service import ProfileService
 from vector_inspector.services.settings_service import SettingsService
+from vector_inspector.ui.main_window_shell import InspectorShell
 from vector_inspector.ui.components.connection_manager_panel import ConnectionManagerPanel
 from vector_inspector.ui.components.profile_manager_panel import ProfileManagerPanel
-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.components.loading_dialog import LoadingDialog
-
-
-class ConnectionThread(QThread):
-    """Background thread for connecting to database."""
-
-    finished = Signal(bool, list, str)  # success, collections, error_message
-
-    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, [], "Connection failed")
-        except Exception as e:
-            self.finished.emit(False, [], str(e))
+from vector_inspector.ui.tabs import InspectorTabs
+from vector_inspector.ui.controllers.connection_controller import ConnectionController
+from vector_inspector.ui.services.dialog_service import DialogService
 
 
-class MainWindow(QMainWindow):
+class MainWindow(InspectorShell):
     """Main application window with multi-database support."""
 
     def __init__(self):
@@ -67,11 +33,21 @@ class MainWindow(QMainWindow):
         self.connection_manager = ConnectionManager()
         self.profile_service = ProfileService()
         self.settings_service = SettingsService()
-        self.loading_dialog = LoadingDialog("Loading...", self)
+
+        # Controller for connection operations
+        self.connection_controller = ConnectionController(
+            self.connection_manager, self.profile_service, self
+        )
 
         # State
         self.visualization_view = None
-        self._connection_threads = {}  # Track connection threads
+
+        # View references (will be set in _setup_ui)
+        self.info_panel = None
+        self.metadata_view = None
+        self.search_view = None
+        self.connection_panel = None
+        self.profile_panel = None
 
         self.setWindowTitle("Vector Inspector")
         self.setGeometry(100, 100, 1600, 900)
@@ -101,62 +77,36 @@ class MainWindow(QMainWindow):
                 print(f"[SplashWindow] Failed to show splash: {e}")
 
     def _setup_ui(self):
-        """Setup the main UI layout."""
-        # Central widget with splitter
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-
-        layout = QHBoxLayout(central_widget)
-        layout.setContentsMargins(5, 5, 5, 5)
-
-        # Main splitter (left panel | right tabs)
-        main_splitter = QSplitter(Qt.Horizontal)
-
-        # Left panel - Connections and Profiles
-        left_panel = QWidget()
-        left_layout = QVBoxLayout(left_panel)
-        left_layout.setContentsMargins(0, 0, 0, 0)
-
-        # Create tab widget for connections and profiles
-        self.left_tabs = QTabWidget()
-
-        # Connection manager panel
+        """Setup the main UI layout using InspectorShell."""
+        # Left panels - Connections and Profiles
         self.connection_panel = ConnectionManagerPanel(self.connection_manager)
-        self.left_tabs.addTab(self.connection_panel, "Active")
+        self.add_left_panel(self.connection_panel, "Active")
 
-        # Profile manager panel
         self.profile_panel = ProfileManagerPanel(self.profile_service)
-        self.left_tabs.addTab(self.profile_panel, "Profiles")
-
-        left_layout.addWidget(self.left_tabs)
+        self.add_left_panel(self.profile_panel, "Profiles")
 
-        # Right panel - Tabbed views
-        self.tab_widget = QTabWidget()
+        # Main content tabs using TabRegistry
+        tab_defs = InspectorTabs.get_standard_tabs()
 
-        # Create views (they'll be updated when collection changes)
-        self.info_panel = InfoPanel(None)  # Will be set later
-        self.metadata_view = MetadataView(None)  # Will be set later
-        self.search_view = SearchView(None)  # Will be set later
+        for i, tab_def in enumerate(tab_defs):
+            widget = InspectorTabs.create_tab_widget(tab_def, connection=None)
+            self.add_main_tab(widget, tab_def.title)
 
-        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(QWidget(), "Visualization")  # Placeholder
+            # Store references to views (except placeholder)
+            if i == InspectorTabs.INFO_TAB:
+                self.info_panel = widget
+            elif i == InspectorTabs.DATA_TAB:
+                self.metadata_view = widget
+            elif i == InspectorTabs.SEARCH_TAB:
+                self.search_view = widget
+            # Visualization is lazy-loaded, so it's a placeholder for now
 
         # Set Info tab as default
-        self.tab_widget.setCurrentIndex(0)
+        self.set_main_tab_active(InspectorTabs.INFO_TAB)
 
         # 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)
-        main_splitter.addWidget(self.tab_widget)
-        main_splitter.setStretchFactor(0, 1)
-        main_splitter.setStretchFactor(1, 4)
-
-        layout.addWidget(main_splitter)
-
     def _setup_menu_bar(self):
         """Setup application menu bar."""
         menubar = self.menuBar()
@@ -303,17 +253,7 @@ class MainWindow(QMainWindow):
         # Show update details dialog
         if not hasattr(self, "_latest_release"):
             return
-        from vector_inspector.ui.components.update_details_dialog import UpdateDetailsDialog
-        from vector_inspector.services.update_service import UpdateService
-
-        latest = self._latest_release
-        version = latest.get("tag_name", "?")
-        notes = latest.get("body", "")
-        instructions = UpdateService.get_update_instructions()
-        pip_cmd = instructions["pip"]
-        github_url = instructions["github"]
-        dlg = UpdateDetailsDialog(version, notes, pip_cmd, github_url, self)
-        dlg.exec()
+        DialogService.show_update_details(self._latest_release, self)
 
     def _connect_signals(self):
         """Connect signals between components."""
@@ -327,6 +267,9 @@ class MainWindow(QMainWindow):
         self.connection_manager.collections_updated.connect(self._on_collections_updated)
         self.connection_manager.connection_opened.connect(self._on_connection_opened)
 
+        # Connection controller signals
+        self.connection_controller.connection_completed.connect(self._on_connection_completed)
+
         # Connection panel signals
         self.connection_panel.collection_selected.connect(self._on_collection_selected_from_panel)
         self.connection_panel.add_connection_btn.clicked.connect(self._new_connection_from_profile)
@@ -334,9 +277,20 @@ class MainWindow(QMainWindow):
         # Profile panel signals
         self.profile_panel.connect_profile.connect(self._connect_to_profile)
 
+    def _on_connection_completed(
+        self, connection_id: str, success: bool, collections: list, error: str
+    ):
+        """Handle connection completed event from controller."""
+        if success:
+            # Switch to Active connections tab
+            self.set_left_panel_active(0)
+            self.statusBar().showMessage(
+                f"Connected successfully ({len(collections)} collections)", 5000
+            )
+
     def _on_tab_changed(self, index: int):
         """Handle tab change - lazy load visualization tab."""
-        if index == 3 and self.visualization_view is None:
+        if index == InspectorTabs.VISUALIZATION_TAB and self.visualization_view is None:
             # Lazy load visualization view
             from vector_inspector.ui.views.visualization_view import VisualizationView
 
@@ -346,9 +300,11 @@ class MainWindow(QMainWindow):
 
             self.visualization_view = VisualizationView(conn)
             # Replace placeholder with actual view
-            self.tab_widget.removeTab(3)
-            self.tab_widget.insertTab(3, self.visualization_view, "Visualization")
-            self.tab_widget.setCurrentIndex(3)
+            self.remove_main_tab(InspectorTabs.VISUALIZATION_TAB)
+            self.add_main_tab(
+                self.visualization_view, "Visualization", InspectorTabs.VISUALIZATION_TAB
+            )
+            self.set_main_tab_active(InspectorTabs.VISUALIZATION_TAB)
 
             # Set collection if one is already selected
             if active and active.active_collection:
@@ -386,20 +342,22 @@ class MainWindow(QMainWindow):
             if connection_id == self.connection_manager.get_active_connection_id():
                 # Show loading immediately when collection changes
                 if collection_name:
-                    self.loading_dialog.show_loading(f"Loading collection '{collection_name}'...")
+                    self.connection_controller.loading_dialog.show_loading(
+                        f"Loading collection '{collection_name}'..."
+                    )
                     QApplication.processEvents()
                     try:
                         self._update_views_for_collection(collection_name)
                     finally:
-                        self.loading_dialog.hide_loading()
+                        self.connection_controller.loading_dialog.hide_loading()
                 else:
                     # Clear collection from views
-                    self.loading_dialog.show_loading("Clearing collection...")
+                    self.connection_controller.loading_dialog.show_loading("Clearing collection...")
                     QApplication.processEvents()
                     try:
                         self._update_views_for_collection(None)
                     finally:
-                        self.loading_dialog.hide_loading()
+                        self.connection_controller.loading_dialog.hide_loading()
 
     def _on_collections_updated(self, connection_id: str, collections: list):
         """Handle collections list updated."""
@@ -417,7 +375,9 @@ class MainWindow(QMainWindow):
     def _on_collection_selected_from_panel(self, connection_id: str, collection_name: str):
         """Handle collection selection from connection panel."""
         # Show loading dialog while switching collections
-        self.loading_dialog.show_loading(f"Loading collection '{collection_name}'...")
+        self.connection_controller.loading_dialog.show_loading(
+            f"Loading collection '{collection_name}'..."
+        )
         QApplication.processEvents()
 
         try:
@@ -425,7 +385,7 @@ class MainWindow(QMainWindow):
             # Just update the views
             self._update_views_for_collection(collection_name)
         finally:
-            self.loading_dialog.hide_loading()
+            self.connection_controller.loading_dialog.hide_loading()
 
     def _update_views_with_connection(self, connection: VectorDBConnection):
         """Update all views with a new connection."""
@@ -464,176 +424,20 @@ class MainWindow(QMainWindow):
 
     def _new_connection_from_profile(self):
         """Show dialog to create new connection (switches to Profiles tab)."""
-        self.left_tabs.setCurrentIndex(1)  # Switch to Profiles tab
-        QMessageBox.information(
-            self,
-            "Connect to Profile",
-            "Select a profile from the list and click 'Connect', or click '+' to create a new profile.",
-        )
+        self.set_left_panel_active(1)  # Switch to Profiles tab
+        DialogService.show_profile_editor_prompt(self)
 
     def _show_profile_editor(self):
         """Show profile editor to create new profile."""
-        self.left_tabs.setCurrentIndex(1)  # Switch to Profiles tab
+        self.set_left_panel_active(1)  # Switch to Profiles tab
         self.profile_panel._create_profile()
 
     def _connect_to_profile(self, profile_id: str):
-        """Connect to a profile."""
-        profile_data = self.profile_service.get_profile_with_credentials(profile_id)
-        if not profile_data:
-            QMessageBox.warning(self, "Error", "Profile not found.")
-            return
-
-        # Check connection limit
-        if self.connection_manager.get_connection_count() >= ConnectionManager.MAX_CONNECTIONS:
-            QMessageBox.warning(
-                self,
-                "Connection Limit",
-                f"Maximum number of connections ({ConnectionManager.MAX_CONNECTIONS}) reached. "
-                "Please close a connection first.",
-            )
-            return
-
-        # Create connection
-        provider = profile_data["provider"]
-        config = profile_data["config"]
-        credentials = profile_data.get("credentials", {})
-
-        try:
-            # Create connection object
-            if provider == "chromadb":
-                connection = self._create_chroma_connection(config, credentials)
-            elif provider == "qdrant":
-                connection = self._create_qdrant_connection(config, credentials)
-            elif provider == "pinecone":
-                connection = self._create_pinecone_connection(config, credentials)
-            elif provider == "pgvector":
-                connection = self._create_pgvector_connection(config, credentials)
-            else:
-                QMessageBox.warning(self, "Error", f"Unsupported provider: {provider}")
-                return
-
-            # Register with connection manager, using profile_id as connection_id for persistence
-            connection_id = self.connection_manager.create_connection(
-                name=profile_data["name"],
-                provider=provider,
-                connection=connection,
-                config=config,
-                connection_id=profile_data["id"],
-            )
-
-            # Update state to connecting
-            self.connection_manager.update_connection_state(
-                connection_id, ConnectionState.CONNECTING
-            )
-
-            # Connect in background thread
-            thread = ConnectionThread(connection)
-            thread.finished.connect(
-                lambda success, collections, error: self._on_connection_finished(
-                    connection_id, success, collections, error
-                )
-            )
-            self._connection_threads[connection_id] = thread
-            thread.start()
-
-            # Show loading dialog
-            self.loading_dialog.show_loading(f"Connecting to {profile_data['name']}...")
-
-        except Exception as e:
-            QMessageBox.critical(self, "Connection Error", f"Failed to create connection: {e}")
-
-    def _create_chroma_connection(self, config: dict, credentials: dict) -> ChromaDBConnection:
-        """Create a ChromaDB connection."""
-        conn_type = config.get("type")
-
-        if conn_type == "persistent":
-            return ChromaDBConnection(path=config.get("path"))
-        elif conn_type == "http":
-            return ChromaDBConnection(host=config.get("host"), port=config.get("port"))
-        else:  # ephemeral
-            return ChromaDBConnection()
-
-    def _create_qdrant_connection(self, config: dict, credentials: dict) -> QdrantConnection:
-        """Create a Qdrant connection."""
-        conn_type = config.get("type")
-        api_key = credentials.get("api_key")
-
-        if conn_type == "persistent":
-            return QdrantConnection(path=config.get("path"))
-        elif conn_type == "http":
-            return QdrantConnection(
-                host=config.get("host"), port=config.get("port"), api_key=api_key
-            )
-        else:  # ephemeral
-            return QdrantConnection()
-
-    def _create_pinecone_connection(self, config: dict, credentials: dict) -> PineconeConnection:
-        """Create a Pinecone connection."""
-        api_key = credentials.get("api_key")
-        if not api_key:
-            raise ValueError("Pinecone requires an API key")
-
-        return PineconeConnection(api_key=api_key)
-
-    def _create_pgvector_connection(self, config: dict, credentials: dict) -> PgVectorConnection:
-        """Create a PgVector/Postgres connection from profile config/credentials."""
-        conn_type = config.get("type")
-
-        # We expect HTTP-style profile for pgvector (host/port + db creds)
-        if conn_type == "http":
-            host = config.get("host", "localhost")
-            port = int(config.get("port", 5432))
-            database = config.get("database")
-            user = config.get("user")
-            # Prefer password from credentials
-            password = credentials.get("password")
-
-            return PgVectorConnection(
-                host=host, port=port, database=database, user=user, password=password
-            )
-
-        raise ValueError("Unsupported connection type for PgVector profile")
-
-    def _on_connection_finished(
-        self, connection_id: str, success: bool, collections: list, error: str
-    ):
-        """Handle connection thread completion."""
-        self.loading_dialog.hide_loading()
-
-        # Clean up thread
-        thread = self._connection_threads.pop(connection_id, None)
-        if thread:
-            thread.wait()  # Wait for thread to fully finish
-            thread.deleteLater()
-
+        """Connect to a profile using the connection controller."""
+        success = self.connection_controller.connect_to_profile(profile_id)
         if success:
-            # Update state to connected
-            self.connection_manager.update_connection_state(
-                connection_id, ConnectionState.CONNECTED
-            )
-
-            # Mark connection as opened first (will show in UI)
-            self.connection_manager.mark_connection_opened(connection_id)
-
-            # Then update collections (UI item now exists to receive them)
-            self.connection_manager.update_collections(connection_id, collections)
-
-            # Switch to Active connections tab
-            self.left_tabs.setCurrentIndex(0)
-
-            self.statusBar().showMessage(
-                f"Connected successfully ({len(collections)} collections)", 5000
-            )
-        else:
-            # Update state to error
-            self.connection_manager.update_connection_state(
-                connection_id, ConnectionState.ERROR, error
-            )
-
-            QMessageBox.warning(self, "Connection Failed", f"Failed to connect: {error}")
-
-            # Remove the failed connection
-            self.connection_manager.close_connection(connection_id)
+            # Switch to Active connections tab after initiating connection
+            self.set_left_panel_active(0)
 
     def _refresh_active_connection(self):
         """Refresh collections for the active connection."""
@@ -665,13 +469,7 @@ class MainWindow(QMainWindow):
 
     def _show_about(self):
         """Show about dialog."""
-        from .main_window import get_about_html
-
-        QMessageBox.about(
-            self,
-            "About Vector Inspector",
-            get_about_html(),
-        )
+        DialogService.show_about(self)
 
     def _toggle_cache(self, checked: bool):
         """Toggle caching on/off."""
@@ -681,53 +479,25 @@ class MainWindow(QMainWindow):
 
     def _show_migration_dialog(self):
         """Show cross-database migration dialog."""
-        if self.connection_manager.get_connection_count() < 2:
-            QMessageBox.information(
-                self,
-                "Insufficient Connections",
-                "You need at least 2 active connections to migrate data.\n"
-                "Please connect to additional databases first.",
-            )
-            return
-
-        from vector_inspector.ui.dialogs.cross_db_migration import CrossDatabaseMigrationDialog
-
-        dialog = CrossDatabaseMigrationDialog(self.connection_manager, self)
-        dialog.exec()
+        DialogService.show_migration_dialog(self.connection_manager, self)
 
     def _show_backup_restore_dialog(self):
         """Show backup/restore dialog for the active collection."""
-        # Check if there's an active connection
+        # Get active connection and collection
         connection = self.connection_manager.get_active_connection()
-        if not connection:
-            QMessageBox.information(self, "No Connection", "Please connect to a database first.")
-            return
-
-        # Get active collection
         collection_name = self.connection_manager.get_active_collection()
-        if not collection_name:
-            # Allow opening dialog without a collection selected (for restore-only)
-            QMessageBox.information(
-                self,
-                "No Collection Selected",
-                "You can restore backups without a collection selected.\n"
-                "To create a backup, please select a collection first.",
-            )
 
-        from vector_inspector.ui.components.backup_restore_dialog import BackupRestoreDialog
+        # Show dialog
+        result = DialogService.show_backup_restore_dialog(connection, collection_name or "", self)
 
-        dialog = BackupRestoreDialog(connection, collection_name or "", self)
-        if dialog.exec() == QDialog.Accepted:
+        if result == QDialog.Accepted:
             # Refresh collections after restore
             self._refresh_active_connection()
 
     def closeEvent(self, event):
         """Handle application close."""
-        # Wait for all connection threads to finish
-        for thread in list(self._connection_threads.values()):
-            if thread.isRunning():
-                thread.quit()
-                thread.wait(1000)  # Wait up to 1 second
+        # Clean up connection controller
+        self.connection_controller.cleanup()
 
         # Clean up temp HTML files from visualization view
         if self.visualization_view is not None:
@@ -739,20 +509,3 @@ class MainWindow(QMainWindow):
         self.connection_manager.close_all_connections()
 
         event.accept()
-
-
-def get_about_html():
-    from vector_inspector.utils.version import get_app_version
-
-    version = get_app_version()
-    version_html = (
-        f"<h2>Vector Inspector {version}</h2>" if version else "<h2>Vector Inspector</h2>"
-    )
-    return (
-        version_html + "<p>A comprehensive desktop application for visualizing, "
-        "querying, and managing multiple vector databases simultaneously.</p>"
-        '<p><a href="https://github.com/anthonypdawson/vector-inspector" style="color:#2980b9;">GitHub Project Page</a></p>'
-        "<hr />"
-        "<p>Built with PySide6</p>"
-        "<p><b>New:</b> Pinecone support!</p>"
-    )

vector_inspector/ui/main_window_shell.py

@@ -0,0 +1,106 @@
+"""Reusable UI shell for Vector Inspector applications."""
+
+from PySide6.QtWidgets import (
+    QMainWindow,
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QSplitter,
+    QTabWidget,
+)
+from PySide6.QtCore import Qt
+
+
+class InspectorShell(QMainWindow):
+    """Base shell for Inspector applications with splitter, tab widget, and left panel.
+
+    This provides the basic UI structure that can be reused by Vector Inspector
+    and Vector Fusion Studio. Subclasses customize behavior and add domain logic.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        # Main UI components that subclasses will interact with
+        self.left_tabs = None
+        self.tab_widget = None
+        self.main_splitter = None
+
+        self._setup_shell_ui()
+
+    def _setup_shell_ui(self):
+        """Setup the main UI shell layout."""
+        # Central widget with splitter
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        layout = QHBoxLayout(central_widget)
+        layout.setContentsMargins(5, 5, 5, 5)
+
+        # Main splitter (left panel | right tabs)
+        self.main_splitter = QSplitter(Qt.Horizontal)
+
+        # Left panel container (will hold tabs)
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        left_layout.setContentsMargins(0, 0, 0, 0)
+
+        # Create tab widget for left panel
+        self.left_tabs = QTabWidget()
+        left_layout.addWidget(self.left_tabs)
+
+        # Right panel - main content tabs
+        self.tab_widget = QTabWidget()
+
+        # Add panels to splitter
+        self.main_splitter.addWidget(left_panel)
+        self.main_splitter.addWidget(self.tab_widget)
+        self.main_splitter.setStretchFactor(0, 1)
+        self.main_splitter.setStretchFactor(1, 4)
+
+        layout.addWidget(self.main_splitter)
+
+    def add_left_panel(self, widget: QWidget, title: str, index: int = -1):
+        """Add a panel to the left tab widget.
+
+        Args:
+            widget: The panel widget to add
+            title: Display title for the tab
+            index: Optional position (default appends to end)
+        """
+        if index < 0:
+            self.left_tabs.addTab(widget, title)
+        else:
+            self.left_tabs.insertTab(index, widget, title)
+
+    def add_main_tab(self, widget: QWidget, title: str, index: int = -1):
+        """Add a tab to the main content area.
+
+        Args:
+            widget: The tab widget to add
+            title: Display title for the tab
+            index: Optional position (default appends to end)
+        """
+        if index < 0:
+            self.tab_widget.addTab(widget, title)
+        else:
+            self.tab_widget.insertTab(index, widget, title)
+
+    def set_left_panel_active(self, index: int):
+        """Switch to a specific left panel tab."""
+        if 0 <= index < self.left_tabs.count():
+            self.left_tabs.setCurrentIndex(index)
+
+    def set_main_tab_active(self, index: int):
+        """Switch to a specific main content tab."""
+        if 0 <= index < self.tab_widget.count():
+            self.tab_widget.setCurrentIndex(index)
+
+    def get_main_tab_count(self) -> int:
+        """Get the number of main content tabs."""
+        return self.tab_widget.count()
+
+    def remove_main_tab(self, index: int):
+        """Remove a main content tab."""
+        if 0 <= index < self.tab_widget.count():
+            self.tab_widget.removeTab(index)

vector_inspector/ui/services/__init__.py

@@ -0,0 +1 @@
+"""UI services for dialog management and utilities."""

vector_inspector/ui/services/dialog_service.py

@@ -0,0 +1,113 @@
+"""Service for managing application dialogs."""
+
+from PySide6.QtWidgets import QMessageBox, QDialog, QWidget
+from vector_inspector.core.connection_manager import ConnectionManager
+
+
+class DialogService:
+    """Service for launching application dialogs."""
+
+    @staticmethod
+    def show_about(parent: QWidget = None):
+        """Show about dialog."""
+        from vector_inspector.utils.version import get_app_version
+
+        version = get_app_version()
+        version_html = (
+            f"<h2>Vector Inspector {version}</h2>" if version else "<h2>Vector Inspector</h2>"
+        )
+        about_text = (
+            version_html + "<p>A comprehensive desktop application for visualizing, "
+            "querying, and managing multiple vector databases simultaneously.</p>"
+            '<p><a href="https://github.com/anthonypdawson/vector-inspector" style="color:#2980b9;">GitHub Project Page</a></p>'
+            "<hr />"
+            "<p>Built with PySide6</p>"
+            "<p><b>New:</b> Pinecone support!</p>"
+        )
+        QMessageBox.about(parent, "About Vector Inspector", about_text)
+
+    @staticmethod
+    def show_backup_restore_dialog(
+        connection, collection_name: str = "", parent: QWidget = None
+    ) -> int:
+        """Show backup/restore dialog.
+
+        Args:
+            connection: Active connection instance
+            collection_name: Optional collection name
+            parent: Parent widget
+
+        Returns:
+            QDialog.Accepted or QDialog.Rejected
+        """
+        if not connection:
+            QMessageBox.information(parent, "No Connection", "Please connect to a database first.")
+            return QDialog.Rejected
+
+        # Show info if no collection selected
+        if not collection_name:
+            QMessageBox.information(
+                parent,
+                "No Collection Selected",
+                "You can restore backups without a collection selected.\n"
+                "To create a backup, please select a collection first.",
+            )
+
+        from vector_inspector.ui.components.backup_restore_dialog import BackupRestoreDialog
+
+        dialog = BackupRestoreDialog(connection, collection_name or "", parent)
+        return dialog.exec()
+
+    @staticmethod
+    def show_migration_dialog(connection_manager: ConnectionManager, parent: QWidget = None) -> int:
+        """Show cross-database migration dialog.
+
+        Args:
+            connection_manager: Connection manager instance
+            parent: Parent widget
+
+        Returns:
+            QDialog.Accepted or QDialog.Rejected
+        """
+        if connection_manager.get_connection_count() < 2:
+            QMessageBox.information(
+                parent,
+                "Insufficient Connections",
+                "You need at least 2 active connections to migrate data.\n"
+                "Please connect to additional databases first.",
+            )
+            return QDialog.Rejected
+
+        from vector_inspector.ui.dialogs.cross_db_migration import CrossDatabaseMigrationDialog
+
+        dialog = CrossDatabaseMigrationDialog(connection_manager, parent)
+        return dialog.exec()
+
+    @staticmethod
+    def show_profile_editor_prompt(parent: QWidget = None):
+        """Show message prompting user to create a new profile."""
+        QMessageBox.information(
+            parent,
+            "Connect to Profile",
+            "Select a profile from the list and click 'Connect', or click '+' to create a new profile.",
+        )
+
+    @staticmethod
+    def show_update_details(latest_release: dict, parent: QWidget = None):
+        """Show update details dialog.
+
+        Args:
+            latest_release: Latest release info from GitHub API
+            parent: Parent widget
+        """
+        from vector_inspector.ui.components.update_details_dialog import UpdateDetailsDialog
+        from vector_inspector.services.update_service import UpdateService
+
+        version = latest_release.get("tag_name", "?")
+        notes = latest_release.get("body", "")
+        instructions = UpdateService.get_update_instructions()
+        pip_cmd = instructions["pip"]
+        github_url = instructions["github"]
+
+        dialog = UpdateDetailsDialog(version, notes, pip_cmd, github_url, parent)
+        dialog.exec()

vector_inspector/ui/tabs.py

@@ -0,0 +1,64 @@
+"""Tab registry for Inspector applications."""
+
+from typing import List, Tuple, Type
+from PySide6.QtWidgets import QWidget
+
+
+class TabDefinition:
+    """Definition for a tab in the main content area."""
+
+    def __init__(self, title: str, widget_class: Type[QWidget], lazy_load: bool = False):
+        self.title = title
+        self.widget_class = widget_class
+        self.lazy_load = lazy_load
+
+
+class InspectorTabs:
+    """Registry of standard Inspector tabs.
+
+    This allows both Vector Inspector and Vector Fusion Studio to use
+    the same tab definitions and add their own custom tabs.
+    """
+
+    # Tab indices (for programmatic access)
+    INFO_TAB = 0
+    DATA_TAB = 1
+    SEARCH_TAB = 2
+    VISUALIZATION_TAB = 3
+
+    @staticmethod
+    def get_standard_tabs() -> List[TabDefinition]:
+        """Get list of standard Inspector tabs.
+
+        Returns:
+            List of TabDefinition objects
+        """
+        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
+
+        return [
+            TabDefinition("Info", InfoPanel, lazy_load=False),
+            TabDefinition("Data Browser", MetadataView, lazy_load=False),
+            TabDefinition("Search", SearchView, lazy_load=False),
+            TabDefinition("Visualization", VisualizationView, lazy_load=True),
+        ]
+
+    @staticmethod
+    def create_tab_widget(tab_def: TabDefinition, connection=None) -> QWidget:
+        """Create a widget instance from a tab definition.
+
+        Args:
+            tab_def: Tab definition
+            connection: Optional connection to pass to widget
+
+        Returns:
+            Widget instance
+        """
+        if tab_def.lazy_load:
+            # Return placeholder for lazy-loaded tabs
+            return QWidget()
+        else:
+            # Create widget with connection
+            return tab_def.widget_class(connection)

{vector_inspector-0.3.7.dist-info → vector_inspector-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vector-inspector
-Version: 0.3.7
+Version: 0.3.8
 Summary: A comprehensive desktop application for visualizing, querying, and managing vector database data
 Author-Email: Anthony Dawson <anthonypdawson+github@gmail.com>
 License: MIT
@@ -31,13 +31,31 @@ Requires-Dist: pgvector>=0.4.2
 Description-Content-Type: text/markdown
 
 # Latest updates
-* Added automatic update notification system:
-	- Checks for new releases on GitHub once per launch/day
-	- Shows update indicator in the status bar and Help menu
-	- Clickable indicator opens a modal with release notes and update instructions
-	- Manual Check for Update in Help menu
-	- Version detection now uses installed package metadata for accuracy
-* Fixed bug where data browser row disappeared post-edit
+
+## Vector Inspector 2026.01 Release Notes
+
+### Major Refactor and Studio-Ready Architecture
+- Refactored main window into modular components:
+  - InspectorShell: reusable UI shell (splitter, tabs, layout)
+  - ProviderFactory: centralized connection creation
+  - DialogService: dialog management
+  - ConnectionController: connection lifecycle and threading
+  - InspectorTabs: pluggable tab registry
+- MainWindow now inherits from InspectorShell and is fully reusable as a widget
+- Bootstrap logic is separated from UI logic—Studio can host Inspector as a component
+- Tab system is now pluggable: Studio and Inspector can add, remove, or override tabs via TabDefinition
+- All Inspector UI logic is self-contained; Studio can extend without modifying Inspector code
+
+### Data Browser Improvements
+- Added a checkbox: Generate embeddings on edit (default: checked)
+  - When unchecked, editing a row skips embedding regeneration
+  - Setting is persisted per user
+
+### Developer and Architecture Notes
+- All modules pass syntax checks and are ready for Studio integration
+- No breaking changes for existing Inspector users
+- Inspector is now a true UI module, not just an application
+
 ---
 
 # Vector Inspector
@@ -45,7 +63,7 @@ Description-Content-Type: text/markdown
 > **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.
 
 [![CI](https://github.com/anthonypdawson/vector-inspector/actions/workflows/ci-tests.yml/badge.svg?branch=master)](https://github.com/anthonypdawson/vector-inspector/actions/workflows/ci-tests.yml)
-[![Publish](https://github.com/anthonypdawson/vector-inspector/actions/workflows/publish.yml/badge.svg?branch=master)](https://github.com/anthonypdawson/vector-inspector/actions/workflows/publish.yml)
+[![Publish](https://github.com/anthonypdawson/vector-inspector/actions/workflows/publish%20copy.yml/badge.svg?branch=master)](https://github.com/anthonypdawson/vector-inspector/actions/workflows/publish%20copy.yml)
 
 [![PyPI Version](https://img.shields.io/pypi/v/vector-inspector.svg?cacheSeconds=300)](https://pypi.org/project/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.3.7.dist-info → vector_inspector-0.3.8.dist-info}/RECORD

@@ -1,6 +1,6 @@
-vector_inspector-0.3.7.dist-info/METADATA,sha256=X24i5_fg7PgJqWp5pUSR3EB5S2j7_UknoOKjPdYJaBs,10786
-vector_inspector-0.3.7.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-vector_inspector-0.3.7.dist-info/entry_points.txt,sha256=u96envMI2NFImZUJDFutiiWl7ZoHrrev9joAgtyvTxo,80
+vector_inspector-0.3.8.dist-info/METADATA,sha256=efuN0ywBf5QkEwGbRDiOV9YHG9pLNdBWBqnHPDsqUg0,11574
+vector_inspector-0.3.8.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+vector_inspector-0.3.8.dist-info/entry_points.txt,sha256=u96envMI2NFImZUJDFutiiWl7ZoHrrev9joAgtyvTxo,80
 vector_inspector/__init__.py,sha256=Q8XbXn98o0eliQWPePhy-aGUz2KNnVg7bQq-sBPl7zQ,119
 vector_inspector/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
 vector_inspector/config/__init__.py,sha256=vHkVsXSUdInsfzWSOLPZzaaELa3SGenAgfpY5EYbsYA,95
@@ -26,6 +26,7 @@ vector_inspector/core/embedding_providers/sentence_transformer_provider.py,sha25
 vector_inspector/core/embedding_utils.py,sha256=UCnJllDS_YPqbOPVo_kxSCUxM64C5tmcH-fuU9IUifQ,5558
 vector_inspector/core/logging.py,sha256=HQ6_OZgZmaS3OMFOTAqc0oRbZujqo1W0w8OU4viXP1g,845
 vector_inspector/core/model_registry.py,sha256=fdofceD3iyNpECVC7djTEAaDYgHX_7JQ3ROh5A0plpY,6269
+vector_inspector/core/provider_factory.py,sha256=QFDpJTOBJVYAdOLlY0GxSWl87Yj_UT9ZzOm9cjVsGMU,3924
 vector_inspector/main.py,sha256=iZeMPH94q6Ma92hWQLJ7on3rwxytUoS0V8n9MkAuEaY,595
 vector_inspector/services/__init__.py,sha256=QLgH7oybjHuEYDFNiBgmJxvSpgAzHEuBEPXa3SKJb_I,67
 vector_inspector/services/backup_helpers.py,sha256=aX1ONFegERq6dpoNM1eJrbyE1gWCV3SuUHMyPpnxrYM,2005
@@ -45,13 +46,19 @@ vector_inspector/ui/components/filter_builder.py,sha256=NSR_hp-rzUZVAca6dIJhTxZA
 vector_inspector/ui/components/item_dialog.py,sha256=VMwehEjQ6xrdxWygR9J-hHsLfzOVb_E3ePUGYO_c7XA,3951
 vector_inspector/ui/components/loading_dialog.py,sha256=YEKYGU-R-Zz4CjXSArJtkNxgTy4O9hI5Bbt6qlIzD8U,1018
 vector_inspector/ui/components/profile_manager_panel.py,sha256=U-Ea6KC97ltj7bYtG4h9Okb97SbfBAvH1SusbYHTn1o,27930
-vector_inspector/ui/components/splash_window.py,sha256=lnCdva1fys0BQ1k_rEIQuWjQYXdhGZOf8zRweG2VdyM,1904
+vector_inspector/ui/components/splash_window.py,sha256=AYuRRdLfnuS3ueMSCLfpGG4Q348g_uDIGRyhK4ovzzU,2507
 vector_inspector/ui/components/update_details_dialog.py,sha256=IQl4QZ30tHHOFay68qGOajQ6JuOB85plNoEazzMYS6k,1587
+vector_inspector/ui/controllers/__init__.py,sha256=Wrc4GsLBbIU3FFk9py9URcblNCp-auGAAT1XPi20nWY,53
+vector_inspector/ui/controllers/connection_controller.py,sha256=cx5Vgdn7cleMeJdUewDHd4NXSMmPUOFDwxQQVArfXuE,6494
 vector_inspector/ui/dialogs/__init__.py,sha256=xtT77L91PFfm3zHYRENHkWHJaKPm1htuUzRXAF53P8w,211
 vector_inspector/ui/dialogs/cross_db_migration.py,sha256=BaUyic8l5Ywwql2hQyxVrCXHMjGtqerNAQHDYxcbQ54,15872
 vector_inspector/ui/dialogs/embedding_config_dialog.py,sha256=1K5LBSBXp590BvKwtHx9qgPwGREsn1mJ8cjFGSZHnMA,12926
 vector_inspector/ui/dialogs/provider_type_dialog.py,sha256=W_FAJuvicwBUJJ7PyvKow9lc8_a5pnE3RIAsh-DVndQ,6809
-vector_inspector/ui/main_window.py,sha256=ma7QPSXom3mw9-nwJcOvuQxj_PoVcmM-4daSJEKKZVs,31055
+vector_inspector/ui/main_window.py,sha256=mZfUm29Ur-dfR4pbHXRSaDsQmIHFY1_SfOahHE_o1DI,21493
+vector_inspector/ui/main_window_shell.py,sha256=0o4KxRc4KXu-mJxni9dv74a5DzP4OIvJoLTX7BLqDoo,3425
+vector_inspector/ui/services/__init__.py,sha256=m2DGkhYlcQQGMtNQsup5eKmhCFhOhXHi-g9Hw0GH1vE,55
+vector_inspector/ui/services/dialog_service.py,sha256=1NHWSMvNadcmoh8tgUMSa8N7g8xYDOTaWMr1G8i9e8A,4261
+vector_inspector/ui/tabs.py,sha256=nniOLax93udxFt1t3s-kx1BpguXBEiDUmC1HA9J-scw,2071
 vector_inspector/ui/views/__init__.py,sha256=FeMtVzSbVFBMjdwLQSQqD0FRW4ieJ4ZKXtTBci2e_bw,30
 vector_inspector/ui/views/collection_browser.py,sha256=oG9_YGPoVuMs-f_zSd4EcITmEU9caxvwuubsFUrNf-c,3991
 vector_inspector/ui/views/connection_view.py,sha256=3oGbClqwpVuUD3AIT8TuM-8heDvwMYw7RowHT3b1b8o,23749
@@ -62,4 +69,4 @@ vector_inspector/ui/views/visualization_view.py,sha256=wgkSkOM-ShOHDj1GCUtKnqH87
 vector_inspector/utils/__init__.py,sha256=jhHBQC8C8bfhNlf6CAt07ejjStp_YAyleaYr2dm0Dk0,38
 vector_inspector/utils/lazy_imports.py,sha256=2XZ3ZnwTvZ5vvrh36nJ_TUjwwkgjoAED6i6P9yctvt0,1211
 vector_inspector/utils/version.py,sha256=2Xk9DEKlDRGEszNNiYnK7ps1i3OH56H2uZhR0_yZORs,382
-vector_inspector-0.3.7.dist-info/RECORD,,
+vector_inspector-0.3.8.dist-info/RECORD,,