vector-inspector 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

vector_inspector/ui/views/info_panel.py

@@ -1,33 +1,34 @@
 """Information panel for displaying database and collection metadata."""
 
-from typing import Optional, Dict, Any
+from typing import Any, Optional
+
+from PySide6.QtCore import Qt
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
+    QApplication,
+    QDialog,
+    QGroupBox,
     QHBoxLayout,
     QLabel,
-    QGroupBox,
-    QScrollArea,
-    QFrame,
     QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
 )
-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.cache_manager import get_cache_manager
+from vector_inspector.core.connection_manager import ConnectionInstance
 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
+from vector_inspector.core.connections.qdrant_connection import QdrantConnection
 from vector_inspector.core.logging import log_info
 
 
 class InfoPanel(QWidget):
     """Panel for displaying database and collection information."""
 
-    def __init__(self, connection: VectorDBConnection, parent=None):
+    def __init__(self, connection: Optional[ConnectionInstance] = None, parent=None):
         super().__init__(parent)
+        # Expects a ConnectionInstance wrapper.
         self.connection = connection
         self.connection_id: str = ""  # Will be set when collection is set
         self.current_collection: str = ""
@@ -149,8 +150,29 @@ class InfoPanel(QWidget):
         """Clear the embedding model configuration for this collection (reset to autodetect)."""
         from vector_inspector.services.settings_service import SettingsService
 
+        # Ensure we have a valid connection_id
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
+        if not effective_connection_id:
+            log_info("Cannot clear embedding model: no connection_id available")
+            return
+
         settings = SettingsService()
-        settings.remove_embedding_model(self.connection_id, self.current_collection)
+        settings.remove_embedding_model(
+            self.connection.name if self.connection else "",
+            self.current_collection,
+        )
+
+        # Clear cache to ensure fresh collection info on next load
+        if effective_connection_id and self.current_collection:
+            self.cache_manager.invalidate(effective_connection_id, self.current_collection)
+            log_info(
+                "Cleared cache for collection after clearing embedding model: %s",
+                self.current_collection,
+            )
+
         # Refresh display (force reload collection info)
         if self.current_collection:
             self.set_collection(self.current_collection, self.current_database)
@@ -163,13 +185,21 @@ class InfoPanel(QWidget):
         """Update the clear button state based on current configuration."""
         from vector_inspector.services.settings_service import SettingsService
 
-        if not self.connection_id or not self.current_collection:
+        # Ensure we have valid identifiers
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
+        if not effective_connection_id or not self.current_collection:
             self.clear_embedding_btn.setEnabled(False)
             return
 
         # Check if there's a user-configured model in settings
         settings = SettingsService()
-        model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+        model_info = settings.get_embedding_model(
+            self.connection.name if self.connection else "",
+            self.current_collection,
+        )
 
         # Enable button if there's a user-configured model
         self.clear_embedding_btn.setEnabled(model_info is not None)
@@ -213,50 +243,48 @@ class InfoPanel(QWidget):
             return
 
         # Get provider name
-        provider_name = self.connection.__class__.__name__.replace("Connection", "")
+        # Extract the underlying database connection from ConnectionInstance wrapper.
+        backend = getattr(self.connection, "database", self.connection)
+        provider_name = (
+            backend.__class__.__name__.replace("Connection", "") if backend else "Unknown"
+        )
         self._update_label(self.provider_label, provider_name)
 
         # Get connection details
-        if isinstance(self.connection, ChromaDBConnection):
-            if self.connection.path:
+        if isinstance(backend, ChromaDBConnection):
+            if getattr(backend, "path", None):
                 self._update_label(self.connection_type_label, "Persistent (Local)")
-                self._update_label(self.endpoint_label, self.connection.path)
-            elif self.connection.host and self.connection.port:
+                self._update_label(self.endpoint_label, backend.path)
+            elif getattr(backend, "host", None) and getattr(backend, "port", None):
                 self._update_label(self.connection_type_label, "HTTP (Remote)")
