vector-inspector 0.2.6__py3-none-any.whl → 0.3.1__py3-none-any.whl

vector_inspector/ui/views/connection_view.py

@@ -10,6 +10,7 @@ from PySide6.QtCore import Signal, QThread
 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.ui.components.loading_dialog import LoadingDialog
 from vector_inspector.services.settings_service import SettingsService
 
@@ -66,6 +67,7 @@ class ConnectionDialog(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)
         provider_layout.addWidget(self.provider_combo)
         provider_group.setLayout(provider_layout)
@@ -179,19 +181,42 @@ class ConnectionDialog(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 self.provider == "qdrant")
+        # For Pinecone, hide persistent/HTTP options and only show API key
+        if self.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.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 self.provider == "qdrant")
+            # Update path/host/port 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()
         
-        self.path_input.setEnabled(is_persistent)
-        self.host_input.setEnabled(is_http)
-        self.port_input.setEnabled(is_http)
-        self.api_key_input.setEnabled(is_http and self.provider == "qdrant")
+        # Pinecone always uses API key, no path/host/port
+        if self.provider == "pinecone":
+            self.path_input.setEnabled(False)
+            self.host_input.setEnabled(False)
+            self.port_input.setEnabled(False)
+            self.api_key_input.setEnabled(True)
+        else:
+            self.path_input.setEnabled(is_persistent)
+            self.host_input.setEnabled(is_http)
+            self.port_input.setEnabled(is_http)
+            self.api_key_input.setEnabled(is_http and self.provider == "qdrant")
 
         self._update_absolute_preview()
         
@@ -202,7 +227,13 @@ class ConnectionDialog(QDialog):
         
         config = {"provider": self.provider}
         
