vector-inspector 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

vector_inspector/ui/dialogs/embedding_config_dialog.py

@@ -2,9 +2,17 @@
 
 from typing import Optional, Tuple
 from PySide6.QtWidgets import (
-    QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
-    QComboBox, QPushButton, QGroupBox, QTextEdit,
-    QMessageBox, QLineEdit, QFormLayout
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QLabel,
+    QComboBox,
+    QPushButton,
+    QGroupBox,
+    QTextEdit,
+    QMessageBox,
+    QLineEdit,
+    QFormLayout,
 )
 from PySide6.QtCore import Qt
 
@@ -14,12 +22,16 @@ 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):
+
+    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
@@ -28,7 +40,7 @@ class EmbeddingConfigDialog(QDialog):
         self.current_type = current_type
         self.selected_model = None
         self.selected_type = None
-        
+
         # Determine title based on provider type
         if provider_type == "custom":
             title = "Enter Custom Model"
@@ -39,17 +51,17 @@ class EmbeddingConfigDialog(QDialog):
                 "openai": "OpenAI API",
                 "cohere": "Cohere API",
                 "vertex-ai": "Google Vertex AI",
-                "voyage": "Voyage 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)
@@ -58,54 +70,57 @@ class EmbeddingConfigDialog(QDialog):
         if self.provider_type == "custom":
             self._setup_custom_ui(layout)
             return
-        
+
         # 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}"))
-        
+
         if self.current_model:
-            info_layout.addWidget(QLabel(f"<b>Current Model:</b> {self.current_model} ({self.current_type})"))
+            info_layout.addWidget(
+                QLabel(f"<b>Current Model:</b> {self.current_model} ({self.current_type})")
+            )
         else:
             warning = QLabel("⚠️ No embedding model configured - using automatic detection")
             warning.setStyleSheet("color: orange;")
             info_layout.addWidget(warning)
-        
+
         info_group.setLayout(info_layout)
         layout.addWidget(info_group)
-        
+
         # Model selection section
         model_group = QGroupBox("Embedding Model Selection")
         model_layout = QVBoxLayout()
-        
+
         # 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
+                from vector_inspector.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)"
-                        ))
+                        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:"))
+            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:
@@ -129,7 +144,9 @@ class EmbeddingConfigDialog(QDialog):
             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;")
+            self.description_text.setStyleSheet(
+                "background-color: #f5f5f5; border: 1px solid #ccc; color: #000000;"
+            )
             model_layout.addWidget(self.description_text)
 
             # Update description when selection changes
@@ -139,7 +156,9 @@ class EmbeddingConfigDialog(QDialog):
         else:
             # 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 = QLabel(
+                f"⚠️ No models of type '{type_name}' available for {self.vector_dimension} dimensions."
+            )
             warning.setWordWrap(True)
             model_layout.addWidget(warning)
 
@@ -149,32 +168,32 @@ class EmbeddingConfigDialog(QDialog):
             model_layout.addWidget(QLabel(dims_text))
 
             self.model_combo = None
-        
+
         model_group.setLayout(model_layout)
         layout.addWidget(model_group)
-        
+
         # Buttons
         button_layout = QHBoxLayout()
         button_layout.addStretch()
-        
+
         self.save_btn = QPushButton("Save Configuration")
         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)
         self.clear_btn.setEnabled(self.current_model is not None)
-        
+
         cancel_btn = QPushButton("Cancel")
         cancel_btn.clicked.connect(self.reject)
-        
+
         button_layout.addWidget(self.save_btn)
         button_layout.addWidget(self.clear_btn)
         button_layout.addWidget(cancel_btn)
-        
+
         layout.addLayout(button_layout)
-    
+
     def _setup_custom_ui(self, layout):
         """Setup UI for custom model entry."""
         # Info section
@@ -194,14 +213,18 @@ class EmbeddingConfigDialog(QDialog):
         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"])
+        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 = 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)
@@ -227,7 +250,7 @@ class EmbeddingConfigDialog(QDialog):
 
         # 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()
@@ -240,27 +263,28 @@ class EmbeddingConfigDialog(QDialog):
 
         # 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"
+            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:
             return
-        
+
         model_name, model_type = self.model_combo.currentData()
-        
+
         descriptions = {
             "sentence-transformer": (
                 "Sentence-Transformers are text-only embedding models optimized for semantic similarity. "
@@ -270,17 +294,14 @@ class EmbeddingConfigDialog(QDialog):
                 "CLIP (Contrastive Language-Image Pre-training) is a multi-modal model that can embed both "
                 "text and images into the same vector space. This allows text queries to find semantically "
                 "similar images, and vice versa. Perfect for image search with text descriptions."
-            )
+            ),
         }
-        
+
         desc = descriptions.get(model_type, "Embedding model for vector similarity search.")
         self.description_text.setPlainText(
-            f"Model: {model_name}\n"
-            f"Type: {model_type}\n"
-            f"Dimension: {self.vector_dimension}\n\n"
-            f"{desc}"
+            f"Model: {model_name}\nType: {model_type}\nDimension: {self.vector_dimension}\n\n{desc}"
         )
-    
+
     def _on_save(self):
         """Handle save button click."""
         if self.model_combo and self.model_combo.currentData():
@@ -291,23 +312,23 @@ class EmbeddingConfigDialog(QDialog):
         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(
             self,
             "Clear Configuration",
             "This will remove the custom embedding model configuration and use automatic detection. Continue?",
-            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
         )
-        
+
         if reply == QMessageBox.StandardButton.Yes:
             self.selected_model = None
             self.selected_type = None
             self.done(2)  # Custom code for "clear"
-    
+
     def get_selection(self) -> Optional[Tuple[str, str]]:
         """Get the selected model and type (from either combo or custom entry)."""
         if self.selected_model and self.selected_type:

vector_inspector/ui/main_window.py

@@ -24,6 +24,7 @@ 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.components.connection_manager_panel import ConnectionManagerPanel
@@ -433,6 +434,8 @@ class MainWindow(QMainWindow):
                 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
@@ -500,6 +503,25 @@ class MainWindow(QMainWindow):
 
         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
     ):