-                self._update_label(
-                    self.endpoint_label, f"{self.connection.host}:{self.connection.port}"
-                )
+                self._update_label(self.endpoint_label, f"{backend.host}:{backend.port}")
             else:
                 self._update_label(self.connection_type_label, "Ephemeral (In-Memory)")
                 self._update_label(self.endpoint_label, "N/A")
             self._update_label(self.api_key_label, "Not required")
-
-        elif isinstance(self.connection, QdrantConnection):
-            if self.connection.path:
+        elif isinstance(backend, QdrantConnection):
+            if getattr(backend, "path", None):
                 self._update_label(self.connection_type_label, "Embedded (Local)")
-                self._update_label(self.endpoint_label, self.connection.path)
-            elif self.connection.url:
+                self._update_label(self.endpoint_label, backend.path)
+            elif getattr(backend, "url", None):
                 self._update_label(self.connection_type_label, "Remote (URL)")
-                self._update_label(self.endpoint_label, self.connection.url)
-            elif self.connection.host:
+                self._update_label(self.endpoint_label, backend.url)
+            elif getattr(backend, "host", None):
                 self._update_label(self.connection_type_label, "Remote (Host)")
-                self._update_label(
-                    self.endpoint_label, f"{self.connection.host}:{self.connection.port}"
-                )
+                self._update_label(self.endpoint_label, f"{backend.host}:{backend.port}")
             else:
                 self._update_label(self.connection_type_label, "In-Memory")
                 self._update_label(self.endpoint_label, "N/A")
-
-            if self.connection.api_key:
+            if getattr(backend, "api_key", None):
                 self._update_label(self.api_key_label, "Present (hidden)")
             else:
                 self._update_label(self.api_key_label, "Not configured")
 
-        elif isinstance(self.connection, PineconeConnection):
+        elif isinstance(backend, PineconeConnection):
+            # backend already assigned above
             self._update_label(self.connection_type_label, "Cloud")
             self._update_label(self.endpoint_label, "Pinecone Cloud")
-
-            if self.connection.api_key:
+            if getattr(backend, "api_key", None):
                 self._update_label(self.api_key_label, "Present (hidden)")
             else:
                 self._update_label(self.api_key_label, "Not configured")
@@ -274,7 +302,7 @@ class InfoPanel(QWidget):
         try:
             collections = self.connection.list_collections()
             self._update_label(self.collections_count_label, str(len(collections)))
-        except Exception as e:
+        except Exception:
             self._update_label(self.collections_count_label, "Error")
 
     def refresh_collection_info(self):
@@ -323,11 +351,11 @@ class InfoPanel(QWidget):
             self._update_label(self.vector_dim_label, "Error")
             self._update_label(self.distance_metric_label, "Error")
             self._update_label(self.total_points_label, "Error")
-            self.schema_label.setText(f"Error: {str(e)}")
+            self.schema_label.setText(f"Error: {e!s}")
             self.schema_label.setStyleSheet("color: red; padding-left: 20px;")
             self.provider_details_label.setText("N/A")
 
-    def _display_collection_info(self, collection_info: Dict[str, Any]):
+    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)
@@ -395,6 +423,11 @@ class InfoPanel(QWidget):
             details_list.append("• Provider: Pinecone")
             details_list.append("• Supports: Vectors, Metadata")
             details_list.append("• Cloud-hosted vector database")
+            # Check if using Pinecone-hosted embedding model
+            if collection_info.get("embedding_model_type") == "pinecone-hosted":
+                hosted_model = collection_info.get("embedding_model", "Unknown")
+                details_list.append(f"• Hosted Model: {hosted_model}")
+                details_list.append("• Supports text-based queries (no local embedding needed)")
             # Add Pinecone-specific info if available
             if "host" in collection_info:
                 details_list.append(f"• Host: {collection_info['host']}")
