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

vector_inspector/core/connections/base_connection.py

@@ -261,7 +261,7 @@ class VectorDBConnection(ABC):
 
             # Finally, check user settings (for collections we can't modify)
             if connection_id:
-                from ...services.settings_service import SettingsService
+                from vector_inspector.services.settings_service import SettingsService
 
                 settings = SettingsService()
                 model_info = settings.get_embedding_model(connection_id, collection_name)
@@ -272,3 +272,88 @@ class VectorDBConnection(ABC):
         except Exception as e:
             log_error("Failed to get embedding model: %s", e)
             return None
+
+    def load_embedding_model_for_collection(
+        self, collection_name: str, connection_id: Optional[str] = None
+    ):
+        """
+        Resolve and load an embedding model for a collection.
+
+        Resolution order:
+        1. User settings (SettingsService)
+        2. Collection metadata (get_collection_info)
+        3. Dimension-based registry (embedding_utils.get_embedding_model_for_dimension)
+        4. DEFAULT_MODEL
+
+        Returns:
+            (loaded_model, model_name, model_type)
+        """
+        try:
+            from vector_inspector.services.settings_service import SettingsService
+            from vector_inspector.core.embedding_utils import (
+                load_embedding_model,
+                get_embedding_model_for_dimension,
+                DEFAULT_MODEL,
+            )
+
+            # 1) settings
+            if connection_id:
+                settings = SettingsService()
+                cfg = settings.get_embedding_model(connection_id, collection_name)
+                if cfg and cfg.get("model"):
+                    model_name = cfg.get("model")
+                    model_type = cfg.get("type", "sentence-transformer")
+                    model = load_embedding_model(model_name, model_type)
+                    return (model, model_name, model_type)
+
+            # 2) collection metadata
+            try:
+                info = self.get_collection_info(collection_name)
+            except Exception:
+                info = None
+
+            if info and info.get("embedding_model"):
+                model_name = info.get("embedding_model")
+                model_type = info.get("embedding_model_type", "sentence-transformer")
+                model = load_embedding_model(model_name, model_type)
+                return (model, model_name, model_type)
+
+            # 3) dimension based
+            if info and info.get("vector_dimension"):
+                try:
+                    dim = int(info.get("vector_dimension"))
+                    model, model_name, model_type = get_embedding_model_for_dimension(dim)
+                    return (model, model_name, model_type)
+                except Exception:
+                    pass
+
+            # 4) fallback
+            model_name, model_type = DEFAULT_MODEL
+            model = load_embedding_model(model_name, model_type)
+            return (model, model_name, model_type)
+        except Exception as e:
+            log_error("Failed to load embedding model for collection %s: %s", collection_name, e)
+            raise
+
+    def compute_embeddings_for_documents(
+        self, collection_name: str, documents: List[str], connection_id: Optional[str] = None
+    ) -> List[List[float]]:
+        """
+        Compute embeddings for a list of documents using the resolved model for the collection.
+
+        Returns a list of embedding vectors (one per document). If encoding fails,
+        raises an exception.
+        """
+        model, model_name, model_type = self.load_embedding_model_for_collection(
+            collection_name, connection_id
+        )
+
+        # Use batch encoding when available (sentence-transformer), otherwise per-doc
+        if model_type != "clip":
+            # sentence-transformer-like models support batch encode
+            return model.encode(documents, show_progress_bar=False).tolist()
+        else:
+            # CLIP - use encode_text helper for each document
+            from vector_inspector.core.embedding_utils import encode_text
+
+            return [encode_text(d, model, model_type) for d in documents]

vector_inspector/core/connections/chroma_connection.py

@@ -8,7 +8,7 @@ from chromadb.api import ClientAPI
 from chromadb.api.models.Collection import Collection
 from chromadb import Documents, EmbeddingFunction, Embeddings
 
-from .base_connection import VectorDBConnection
+from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.logging import log_info, log_error
 
 
@@ -28,7 +28,7 @@ class DimensionAwareEmbeddingFunction(EmbeddingFunction):
         if self._initialized:
             return
 
-        from ..embedding_utils import get_embedding_model_for_dimension
+        from vector_inspector.core.embedding_utils import get_embedding_model_for_dimension
 
         log_info("[ChromaDB] Loading embedding model for %dd vectors...", self.expected_dimension)
         self.model, self.model_name, self.model_type = get_embedding_model_for_dimension(
@@ -45,7 +45,7 @@ class DimensionAwareEmbeddingFunction(EmbeddingFunction):
     def __call__(self, input: Documents) -> Embeddings:
         """Embed documents using the dimension-appropriate model."""
         self._ensure_model_loaded()
-        from ..embedding_utils import encode_text
+        from vector_inspector.core.embedding_utils import encode_text
 
         embeddings = []
         for text in input:
@@ -385,6 +385,16 @@ class ChromaDBConnection(VectorDBConnection):
             return False
 
         try:
+            # If embeddings not provided, compute using collection model
+            if not embeddings and documents:
+                try:
+                    embeddings = self.compute_embeddings_for_documents(
+                        collection_name, documents, getattr(self, "connection_id", None)
+                    )
+                except Exception as e:
+                    log_error("Failed to compute embeddings for Chroma add_items: %s", e)
+                    return False
+
             collection.add(
                 documents=documents,
                 metadatas=metadatas,  # type: ignore
@@ -422,6 +432,16 @@ class ChromaDBConnection(VectorDBConnection):
             return False
 
         try:
+            # If embeddings not provided but documents changed, compute embeddings
+            if (not embeddings) and documents:
+                try:
+                    embeddings = self.compute_embeddings_for_documents(
+                        collection_name, documents, getattr(self, "connection_id", None)
+                    )
+                except Exception as e:
+                    log_error("Failed to compute embeddings for Chroma update_items: %s", e)
+                    return False
+
             collection.update(
                 ids=ids,
                 documents=documents,