-        if self.persistent_radio.isChecked():
+        # Pinecone only needs API key
+        if self.provider == "pinecone":
+            config.update({
+                "type": "cloud",
+                "api_key": self.api_key_input.text()
+            })
+        elif self.persistent_radio.isChecked():
             config.update({"type": "persistent", "path": self.path_input.text()})
         elif self.http_radio.isChecked():
             config.update({
@@ -286,7 +317,13 @@ class ConnectionDialog(QDialog):
         
         # Set connection type
         conn_type = last_config.get("type", "persistent")
-        if conn_type == "persistent":
+        if conn_type == "cloud":
+            # Pinecone cloud connection
+            self.http_radio.setChecked(True)
+            api_key = last_config.get("api_key")
+            if api_key:
+                self.api_key_input.setText(api_key)
+        elif conn_type == "persistent":
             self.persistent_radio.setChecked(True)
             path = last_config.get("path", "")
             if path:
@@ -370,7 +407,15 @@ class ConnectionView(QWidget):
         conn_type = config.get("type")
         
         # Create appropriate connection instance based on provider
-        if provider == "qdrant":
+        if provider == "pinecone":
+            api_key = config.get("api_key")
+            if not api_key:
+                self.loading_dialog.hide_loading()
+                from PySide6.QtWidgets import QMessageBox
+                QMessageBox.warning(self, "Missing API Key", "Pinecone requires an API key to connect.")
+                return
+            self.connection = PineconeConnection(api_key=api_key)
+        elif provider == "qdrant":
             if conn_type == "persistent":
                 self.connection = QdrantConnection(path=config.get("path"))
             elif conn_type == "http":

vector_inspector/ui/views/info_panel.py

@@ -3,13 +3,17 @@
 from typing import Optional, Dict, Any
 from PySide6.QtWidgets import (
     QWidget, QVBoxLayout, QHBoxLayout, QLabel,
-    QGroupBox, QScrollArea, QFrame
+    QGroupBox, QScrollArea, QFrame, QPushButton
 )
 from PySide6.QtCore import Qt, QObject
+from PySide6.QtWidgets import QDialog
+from PySide6.QtWidgets import QApplication
 
 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.cache_manager import get_cache_manager
 
 
 class InfoPanel(QWidget):
@@ -18,7 +22,10 @@ class InfoPanel(QWidget):
     def __init__(self, connection: VectorDBConnection, parent=None):
         super().__init__(parent)
         self.connection = connection
+        self.connection_id: str = ""  # Will be set when collection is set
         self.current_collection: str = ""
+        self.current_database: str = ""
+        self.cache_manager = get_cache_manager()
         self._setup_ui()
         
     def _setup_ui(self):
@@ -65,10 +72,31 @@ class InfoPanel(QWidget):
         self.distance_metric_label = self._create_info_row("Distance Metric:", "N/A")
         self.total_points_label = self._create_info_row("Total Points:", "0")
         
+        # Embedding model row with configure button
+        embedding_row = QWidget()
+        embedding_layout = QHBoxLayout(embedding_row)
+        embedding_layout.setContentsMargins(0, 2, 0, 2)
+        
+        embedding_label = QLabel("<b>Embedding Model:</b>")
+        embedding_label.setMinimumWidth(150)
+        self.embedding_model_label = QLabel("Auto-detect")
+        self.embedding_model_label.setStyleSheet("color: gray;")
+        self.embedding_model_label.setWordWrap(True)
+        
+        self.configure_embedding_btn = QPushButton("Configure...")
+        self.configure_embedding_btn.setMaximumWidth(100)
+        self.configure_embedding_btn.clicked.connect(self._configure_embedding_model)
+        self.configure_embedding_btn.setEnabled(False)
+        
+        embedding_layout.addWidget(embedding_label)
+        embedding_layout.addWidget(self.embedding_model_label, 1)
+        embedding_layout.addWidget(self.configure_embedding_btn)
+        
         collection_layout.addWidget(self.collection_name_label)
         collection_layout.addWidget(self.vector_dim_label)
         collection_layout.addWidget(self.distance_metric_label)
         collection_layout.addWidget(self.total_points_label)
+        collection_layout.addWidget(embedding_row)
         
         # Payload Schema subsection
         schema_label = QLabel("<b>Payload Schema:</b>")
@@ -173,6 +201,15 @@ class InfoPanel(QWidget):
                 self._update_label(self.api_key_label, "Present (hidden)")
             else:
                 self._update_label(self.api_key_label, "Not configured")
+                
+        elif isinstance(self.connection, PineconeConnection):
+            self._update_label(self.connection_type_label, "Cloud")
+            self._update_label(self.endpoint_label, "Pinecone Cloud")
+            
+            if self.connection.api_key:
+                self._update_label(self.api_key_label, "Present (hidden)")
+            else:
+                self._update_label(self.api_key_label, "Not configured")
         else:
             self._update_label(self.connection_type_label, "Unknown")
             self._update_label(self.endpoint_label, "N/A")
@@ -200,7 +237,7 @@ class InfoPanel(QWidget):
             return
             
         try:
-            # Get collection info
+            # Get collection info from database
             collection_info = self.connection.get_collection_info(self.current_collection)
             
             if not collection_info:
@@ -212,59 +249,18 @@ class InfoPanel(QWidget):
                 self.provider_details_label.setText("N/A")
                 return
             
-            # Update basic info
-            self._update_label(self.collection_name_label, self.current_collection)
-            
-            # Vector dimension
-            vector_dim = collection_info.get("vector_dimension", "Unknown")
-            self._update_label(self.vector_dim_label, str(vector_dim))
-            
-            # Distance metric
-            distance = collection_info.get("distance_metric", "Unknown")
-            self._update_label(self.distance_metric_label, distance)
-            
-            # Total points
-            count = collection_info.get("count", 0)
-            self._update_label(self.total_points_label, f"{count:,}")
-            
-            # Metadata schema
-            metadata_fields = collection_info.get("metadata_fields", [])
-            if metadata_fields:
-                schema_text = "\n".join([f"• {field}" for field in sorted(metadata_fields)])
-                self.schema_label.setText(schema_text)
-                self.schema_label.setStyleSheet("color: white; padding-left: 20px; font-family: monospace;")
-            else:
-                self.schema_label.setText("No metadata fields found")
-                self.schema_label.setStyleSheet("color: gray; padding-left: 20px;")
-            
-            # Provider-specific details
-            details_list = []
-            
-            if isinstance(self.connection, ChromaDBConnection):
-                details_list.append("• Provider: ChromaDB")
-                details_list.append("• Supports: Documents, Metadata, Embeddings")
-                details_list.append("• Default embedding: all-MiniLM-L6-v2")
-                
-            elif isinstance(self.connection, QdrantConnection):
-                details_list.append("• Provider: Qdrant")
-                details_list.append("• Supports: Points, Payload, Vectors")
-                # Get additional Qdrant-specific info if available
-                if "config" in collection_info:
-                    config = collection_info["config"]
-                    if "hnsw_config" in config:
-                        hnsw = config["hnsw_config"]
-                        details_list.append(f"• HNSW M: {hnsw.get('m', 'N/A')}")
-                        details_list.append(f"• HNSW ef_construct: {hnsw.get('ef_construct', 'N/A')}")
-                    if "optimizer_config" in config:
-                        opt = config["optimizer_config"]
-                        details_list.append(f"• Indexing threshold: {opt.get('indexing_threshold', 'N/A')}")
+            # Display the info
+            self._display_collection_info(collection_info)
             
-            if details_list:
-                self.provider_details_label.setText("\n".join(details_list))
-                self.provider_details_label.setStyleSheet("color: white; padding-left: 20px; font-family: monospace;")
-            else:
-                self.provider_details_label.setText("No additional details available")
-                self.provider_details_label.setStyleSheet("color: gray; padding-left: 20px;")
+            # Save to cache
+            if self.current_database and self.current_collection:
+                print(f"[InfoPanel] Saving collection info to cache: db='{self.current_database}', coll='{self.current_collection}'")
+                self.cache_manager.update(
+                    self.current_database,
+                    self.current_collection,
+                    user_inputs={'collection_info': collection_info}
+                )
+                print(f"[InfoPanel] ✓ Saved collection info to cache.")
                 
         except Exception as e:
             self._update_label(self.collection_name_label, self.current_collection)
@@ -275,9 +271,101 @@ class InfoPanel(QWidget):
             self.schema_label.setStyleSheet("color: red; padding-left: 20px;")
             self.provider_details_label.setText("N/A")
     
-    def set_collection(self, collection_name: str):
+    def _display_collection_info(self, collection_info: Dict[str, Any]):
+        """Display collection information (from cache or fresh query)."""
+        # Update basic info
+        self._update_label(self.collection_name_label, self.current_collection)
+        
+        # Vector dimension
+        vector_dim = collection_info.get("vector_dimension", "Unknown")
+        self._update_label(self.vector_dim_label, str(vector_dim))
+        
+        # Enable configure button if we have a valid dimension
+        self.configure_embedding_btn.setEnabled(
+            vector_dim != "Unknown" and isinstance(vector_dim, int)
+        )
+        
+        # Update embedding model display
+        self._update_embedding_model_display(collection_info)
+        
+        # Distance metric
+        distance = collection_info.get("distance_metric", "Unknown")
+        self._update_label(self.distance_metric_label, distance)
+        
+        # Total points
+        count = collection_info.get("count", 0)
+        self._update_label(self.total_points_label, f"{count:,}")
+        
+        # Metadata schema
+        metadata_fields = collection_info.get("metadata_fields", [])
+        if metadata_fields:
+            schema_text = "\n".join([f"• {field}" for field in sorted(metadata_fields)])
+            self.schema_label.setText(schema_text)
+            self.schema_label.setStyleSheet("color: white; padding-left: 20px; font-family: monospace;")
+        else:
+            self.schema_label.setText("No metadata fields found")
+            self.schema_label.setStyleSheet("color: gray; padding-left: 20px;")
+        
+        # Provider-specific details
+        details_list = []
+        
+        if isinstance(self.connection, ChromaDBConnection):
+            details_list.append("• Provider: ChromaDB")
+            details_list.append("• Supports: Documents, Metadata, Embeddings")
+            details_list.append("• Default embedding: all-MiniLM-L6-v2")
+            
+        elif isinstance(self.connection, QdrantConnection):
+            details_list.append("• Provider: Qdrant")
+            details_list.append("• Supports: Points, Payload, Vectors")
+            # Get additional Qdrant-specific info if available
+            if "config" in collection_info:
+                config = collection_info["config"]
+                if "hnsw_config" in config:
+                    hnsw = config["hnsw_config"]
+                    details_list.append(f"• HNSW M: {hnsw.get('m', 'N/A')}")
+                    details_list.append(f"• HNSW ef_construct: {hnsw.get('ef_construct', 'N/A')}")
+                if "optimizer_config" in config:
+                    opt = config["optimizer_config"]
+                    details_list.append(f"• Indexing threshold: {opt.get('indexing_threshold', 'N/A')}")
+        
+        elif isinstance(self.connection, PineconeConnection):
+            details_list.append("• Provider: Pinecone")
+            details_list.append("• Supports: Vectors, Metadata")
+            details_list.append("• Cloud-hosted vector database")
+            # Add Pinecone-specific info if available
+            if "host" in collection_info:
+                details_list.append(f"• Host: {collection_info['host']}")
+            if "status" in collection_info:
+                details_list.append(f"• Status: {collection_info['status']}")
+            if "spec" in collection_info:
+                details_list.append(f"• Spec: {collection_info['spec']}")
+        
+        if details_list:
+            self.provider_details_label.setText("\n".join(details_list))
+            self.provider_details_label.setStyleSheet("color: white; padding-left: 20px; font-family: monospace;")
+        else:
+            self.provider_details_label.setText("No additional details available")
+            self.provider_details_label.setStyleSheet("color: gray; padding-left: 20px;")
+    
+    def set_collection(self, collection_name: str, database_name: str = ""):
         """Set the current collection and refresh its information."""
         self.current_collection = collection_name
+        # Always update database_name if provided
+        if database_name:
+            self.current_database = database_name
+            self.connection_id = database_name  # database_name is the connection ID
+        
+        print(f"[InfoPanel] Setting collection: db='{self.current_database}', coll='{collection_name}'")
+        
+        # Check cache first for collection info
+        cached = self.cache_manager.get(self.current_database, self.current_collection)
+        if cached and hasattr(cached, 'user_inputs') and cached.user_inputs.get('collection_info'):
+            print(f"[InfoPanel] ✓ Cache HIT! Loading collection info from cache.")
+            collection_info = cached.user_inputs['collection_info']
+            self._display_collection_info(collection_info)
+            return
+        
+        print(f"[InfoPanel] ✗ Cache MISS. Loading collection info from database...")
         self.refresh_collection_info()
     
     def _update_label(self, row_widget: QWidget, value: str):
@@ -285,3 +373,132 @@ class InfoPanel(QWidget):
         value_label = row_widget.property("value_label")
         if value_label and isinstance(value_label, QLabel):
             value_label.setText(value)
+    
+    def _update_embedding_model_display(self, collection_info: Dict[str, Any]):
+        """Update the embedding model label based on current configuration."""
+        from ...services.settings_service import SettingsService
+        
+        # Check if stored in collection metadata
+        if 'embedding_model' in collection_info:
+            model_name = collection_info['embedding_model']
+            model_type = collection_info.get('embedding_model_type', 'stored')
+            self.embedding_model_label.setText(f"{model_name} ({model_type})")
+            self.embedding_model_label.setStyleSheet("color: lightgreen;")
+            return
+        
+        # Try to get from connection using the helper method
+        if self.connection and self.current_collection:
+            detected_model = self.connection.get_embedding_model(self.current_collection, self.connection_id)
+            if detected_model:
+                self.embedding_model_label.setText(f"{detected_model} (detected)")
+                self.embedding_model_label.setStyleSheet("color: lightgreen;")
+                return
+        
+        # Check user settings
+        settings = SettingsService()
+        model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+        
+        if model_info:
+            model_name = model_info['model']
+            model_type = model_info.get('type', 'unknown')
+            self.embedding_model_label.setText(f"{model_name} ({model_type})")
+            self.embedding_model_label.setStyleSheet("color: lightblue;")
+            return
+        
+        # No configuration - using auto-detect
+        self.embedding_model_label.setText("Auto-detect (dimension-based)")
+        self.embedding_model_label.setStyleSheet("color: orange;")
+    
+    def _configure_embedding_model(self):
+        """Open dialog to configure embedding model for current collection."""
+        if not self.current_collection:
+            return
+        
+        # Show loading immediately; preparing can touch DB/registry
+        from ..components.loading_dialog import LoadingDialog
+        loading = LoadingDialog("Preparing model configuration...", self)
+        loading.show_loading("Preparing model configuration...")
+        QApplication.processEvents()
+
+        from ..dialogs import ProviderTypeDialog, EmbeddingConfigDialog
+        from ...services.settings_service import SettingsService
+        
+        # Get current collection info
+        try:
+            collection_info = self.connection.get_collection_info(self.current_collection)
+        finally:
+            # Hide loading before presenting dialogs
+            loading.hide_loading()
+        if not collection_info:
+            return
+        
+        vector_dim = collection_info.get("vector_dimension")
+        if not vector_dim or vector_dim == "Unknown":
+            return
+        
+        # Get current configuration if any
+        settings = SettingsService()
+        
+        current_model = None
+        current_type = None
+        
+        # Check metadata first
+        if 'embedding_model' in collection_info:
+            current_model = collection_info['embedding_model']
+            current_type = collection_info.get('embedding_model_type', 'stored')
+        # Then check settings
+        else:
+            model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+            if model_info:
+                current_model = model_info.get('model')
+                current_type = model_info.get('type')
+        
+        # Step 1: Provider Type Selection
+        type_dialog = ProviderTypeDialog(
+            self.current_collection,
+            vector_dim,
+            self
+        )
+        
+        type_result = type_dialog.exec()
+        if type_result != QDialog.DialogCode.Accepted:
+            return  # User cancelled
+        
+        provider_type = type_dialog.get_selected_type()
+        if not provider_type:
+            return
+        
+        # Step 2: Model Selection (filtered by provider type)
+        model_dialog = EmbeddingConfigDialog(
+            self.current_collection,
+            vector_dim,
+            provider_type,
+            current_model,
+            current_type,
+            self
+        )
+        
+        # Optionally show brief loading while populating models
+        # (dialog itself handles content; only show if provider lists are large)
+        result = model_dialog.exec()
+        
+        if result == QDialog.DialogCode.Accepted:
+            # Save the configuration using the new SettingsService method
+            selection = model_dialog.get_selection()
+            if selection:
+                model_name, model_type = selection
+                settings.save_embedding_model(self.connection_id, self.current_collection, model_name, model_type)
+                
+                # Refresh display
+                self._update_embedding_model_display(collection_info)
+                
+                print(f"✓ Configured embedding model for '{self.current_collection}': {model_name} ({model_type})")
+                
+        elif result == 2:  # Clear configuration
+            # Remove from settings using the new SettingsService method
+            settings.remove_embedding_model(self.connection_id, self.current_collection)
+            
+            # Refresh display
+            self._update_embedding_model_display(collection_info)
+            
+            print(f"✓ Cleared embedding model configuration for '{self.current_collection}'")

vector_inspector/ui/views/metadata_view.py

@@ -16,6 +16,7 @@ from vector_inspector.ui.components.filter_builder import FilterBuilder
 from vector_inspector.services.import_export_service import ImportExportService
 from vector_inspector.services.filter_service import apply_client_side_filters
 from vector_inspector.services.settings_service import SettingsService
+from vector_inspector.core.cache_manager import get_cache_manager, CacheEntry
 from PySide6.QtWidgets import QApplication
 
 
@@ -57,12 +58,14 @@ class MetadataView(QWidget):
         super().__init__(parent)
         self.connection = connection
         self.current_collection: str = ""
+        self.current_database: str = ""
         self.current_data: Optional[Dict[str, Any]] = None
         self.page_size = 50
         self.current_page = 0
         self.loading_dialog = LoadingDialog("Loading data...", self)
         self.settings_service = SettingsService()
         self.load_thread: Optional[DataLoadThread] = None
+        self.cache_manager = get_cache_manager()
         
         # Debounce timer for filter changes
         self.filter_reload_timer = QTimer()
@@ -107,8 +110,9 @@ class MetadataView(QWidget):
         controls_layout.addStretch()
         
         # Refresh button
-        self.refresh_button = QPushButton("Refresh")
-        self.refresh_button.clicked.connect(self._load_data)
+        self.refresh_button = QPushButton("🔄 Refresh")
+        self.refresh_button.clicked.connect(self._refresh_data)
+        self.refresh_button.setToolTip("Refresh data and clear cache")
         controls_layout.addWidget(self.refresh_button)
         
         # Add/Delete buttons
@@ -172,9 +176,40 @@ class MetadataView(QWidget):
         self.status_label.setStyleSheet("color: gray;")
         layout.addWidget(self.status_label)
         
-    def set_collection(self, collection_name: str):
+    def set_collection(self, collection_name: str, database_name: str = ""):
         """Set the current collection to display."""
         self.current_collection = collection_name
+        # Always update database_name if provided (even if empty string on first call)
+        if database_name:  # Only update if non-empty
+            self.current_database = database_name
+        
+        # Debug: Check cache status
+        print(f"[MetadataView] Setting collection: db='{self.current_database}', coll='{collection_name}'")
+        print(f"[MetadataView] Cache enabled: {self.cache_manager.is_enabled()}")
+        
+        # Check cache first
+        cached = self.cache_manager.get(self.current_database, self.current_collection)
+        if cached and cached.data:
+            print(f"[MetadataView] ✓ Cache HIT! Loading from cache.")
+            # Restore from cache
+            self.current_page = 0
+            self.current_data = cached.data
+            self._populate_table(cached.data)
+            self._update_pagination_controls()
+            self._update_filter_fields(cached.data)
+            
+            # Restore UI state
+            if cached.scroll_position:
+                self.table.verticalScrollBar().setValue(cached.scroll_position)
+            if cached.search_query:
+                # Restore filter state if applicable
+                pass
+            
+            self.status_label.setText(f"✓ Loaded from cache - {len(cached.data.get('ids', []))} items")
+            return
+        
+        print(f"[MetadataView] ✗ Cache MISS. Loading from database...")
+        # Not in cache, load from database
         self.current_page = 0
         
         # Update filter builder with supported operators
@@ -246,6 +281,19 @@ class MetadataView(QWidget):
         
         # Update filter builder with available metadata fields
         self._update_filter_fields(data)
+        
+        # Save to cache
+        if self.current_database and self.current_collection:
+            print(f"[MetadataView] Saving to cache: db='{self.current_database}', coll='{self.current_collection}'")
+            cache_entry = CacheEntry(
+                data=data,
+                scroll_position=self.table.verticalScrollBar().value(),
+                search_query=self.filter_builder.to_dict() if hasattr(self.filter_builder, 'to_dict') else ""
+            )
+            self.cache_manager.set(self.current_database, self.current_collection, cache_entry)
+            print(f"[MetadataView] ✓ Saved to cache. Total entries: {len(self.cache_manager._cache)}")
+        else:
+            print(f"[MetadataView] ✗ NOT saving to cache - db='{self.current_database}', coll='{self.current_collection}'")
     
     def _on_load_error(self, error_msg: str):
         """Handle error from background thread."""
@@ -365,6 +413,9 @@ class MetadataView(QWidget):
             )
             
             if success:
+                # Invalidate cache after adding item
+                if self.current_database and self.current_collection:
+                    self.cache_manager.invalidate(self.current_database, self.current_collection)
                 QMessageBox.information(self, "Success", "Item added successfully.")
                 self._load_data()
             else:
@@ -399,6 +450,9 @@ class MetadataView(QWidget):
         if reply == QMessageBox.Yes:
             success = self.connection.delete_items(self.current_collection, ids=ids_to_delete)
             if success:
+                # Invalidate cache after deletion
+                if self.current_database and self.current_collection:
+                    self.cache_manager.invalidate(self.current_database, self.current_collection)
                 QMessageBox.information(self, "Success", "Items deleted successfully.")
                 self._load_data()
             else:
@@ -422,6 +476,13 @@ class MetadataView(QWidget):
             self.current_page = 0
             self._load_data()
     
+    def _refresh_data(self):
+        """Refresh data and invalidate cache."""
+        if self.current_database and self.current_collection:
+            self.cache_manager.invalidate(self.current_database, self.current_collection)
+        self.current_page = 0
+        self._load_data()
+    
     def _on_row_double_clicked(self, index):
         """Handle double-click on a row to edit item."""
         if not self.current_collection or not self.current_data:
@@ -462,6 +523,9 @@ class MetadataView(QWidget):
             )
             
             if success:
+                # Invalidate cache after updating item
+                if self.current_database and self.current_collection:
+                    self.cache_manager.invalidate(self.current_database, self.current_collection)
                 QMessageBox.information(self, "Success", "Item updated successfully.")
                 self._load_data()
             else:
@@ -653,6 +717,10 @@ class MetadataView(QWidget):
             self.loading_dialog.hide_loading()
             
         if success:
+            # Invalidate cache after import
+            if self.current_database and self.current_collection:
+                self.cache_manager.invalidate(self.current_database, self.current_collection)
+            
             # Save the directory for next time
             from pathlib import Path
             self.settings_service.set("last_import_export_dir", str(Path(file_path).parent))