@@ -443,7 +476,7 @@ class InfoPanel(QWidget):
         if value_label and isinstance(value_label, QLabel):
             value_label.setText(value)
 
-    def _update_embedding_model_display(self, collection_info: Dict[str, Any]):
+    def _update_embedding_model_display(self, collection_info: dict[str, Any]):
         """Update the embedding model label based on current configuration."""
         from vector_inspector.services.settings_service import SettingsService
 
@@ -459,20 +492,28 @@ class InfoPanel(QWidget):
             self.clear_embedding_btn.setEnabled(True)
             return
 
+        # Ensure we have a valid connection_id for settings lookup
+        # Fallback to connection.id if connection_id not set
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
         # 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
-            )
+            detected_model = self.connection.get_embedding_model(self.current_collection)
             if detected_model:
                 self.embedding_model_label.setText(f"{detected_model} (detected)")
                 self.embedding_model_label.setStyleSheet("color: lightgreen;")
                 self.clear_embedding_btn.setEnabled(False)
                 return
 
-        # Check user settings
+        # Check user settings directly
         settings = SettingsService()
-        model_info = settings.get_embedding_model(self.connection_id, self.current_collection)
+        profile_name = self.connection.name if self.connection else ""
+        model_info = settings.get_embedding_model(
+            profile_name,
+            self.current_collection,
+        )
 
         if model_info:
             model_name = model_info["model"]
@@ -492,6 +533,14 @@ class InfoPanel(QWidget):
         if not self.current_collection:
             return
 
+        # Ensure we have a valid connection_id
+        effective_connection_id = self.connection_id or (
+            self.connection.id if self.connection else None
+        )
+
+        if not effective_connection_id:
+            return
+
         # Show loading immediately; preparing can touch DB/registry
         from vector_inspector.ui.components.loading_dialog import LoadingDialog
 
@@ -499,8 +548,8 @@ class InfoPanel(QWidget):
         loading.show_loading("Preparing model configuration...")
         QApplication.processEvents()
 
-        from vector_inspector.ui.dialogs import ProviderTypeDialog, EmbeddingConfigDialog
         from vector_inspector.services.settings_service import SettingsService
+        from vector_inspector.ui.dialogs import EmbeddingConfigDialog, ProviderTypeDialog
 
         # Get current collection info
         try:
@@ -527,7 +576,10 @@ class InfoPanel(QWidget):
             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)
+            model_info = settings.get_embedding_model(
+                self.connection.name if self.connection else "",
+                self.current_collection,
+            )
             if model_info:
                 current_model = model_info.get("model")
                 current_type = model_info.get("type")
@@ -558,9 +610,20 @@ class InfoPanel(QWidget):
             if selection:
                 model_name, model_type = selection
                 settings.save_embedding_model(
-                    self.connection_id, self.current_collection, model_name, model_type
+                    self.connection.name if self.connection else "",
+                    self.current_collection,
+                    model_name,
+                    model_type,
                 )
 
+                # Clear cache to ensure fresh collection info on next load
+                if effective_connection_id and self.current_collection:
+                    self.cache_manager.invalidate(effective_connection_id, self.current_collection)
+                    log_info(
+                        "Cleared cache for collection after configuring embedding model: %s",
+                        self.current_collection,
+                    )
+
                 # Update the display immediately to show new model
                 self.embedding_model_label.setText(f"{model_name} ({model_type})")
                 self.embedding_model_label.setStyleSheet("color: lightblue;")
@@ -577,7 +640,10 @@ class InfoPanel(QWidget):
 
         elif result == 2:  # Clear configuration
             # Remove from settings using the new SettingsService method
-            settings.remove_embedding_model(self.connection_id, self.current_collection)
+            settings.remove_embedding_model(
+                self.connection.name if self.connection else "",
+                self.current_collection,
+            )
 
             # Refresh display
             self._update_embedding_model_display(collection_info)

vector_inspector/ui/views/metadata_view.py

@@ -1,38 +1,36 @@
 """Metadata browsing and data view."""
 
