vector-inspector 0.2.7__py3-none-any.whl → 0.3.2__py3-none-any.whl

vector_inspector/services/settings_service.py

@@ -2,7 +2,7 @@
 
 import json
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 from vector_inspector.core.cache_manager import invalidate_cache_on_settings_change
 
 
@@ -77,3 +77,119 @@ class SettingsService:
         """Clear all settings."""
         self.settings = {}
         self._save_settings()
+    
+    def save_embedding_model(self, connection_id: str, collection_name: str, model_name: str, model_type: str = "user-configured"):
+        """Save embedding model mapping for a collection.
+        
+        Args:
+            connection_id: Connection identifier
+            collection_name: Collection name
+            model_name: Embedding model name (e.g., 'sentence-transformers/all-MiniLM-L6-v2')
+            model_type: Type of configuration ('user-configured', 'auto-detected', 'stored')
+        """
+        if "collection_embedding_models" not in self.settings:
+            self.settings["collection_embedding_models"] = {}
+        
+        collection_key = f"{connection_id}:{collection_name}"
+        self.settings["collection_embedding_models"][collection_key] = {
+            "model": model_name,
+            "type": model_type,
+            "timestamp": self._get_timestamp()
+        }
+        self._save_settings()
+    
+    def get_embedding_model(self, connection_id: str, collection_name: str) -> Optional[Dict[str, Any]]:
+        """Get embedding model mapping for a collection.
+        
+        Args:
+            connection_id: Connection identifier
+            collection_name: Collection name
+            
+        Returns:
+            Dictionary with 'model', 'type', and 'timestamp' or None
+        """
+        collection_models = self.settings.get("collection_embedding_models", {})
+        collection_key = f"{connection_id}:{collection_name}"
+        return collection_models.get(collection_key)
+    
+    def remove_embedding_model(self, connection_id: str, collection_name: str):
+        """Remove embedding model mapping for a collection.
+        
+        Args:
+            connection_id: Connection identifier
+            collection_name: Collection name
+        """
+        if "collection_embedding_models" not in self.settings:
+            return
+        
+        collection_key = f"{connection_id}:{collection_name}"
+        self.settings["collection_embedding_models"].pop(collection_key, None)
+        self._save_settings()
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp as ISO string."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+    
+    def add_custom_embedding_model(self, model_name: str, dimension: int, model_type: str = "sentence-transformer", description: str = "Custom model"):
+        """Add a custom embedding model to the known models list.
+        
+        Args:
+            model_name: Name of the embedding model
+            dimension: Vector dimension
+            model_type: Type of model (e.g., 'sentence-transformer', 'clip', 'openai')
+            description: Brief description of the model
+        """
+        if "custom_embedding_models" not in self.settings:
+            self.settings["custom_embedding_models"] = []
+        
+        # Check if already exists
+        for model in self.settings["custom_embedding_models"]:
+            if model["name"] == model_name and model["dimension"] == dimension:
+                # Update existing entry
+                model["type"] = model_type
+                model["description"] = description
+                model["last_used"] = self._get_timestamp()
+                self._save_settings()
+                return
+        
+        # Add new entry
+        self.settings["custom_embedding_models"].append({
+            "name": model_name,
+            "dimension": dimension,
+            "type": model_type,
+            "description": description,
+            "added": self._get_timestamp(),
+            "last_used": self._get_timestamp()
+        })
+        self._save_settings()
+    
+    def get_custom_embedding_models(self, dimension: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Get list of custom embedding models.
+        
+        Args:
+            dimension: Optional filter by dimension
+            
+        Returns:
+            List of custom model dictionaries
+        """
+        models = self.settings.get("custom_embedding_models", [])
+        if dimension is not None:
+            return [m for m in models if m["dimension"] == dimension]
+        return models
+    
+    def remove_custom_embedding_model(self, model_name: str, dimension: int):
+        """Remove a custom embedding model.
+        
+        Args:
+            model_name: Name of the model to remove
+            dimension: Vector dimension
+        """
+        if "custom_embedding_models" not in self.settings:
+            return
+        
+        self.settings["custom_embedding_models"] = [
+            m for m in self.settings["custom_embedding_models"]
+            if not (m["name"] == model_name and m["dimension"] == dimension)
+        ]
+        self._save_settings()

vector_inspector/ui/components/connection_manager_panel.py

@@ -289,11 +289,18 @@ class ConnectionManagerPanel(QWidget):
         if not instance or not instance.connection.is_connected:
             return
         
+        # Show loading while refreshing
+        from ..components.loading_dialog import LoadingDialog
+        loading = LoadingDialog("Refreshing collections...", self)
+        loading.show_loading("Refreshing collections...")
+        QApplication.processEvents()
         try:
             collections = instance.connection.list_collections()
             self.connection_manager.update_collections(connection_id, collections)
         except Exception as e:
             QMessageBox.warning(self, "Error", f"Failed to refresh collections: {e}")
+        finally:
+            loading.hide_loading()
     
     def _disconnect_connection(self, connection_id: str):
         """Disconnect a connection."""

vector_inspector/ui/components/profile_manager_panel.py

@@ -266,6 +266,7 @@ class ProfileEditorDialog(QDialog):
         self.provider_combo = QComboBox()
         self.provider_combo.addItem("ChromaDB", "chromadb")
         self.provider_combo.addItem("Qdrant", "qdrant")
+        self.provider_combo.addItem("Pinecone", "pinecone")
         self.provider_combo.currentIndexChanged.connect(self._on_provider_changed)
         form_layout.addRow("Provider:", self.provider_combo)
         
@@ -356,23 +357,48 @@ class ProfileEditorDialog(QDialog):
             if self.port_input.text() == "6333":
                 self.port_input.setText("8000")
         
-        # Show/hide API key field
-        is_http = self.http_radio.isChecked()
-        self.api_key_input.setEnabled(is_http and provider == "qdrant")
+        # For Pinecone, disable persistent/ephemeral modes and only show API key
+        if provider == "pinecone":
+            self.persistent_radio.setEnabled(False)
+            self.http_radio.setEnabled(True)
+            self.http_radio.setChecked(True)
+            self.ephemeral_radio.setEnabled(False)
+            self.path_input.setEnabled(False)
+            self.path_browse_btn.setEnabled(False)
+            self.host_input.setEnabled(False)
+            self.port_input.setEnabled(False)
+            self.api_key_input.setEnabled(True)
+        else:
+            self.persistent_radio.setEnabled(True)
+            self.http_radio.setEnabled(True)
+            self.ephemeral_radio.setEnabled(True)
+            # Show/hide API key field
+            is_http = self.http_radio.isChecked()
+            self.api_key_input.setEnabled(is_http and provider == "qdrant")
+            # Update other fields based on connection type
+            self._on_type_changed()
     
     def _on_type_changed(self):
         """Handle connection type change."""
         is_persistent = self.persistent_radio.isChecked()
         is_http = self.http_radio.isChecked()
         
-        # Show/hide relevant fields
-        self.path_input.setEnabled(is_persistent)
-        self.path_browse_btn.setEnabled(is_persistent)
-        self.host_input.setEnabled(is_http)
-        self.port_input.setEnabled(is_http)
-        
         provider = self.provider_combo.currentData()
-        self.api_key_input.setEnabled(is_http and provider == "qdrant")
+        
+        # Pinecone always uses API key, no path/host/port
+        if provider == "pinecone":
+            self.path_input.setEnabled(False)
+            self.path_browse_btn.setEnabled(False)
+            self.host_input.setEnabled(False)
+            self.port_input.setEnabled(False)
+            self.api_key_input.setEnabled(True)
+        else:
+            # Show/hide relevant fields
+            self.path_input.setEnabled(is_persistent)
+            self.path_browse_btn.setEnabled(is_persistent)
+            self.host_input.setEnabled(is_http)
+            self.port_input.setEnabled(is_http)
+            self.api_key_input.setEnabled(is_http and provider == "qdrant")
     
     def _browse_for_path(self):
         """Browse for persistent storage path."""
@@ -405,7 +431,10 @@ class ProfileEditorDialog(QDialog):
         conn_type = config.get("type", "persistent")
         
         # Set connection type
-        if conn_type == "persistent":
+        if conn_type == "cloud":
+            # Pinecone cloud connection
+            self.http_radio.setChecked(True)
+        elif conn_type == "persistent":
             self.persistent_radio.setChecked(True)
             self.path_input.setText(config.get("path", ""))
         elif conn_type == "http":
@@ -429,9 +458,16 @@ class ProfileEditorDialog(QDialog):
         # Create connection
         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
         
         try:
-            if provider == "chromadb":
+            if provider == "pinecone":
+                api_key = self.api_key_input.text()
+                if not api_key:
+                    QMessageBox.warning(self, "Missing API Key", "Pinecone requires an API key.")
+                    return
+                conn = PineconeConnection(api_key=api_key)
+            elif provider == "chromadb":
                 conn = ChromaDBConnection(**self._get_connection_kwargs(config))
             else:
                 conn = QdrantConnection(**self._get_connection_kwargs(config))
@@ -455,8 +491,12 @@ class ProfileEditorDialog(QDialog):
     def _get_config(self) -> dict:
         """Get configuration from form."""
         config = {}
+        provider = self.provider_combo.currentData()
         
-        if self.persistent_radio.isChecked():
+        # Pinecone uses cloud connection type
+        if provider == "pinecone":
+            config["type"] = "cloud"
+        elif self.persistent_radio.isChecked():
             config["type"] = "persistent"
             config["path"] = self.path_input.text()
         elif self.http_radio.isChecked():
@@ -494,7 +534,14 @@ class ProfileEditorDialog(QDialog):
         
         # Get credentials
         credentials = {}
-        if self.api_key_input.text() and self.http_radio.isChecked():
+        if provider == "pinecone":
+            # Pinecone always requires API key
+            if self.api_key_input.text():
+                credentials["api_key"] = self.api_key_input.text()
+            else:
+                QMessageBox.warning(self, "Missing API Key", "Pinecone requires an API key.")
+                return
+        elif self.api_key_input.text() and self.http_radio.isChecked():
             credentials["api_key"] = self.api_key_input.text()
         
         if self.is_edit_mode:

vector_inspector/ui/dialogs/__init__.py

@@ -1,5 +1,6 @@
 """UI Dialogs for vector-inspector."""
 
 from .embedding_config_dialog import EmbeddingConfigDialog
+from .provider_type_dialog import ProviderTypeDialog
 
-__all__ = ['EmbeddingConfigDialog']
+__all__ = ['EmbeddingConfigDialog', 'ProviderTypeDialog']

vector_inspector/ui/dialogs/cross_db_migration.py

@@ -107,12 +107,31 @@ class MigrationThread(QThread):
                 self.progress.emit(100, f"Migration complete!")
                 self.finished.emit(True, f"Successfully migrated {self.source_collection} to {self.target_collection}")
             else:
-                self.finished.emit(False, "Failed to restore to target collection.")
+                # Clean up target collection on failure
+                try:
+                    if self.target_collection in self.target_conn.connection.list_collections():
+                        self.progress.emit(90, "Cleaning up failed migration...")
+                        print(f"Cleaning up failed migration: deleting target collection '{self.target_collection}'")
+                        self.target_conn.connection.delete_collection(self.target_collection)
+                except Exception as cleanup_error:
+                    print(f"Warning: Failed to clean up target collection: {cleanup_error}")
+                
+                self.finished.emit(False, "Failed to restore to target collection. Target collection cleaned up.")
         
         except Exception as e:
             import traceback
             error_details = traceback.format_exc()
             print(f"Migration error details:\n{error_details}")
+            
+            # Clean up target collection on exception
+            try:
+                if self.target_conn and self.target_conn.connection.is_connected:
+                    if self.target_collection in self.target_conn.connection.list_collections():
+                        print(f"Cleaning up failed migration: deleting target collection '{self.target_collection}'")
+                        self.target_conn.connection.delete_collection(self.target_collection)
+            except Exception as cleanup_error:
+                print(f"Warning: Failed to clean up target collection: {cleanup_error}")
+            
             self.finished.emit(False, f"Migration error: {str(e)}")
         
         finally:

vector_inspector/ui/dialogs/embedding_config_dialog.py

@@ -1,38 +1,63 @@
-"""Dialog for configuring embedding models for collections."""
+"""Dialog for configuring embedding models for collections (Step 2: Model Selection)."""
 
 from typing import Optional, Tuple
 from PySide6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
     QComboBox, QPushButton, QGroupBox, QTextEdit,
-    QMessageBox
+    QMessageBox, QLineEdit, QFormLayout
 )
 from PySide6.QtCore import Qt
 
-from vector_inspector.core.embedding_utils import get_available_models_for_dimension, DIMENSION_TO_MODEL
+from vector_inspector.core.embedding_utils import get_available_models_for_dimension
+from vector_inspector.core.model_registry import get_model_registry
 
 
 class EmbeddingConfigDialog(QDialog):
     """Dialog for selecting embedding model for a collection."""
     
     def __init__(self, collection_name: str, vector_dimension: int, 
+                 provider_type: Optional[str] = None,
                  current_model: Optional[str] = None, 
                  current_type: Optional[str] = None,
                  parent=None):
         super().__init__(parent)
         self.collection_name = collection_name
         self.vector_dimension = vector_dimension
+        self.provider_type = provider_type  # Filter by this type
         self.current_model = current_model
         self.current_type = current_type
         self.selected_model = None
         self.selected_type = None
         
-        self.setWindowTitle(f"Configure Embedding Model - {collection_name}")
+        # Determine title based on provider type
+        if provider_type == "custom":
+            title = "Enter Custom Model"
+        elif provider_type:
+            type_names = {
+                "sentence-transformer": "Sentence Transformers",
+                "clip": "CLIP Models",
+                "openai": "OpenAI API",
+                "cohere": "Cohere API",
+                "vertex-ai": "Google Vertex AI",
+                "voyage": "Voyage AI"
+            }
+            type_name = type_names.get(provider_type, provider_type.title())
+            title = f"Select Model: {type_name}"
+        else:
+            title = f"Configure Embedding Model - {collection_name}"
+        
+        self.setWindowTitle(title)
         self.setMinimumWidth(500)
         self._setup_ui()
         
     def _setup_ui(self):
         """Setup dialog UI."""
         layout = QVBoxLayout(self)
+
+        # Handle custom model entry case
+        if self.provider_type == "custom":
+            self._setup_custom_ui(layout)
+            return
         
         # Info section
         info_group = QGroupBox("Collection Information")
@@ -55,17 +80,38 @@ class EmbeddingConfigDialog(QDialog):
         model_group = QGroupBox("Embedding Model Selection")
         model_layout = QVBoxLayout()
         
-        # Get available models for this dimension
-        available_models = get_available_models_for_dimension(self.vector_dimension)
+        # Get available models for this dimension, filtered by provider type
+        if self.provider_type:
+            registry = get_model_registry()
+            registry_models = registry.get_models_by_dimension(self.vector_dimension)
+            filtered_models = [m for m in registry_models if m.type == self.provider_type]
+            available_models = [(m.name, m.type, m.description) for m in filtered_models]
+            
+            # Add custom models from settings
+            try:
+                from ...services.settings_service import SettingsService
+                settings = SettingsService()
+                custom_models = settings.get_custom_embedding_models(self.vector_dimension)
+                for model in custom_models:
+                    if model["type"] == self.provider_type:
+                        available_models.append((
+                            model["name"],
+                            model["type"],
+                            f"{model['description']} (custom)"
+                        ))
+            except Exception:
+                pass
+        else:
+            available_models = get_available_models_for_dimension(self.vector_dimension)
         
         if available_models:
             model_layout.addWidget(QLabel(f"Available models for {self.vector_dimension}-dimensional vectors:"))
-            
+
             self.model_combo = QComboBox()
             for model_name, model_type, description in available_models:
                 display_text = f"{model_name} ({model_type}) - {description}"
                 self.model_combo.addItem(display_text, (model_name, model_type))
-            
+
             # Set current selection if it matches
             if self.current_model and self.current_type:
                 for i in range(self.model_combo.count()):
@@ -73,33 +119,35 @@ class EmbeddingConfigDialog(QDialog):
                     if model_name == self.current_model and model_type == self.current_type:
                         self.model_combo.setCurrentIndex(i)
                         break
-            
+
             model_layout.addWidget(self.model_combo)
-            
+
             # Description area
             desc_label = QLabel("<b>About the selected model:</b>")
             model_layout.addWidget(desc_label)
-            
+
             self.description_text = QTextEdit()
             self.description_text.setReadOnly(True)
             self.description_text.setMaximumHeight(100)
             self.description_text.setStyleSheet("background-color: #f5f5f5; border: 1px solid #ccc; color: #000000;")
             model_layout.addWidget(self.description_text)
-            
+
             # Update description when selection changes
             self.model_combo.currentIndexChanged.connect(self._update_description)
             self._update_description()
-            
+
         else:
-            # No known models for this dimension
-            warning = QLabel(f"⚠️ No pre-configured models available for {self.vector_dimension} dimensions.")
+            # No models for this type + dimension
+            type_name = self.provider_type or "any type"
+            warning = QLabel(f"⚠️ No models of type '{type_name}' available for {self.vector_dimension} dimensions.")
             warning.setWordWrap(True)
             model_layout.addWidget(warning)
-            
-            # Show all available dimensions
-            dims_text = "Available dimensions: " + ", ".join(str(d) for d in sorted(DIMENSION_TO_MODEL.keys()))
+
+            registry = get_model_registry()
+            all_dims = registry.get_all_dimensions()
+            dims_text = "Available dimensions: " + ", ".join(str(d) for d in sorted(all_dims))
             model_layout.addWidget(QLabel(dims_text))
-            
+
             self.model_combo = None
         
         model_group.setLayout(model_layout)
@@ -110,8 +158,9 @@ class EmbeddingConfigDialog(QDialog):
         button_layout.addStretch()
         
         self.save_btn = QPushButton("Save Configuration")
-        self.save_btn.clicked.connect(self.accept)
-        self.save_btn.setEnabled(available_models and len(available_models) > 0)
+        self.save_btn.clicked.connect(self._on_save)
+        # Always enabled - user can choose from combo OR enter custom
+        self.save_btn.setEnabled(True)
         
         self.clear_btn = QPushButton("Clear Configuration")
         self.clear_btn.clicked.connect(self._clear_config)
@@ -126,6 +175,85 @@ class EmbeddingConfigDialog(QDialog):
         
         layout.addLayout(button_layout)
     
+    def _setup_custom_ui(self, layout):
+        """Setup UI for custom model entry."""
+        # Info section
+        info_group = QGroupBox("Collection Information")
+        info_layout = QVBoxLayout()
+        info_layout.addWidget(QLabel(f"<b>Collection:</b> {self.collection_name}"))
+        info_layout.addWidget(QLabel(f"<b>Vector Dimension:</b> {self.vector_dimension}"))
+        info_group.setLayout(info_layout)
+        layout.addWidget(info_group)
+
+        # Custom model entry section
+        custom_group = QGroupBox("Enter Custom Model Details")
+        custom_layout = QFormLayout()
+
+        self.custom_name_input = QLineEdit()
+        self.custom_name_input.setPlaceholderText("e.g., sentence-transformers/all-mpnet-base-v2")
+        custom_layout.addRow("Model Name:", self.custom_name_input)
+
+        self.custom_type_combo = QComboBox()
+        self.custom_type_combo.addItems(["sentence-transformer", "clip", "openai", "cohere", "vertex-ai", "voyage", "custom"])
+        custom_layout.addRow("Model Type:", self.custom_type_combo)
+
+        self.custom_desc_input = QLineEdit()
+        self.custom_desc_input.setPlaceholderText("Brief description (optional)")
+        custom_layout.addRow("Description:", self.custom_desc_input)
+
+        custom_note = QLabel("💡 Custom models will be saved and available for future use with this dimension.")
+        custom_note.setWordWrap(True)
+        custom_note.setStyleSheet("color: #666; font-size: 10px; padding: 4px;")
+        custom_layout.addRow(custom_note)
+
+        custom_group.setLayout(custom_layout)
+        layout.addWidget(custom_group)
+
+        # Buttons for custom entry
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+
+        save_btn = QPushButton("Save")
+        save_btn.clicked.connect(self._save_custom_model)
+        save_btn.setDefault(True)
+
+        button_layout.addWidget(cancel_btn)
+        button_layout.addWidget(save_btn)
+
+        layout.addLayout(button_layout)
+
+        # No combo or description for custom mode
+        self.model_combo = None
+    
+    def _save_custom_model(self):
+        """Save custom model entry."""
+        custom_name = self.custom_name_input.text().strip()
+        custom_desc = self.custom_desc_input.text().strip()
+        custom_type = self.custom_type_combo.currentText()
+
+        if not custom_name:
+            QMessageBox.warning(self, "Invalid Input", "Please enter a model name.")
+            return
+
+        # Save custom model to registry
+        from vector_inspector.services.settings_service import SettingsService
+        settings = SettingsService()
+
+        settings.add_custom_embedding_model(
+            model_name=custom_name,
+            dimension=self.vector_dimension,
+            model_type=custom_type,
+            description=custom_desc if custom_desc else f"Custom {custom_type} model"
+        )
+
+        # Set selection to custom model
+        self.selected_model = custom_name
+        self.selected_type = custom_type
+        self.accept()
+    
     def _update_description(self):
         """Update the description text based on selected model."""
         if not self.model_combo:
@@ -153,6 +281,19 @@ class EmbeddingConfigDialog(QDialog):
             f"{desc}"
         )
     
+    def _on_save(self):
+        """Handle save button click."""
+        if self.model_combo and self.model_combo.currentData():
+            # Use combo selection
+            model_name, model_type = self.model_combo.currentData()
+            self.selected_model = model_name
+            self.selected_type = model_type
+        else:
+            QMessageBox.warning(self, "No Selection", "Please select a model from the list.")
+            return
+        
+        self.accept()
+    
     def _clear_config(self):
         """Clear the embedding model configuration."""
         reply = QMessageBox.question(
@@ -168,9 +309,7 @@ class EmbeddingConfigDialog(QDialog):
             self.done(2)  # Custom code for "clear"
     
     def get_selection(self) -> Optional[Tuple[str, str]]:
-        """Get the selected model and type."""
-        if not self.model_combo:
-            return None
-        
-        model_name, model_type = self.model_combo.currentData()
-        return (model_name, model_type)
+        """Get the selected model and type (from either combo or custom entry)."""
+        if self.selected_model and self.selected_type:
+            return (self.selected_model, self.selected_type)
+        return None