-from typing import Optional, Dict, Any, List
+import math
+from typing import Any, Optional
+
+from PySide6.QtCore import Qt, QThread, QTimer, Signal
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QTableWidget,
-    QTableWidgetItem,
-    QPushButton,
+    QApplication,
     QCheckBox,
-    QLabel,
-    QSpinBox,
-    QLineEdit,
-    QComboBox,
-    QGroupBox,
-    QHeaderView,
-    QMessageBox,
     QDialog,
     QFileDialog,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
     QMenu,
+    QMessageBox,
+    QPushButton,
+    QSpinBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
 )
-from PySide6.QtCore import Qt, QTimer, QThread, Signal
-import math
 
-from vector_inspector.core.connections.base_connection import VectorDBConnection
-from vector_inspector.ui.components.item_dialog import ItemDialog
-from vector_inspector.ui.components.loading_dialog import LoadingDialog
-from vector_inspector.ui.components.filter_builder import FilterBuilder
-from vector_inspector.services.import_export_service import ImportExportService
+from vector_inspector.core.cache_manager import CacheEntry, get_cache_manager
+from vector_inspector.core.connection_manager import ConnectionInstance
+from vector_inspector.core.logging import log_info
 from vector_inspector.services.filter_service import apply_client_side_filters
+from vector_inspector.services.import_export_service import ImportExportService
 from vector_inspector.services.settings_service import SettingsService
-from vector_inspector.core.cache_manager import get_cache_manager, CacheEntry
-from PySide6.QtWidgets import QApplication
-from vector_inspector.core.logging import log_info
+from vector_inspector.ui.components.filter_builder import FilterBuilder
+from vector_inspector.ui.components.item_dialog import ItemDialog
+from vector_inspector.ui.components.loading_dialog import LoadingDialog
 
 
 class DataLoadThread(QThread):
@@ -66,12 +64,13 @@ class DataLoadThread(QThread):
 class MetadataView(QWidget):
     """View for browsing collection data and metadata."""
 
-    def __init__(self, connection: VectorDBConnection, parent=None):
+    def __init__(self, connection: Optional[ConnectionInstance] = None, parent=None):
         super().__init__(parent)
+        # Expects a ConnectionInstance wrapper.
         self.connection = connection
         self.current_collection: str = ""
         self.current_database: str = ""
-        self.current_data: Optional[Dict[str, Any]] = None
+        self.current_data: Optional[dict[str, Any]] = None
         self.page_size = 50
         self.current_page = 0
         self.loading_dialog = LoadingDialog("Loading data...", self)
@@ -308,7 +307,7 @@ class MetadataView(QWidget):
         self.load_thread.error.connect(self._on_load_error)
         self.load_thread.start()
 
-    def _on_data_loaded(self, data: Dict[str, Any]):
+    def _on_data_loaded(self, data: dict[str, Any]):
         """Handle data loaded from background thread."""
         # If no data returned
         if not data:
@@ -358,7 +357,7 @@ class MetadataView(QWidget):
                     data=full_data,
                     scroll_position=self.table.verticalScrollBar().value(),
                     search_query=(
-                        getattr(self.filter_builder, "to_dict")()
+                        self.filter_builder.to_dict()
                         if callable(getattr(self.filter_builder, "to_dict", None))
                         else ""
                     ),
@@ -401,7 +400,7 @@ class MetadataView(QWidget):
                 data=data,
                 scroll_position=self.table.verticalScrollBar().value(),
                 search_query=(
-                    getattr(self.filter_builder, "to_dict")()
+                    self.filter_builder.to_dict()
                     if callable(getattr(self.filter_builder, "to_dict", None))
                     else ""
                 ),
@@ -422,7 +421,7 @@ class MetadataView(QWidget):
         self.status_label.setText(f"Failed to load data: {error_msg}")
         self.table.setRowCount(0)
 
-    def _update_filter_fields(self, data: Dict[str, Any]):
+    def _update_filter_fields(self, data: dict[str, Any]):
         """Update filter builder with available metadata field names."""
         field_names = []
 
@@ -441,7 +440,7 @@ class MetadataView(QWidget):
         if field_names:
             self.filter_builder.set_available_fields(field_names)
 
-    def _populate_table(self, data: Dict[str, Any]):
+    def _populate_table(self, data: dict[str, Any]):
         """Populate table with data."""
         ids = data.get("ids", [])
         documents = data.get("documents", [])

vector_inspector/ui/views/search_view.py

@@ -1,38 +1,38 @@
 """Search interface for similarity queries."""
 
-from typing import Optional, Dict, Any
+from typing import Any, Optional
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFontMetrics
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
+    QApplication,
+    QGroupBox,
     QHBoxLayout,
-    QTextEdit,
-    QPushButton,
     QLabel,
+    QMenu,
+    QPushButton,
     QSizePolicy,
     QSpinBox,
+    QSplitter,
     QTableWidget,
     QTableWidgetItem,
-    QGroupBox,
-    QSplitter,
-    QCheckBox,
-    QApplication,
-    QMenu,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
 )
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QFontMetrics
 
-from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.cache_manager import get_cache_manager
+from vector_inspector.core.connection_manager import ConnectionInstance
+from vector_inspector.core.logging import log_info
+from vector_inspector.services.filter_service import apply_client_side_filters
 from vector_inspector.ui.components.filter_builder import FilterBuilder
 from vector_inspector.ui.components.loading_dialog import LoadingDialog
-from vector_inspector.services.filter_service import apply_client_side_filters
-from vector_inspector.core.cache_manager import get_cache_manager, CacheEntry
-from vector_inspector.core.logging import log_info
 
 
 class SearchView(QWidget):
     """View for performing similarity searches."""
 
-    def __init__(self, connection: VectorDBConnection, parent=None):
+    def __init__(self, connection: Optional[ConnectionInstance] = None, parent=None):
         super().__init__(parent)
         # Initialize all UI attributes to None to avoid AttributeError
         self.breadcrumb_label = None
@@ -47,10 +47,11 @@ class SearchView(QWidget):
         self.loading_dialog = None
         self.cache_manager = None
 
+        # Expects a ConnectionInstance wrapper.
         self.connection = connection
         self.current_collection: str = ""
         self.current_database: str = ""
-        self.search_results: Optional[Dict[str, Any]] = None
+        self.search_results: Optional[dict[str, Any]] = None
         self.loading_dialog = LoadingDialog("Searching...", self)
         self.cache_manager = get_cache_manager()
 
@@ -414,7 +415,7 @@ class SearchView(QWidget):
         if not menu.isEmpty():
             menu.exec(self.results_table.viewport().mapToGlobal(position))
 
-    def _display_results(self, results: Dict[str, Any]):
+    def _display_results(self, results: dict[str, Any]):
         """Display search results in table."""
         ids = results.get("ids", [[]])[0]
         documents = results.get("documents", [[]])[0]

vector_inspector/ui/views/visualization_view.py

@@ -1,28 +1,30 @@
 """Vector visualization view with dimensionality reduction."""
 
 from __future__ import annotations
-from typing import Any
+
 import traceback
+from typing import Any, Optional
+
+import numpy as np
+from PySide6.QtCore import QThread, Signal
+from PySide6.QtWebEngineWidgets import QWebEngineView
 from PySide6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QPushButton,
-    QLabel,
+    QApplication,
     QComboBox,
-    QSpinBox,
     QGroupBox,
+    QHBoxLayout,
+    QLabel,
     QMessageBox,
-    QApplication,
+    QPushButton,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
 )
-from PySide6.QtCore import QThread, Signal
-from PySide6.QtWebEngineWidgets import QWebEngineView
-import numpy as np
 
-from vector_inspector.core.connections.base_connection import VectorDBConnection
+from vector_inspector.core.connection_manager import ConnectionInstance
+from vector_inspector.core.logging import log_error
 from vector_inspector.services.visualization_service import VisualizationService
 from vector_inspector.ui.components.loading_dialog import LoadingDialog
-from vector_inspector.core.logging import log_error
 
 
 class VisualizationThread(QThread):
@@ -55,8 +57,9 @@ class VisualizationThread(QThread):
 class VisualizationView(QWidget):
     """View for visualizing vectors in 2D/3D."""
 
-    def __init__(self, connection: VectorDBConnection, parent=None):
+    def __init__(self, connection: Optional[ConnectionInstance] = None, parent=None):
         super().__init__(parent)
+        # Expects a ConnectionInstance wrapper.
         self.connection = connection
         self.current_collection: str = ""
         self.current_data: dict[str, Any] | None = None
@@ -296,8 +299,8 @@ class VisualizationView(QWidget):
             webbrowser.open(f"file://{self._last_temp_html}")
 
     def cleanup_temp_html(self):
-        import os
         import contextlib
+        import os
 
         for f in getattr(self, "temp_html_files", []):
             with contextlib.suppress(Exception):

{vector_inspector-0.3.11.dist-info → vector_inspector-0.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vector-inspector
-Version: 0.3.11
+Version: 0.3.12
 Summary: A comprehensive desktop application for visualizing, querying, and managing vector database data
 Author-Email: Anthony Dawson <anthonypdawson+github@gmail.com>
 License: MIT
@@ -26,14 +26,19 @@ Requires-Dist: keyring>=25.7.0
 Requires-Dist: hf-xet>=1.2.0
 Requires-Dist: pymilvus>=2.6.6
 Requires-Dist: lancedb>=0.27.0
-Requires-Dist: psycopg2>=2.9.11
+Requires-Dist: psycopg2-binary>=2.9.11
 Requires-Dist: pgvector>=0.4.2
 Description-Content-Type: text/markdown
 
 # Latest updates
 
-- Added optional telemetry opt-in in settings panel (File -> Preferences -> Telemetry). See docs/telemetry/model_telemetry_and_registry.md and docs/telemetry/unified_telemetry_architecture.md for details.
-  - Currently only 'launch' telemetry is sent. Model registry telemetry will be added later.
+## Pinecone Hosted Model Support Improvements
+  - Direct Text Search: Added full support for Pinecone indexes with integrated (hosted) embedding models. You can now perform semantic search using plain text queries—no local embedding required.
+  - Accurate Model Detection: The app now detects and displays the hosted model name (e.g., llama-text-embed-v2) in the info panel for Pinecone indexes.
+  - Robust Query Handling: The search logic now uses Pinecone’s search() API for hosted models, with correct response parsing and error handling.
+  - Future-Proof: Retained the ability to generate embeddings via Pinecone’s inference API for future features or advanced workflows.
+  - Improved Error Handling: Added better checks and debug logging for Pinecone API responses.
+  - These changes make Pinecone integration seamless and future-ready for both text and vector search scenarios.
 ---
 
 # Vector Inspector
@@ -49,6 +54,14 @@ Description-Content-Type: text/markdown
 
 A comprehensive desktop application for visualizing, querying, and managing vector database data. Similar to SQL database viewers, Vector Inspector provides an intuitive GUI for exploring vector embeddings, metadata, and performing similarity searches across multiple vector database providers.
 
+<p align="center">
+  <a href="site/images/demo.gif" target="_blank">
+    <img src="site/images/demo.gif" alt="Vector Inspector Demo" width="600"/>
+  </a>
+</p>
+
+**Quick Demo:** See Vector Inspector in action!
+
 ## Overview
 
 Vector Inspector bridges the gap between vector databases and user-friendly data exploration tools. While vector databases are powerful for semantic search and AI applications, they often lack the intuitive inspection and management tools that traditional SQL databases have. This project aims to provide that missing layer.