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

vector_inspector/core/connections/qdrant_connection.py

@@ -4,31 +4,41 @@ from typing import Optional, List, Dict, Any
 import uuid
 from qdrant_client import QdrantClient
 from qdrant_client.models import (
-    Distance, VectorParams, PointStruct, 
-    Filter, FieldCondition, MatchValue, MatchText, MatchAny, MatchExcept, Range
+    Distance,
+    VectorParams,
+    PointStruct,
+    Filter,
+    FieldCondition,
+    MatchValue,
+    MatchText,
+    MatchAny,
+    MatchExcept,
+    Range,
 )
 
-from .base_connection import VectorDBConnection
+from vector_inspector.core.connections.base_connection import VectorDBConnection
 from vector_inspector.core.logging import log_info, log_error, log_debug
 from vector_inspector.core.connections.qdrant_helpers.qdrant_filter_builder import build_filter
-from vector_inspector.core.connections.qdrant_helpers.qdrant_embedding_resolver import resolve_embedding_model
+from vector_inspector.core.connections.qdrant_helpers.qdrant_embedding_resolver import (
+    resolve_embedding_model,
+)
 
 
 class QdrantConnection(VectorDBConnection):
     """Manages connection to Qdrant and provides query interface."""
-    
+
     def __init__(
-        self, 
-        path: Optional[str] = None, 
+        self,
+        path: Optional[str] = None,
         url: Optional[str] = None,
-        host: Optional[str] = None, 
+        host: Optional[str] = None,
         port: Optional[int] = None,
         api_key: Optional[str] = None,
-        prefer_grpc: bool = False
+        prefer_grpc: bool = False,
     ):
         """
         Initialize Qdrant connection.
-        
+
         Args:
             path: Path for local/embedded client
             url: Full URL for remote client (e.g., "http://localhost:6333")
@@ -44,21 +54,21 @@ class QdrantConnection(VectorDBConnection):
         self.api_key = api_key
         self.prefer_grpc = prefer_grpc
         self._client: Optional[QdrantClient] = None
-        
+
     def connect(self) -> bool:
         """
         Establish connection to Qdrant.
-        
+
         Returns:
             True if connection successful, False otherwise
         """
         try:
             # Common parameters for stability
             common_params = {
-                'check_compatibility': False,
-                'timeout': 300,  # 5 minutes timeout for long operations
+                "check_compatibility": False,
+                "timeout": 300,  # 5 minutes timeout for long operations
             }
-            
+
             if self.path:
                 # Local/embedded mode
                 self._client = QdrantClient(path=self.path, **common_params)
@@ -68,7 +78,7 @@ class QdrantConnection(VectorDBConnection):
                     url=self.url,
                     api_key=self.api_key,
                     prefer_grpc=self.prefer_grpc,
-                    **common_params
+                    **common_params,
                 )
             elif self.host:
                 # Host and port provided
@@ -77,22 +87,22 @@ class QdrantConnection(VectorDBConnection):
                     port=self.port,
                     api_key=self.api_key,
                     prefer_grpc=self.prefer_grpc,
-                    **common_params
+                    **common_params,
                 )
             else:
                 # Default to in-memory client
                 self._client = QdrantClient(":memory:", **common_params)
-            
+
             # Test connection
             self._client.get_collections()
             return True
         except Exception as e:
             log_error("Connection failed: %s", e)
             return False
-    
+
     def _to_uuid(self, id_str: str) -> uuid.UUID:
         """Convert a string ID to a valid UUID.
-        
+
         If the string is already a valid UUID, return it.
         Otherwise, generate a deterministic UUID from the string.
         """
@@ -101,18 +111,18 @@ class QdrantConnection(VectorDBConnection):
         except (ValueError, AttributeError):
             # Generate deterministic UUID from string
             return uuid.uuid5(uuid.NAMESPACE_DNS, id_str)
-    
+
     def disconnect(self):
         """Close connection to Qdrant."""
         if self._client:
             self._client.close()
         self._client = None
-    
+
     @property
     def is_connected(self) -> bool:
         """Check if connected to Qdrant."""
         return self._client is not None
-    
+
     def count_collection(self, name: str) -> int:
         """Count the number of items in a collection."""
         if not self._client:
@@ -122,23 +132,23 @@ class QdrantConnection(VectorDBConnection):
             return getattr(res, "count", 0) or 0
         except Exception:
             return 0
-    
+
     def get_items(self, name: str, ids: List[str]) -> Dict[str, Any]:
         """
         Get items by IDs (implementation for compatibility).
-        
+
         Note: This is a simplified implementation that retrieves items by scrolling
         and filtering. For production use, consider using get_all_items with filters.
         """
         if not self._client:
             return {"documents": [], "metadatas": []}
-        
+
         try:
             # Retrieve by scrolling and filtering
             all_items = self.get_all_items(name, limit=1000)
             if not all_items:
                 return {"documents": [], "metadatas": []}
-            
+
             # Filter by requested IDs
             documents = []
             metadatas = []
@@ -146,16 +156,16 @@ class QdrantConnection(VectorDBConnection):
                 if item_id in ids:
                     documents.append(all_items["documents"][i])
                     metadatas.append(all_items["metadatas"][i])
-            
+
             return {"documents": documents, "metadatas": metadatas}
         except Exception as e:
             log_error("Failed to get items: %s", e)
             return {"documents": [], "metadatas": []}
-    
+
     def list_collections(self) -> List[str]:
         """
         Get list of all collections.
-        
+
         Returns:
             List of collection names
         """
@@ -167,91 +177,88 @@ class QdrantConnection(VectorDBConnection):
         except Exception as e:
             log_error("Failed to list collections: %s", e)
             return []
-    
+
     def get_collection_info(self, name: str) -> Optional[Dict[str, Any]]:
         """
         Get collection metadata and statistics.
-        
+
         Args:
             name: Collection name
-            
+
         Returns:
             Dictionary with collection info
         """
         if not self._client:
             return None
-        
+
         try:
             # Get collection info
             collection_info = self._client.get_collection(name)
-            
+
             # Get a sample point to determine metadata fields
             sample = self._client.scroll(
-                collection_name=name,
-                limit=1,
-                with_payload=True,
-                with_vectors=False
+                collection_name=name, limit=1, with_payload=True, with_vectors=False
             )
-            
+
             metadata_fields = []
             if sample[0] and len(sample[0]) > 0:
                 point = sample[0][0]
                 if point.payload:
                     # Extract metadata fields, excluding 'document' if present
-                    metadata_fields = [k for k in point.payload.keys() if k != 'document']
-            
+                    metadata_fields = [k for k in point.payload.keys() if k != "document"]
+
             # Extract vector configuration
             vector_dimension = "Unknown"
             distance_metric = "Unknown"
             config_details = {}
-            
+
             if collection_info.config:
                 # Get vector parameters
-                if hasattr(collection_info.config, 'params'):
+                if hasattr(collection_info.config, "params"):
                     params = collection_info.config.params
-                    if hasattr(params, 'vectors'):
+                    if hasattr(params, "vectors"):
                         vectors = params.vectors
                         # Handle both dict and object access
                         if isinstance(vectors, dict):
                             # Named vectors
                             first_vector = next(iter(vectors.values()), None)
                             if first_vector:
-                                vector_dimension = getattr(first_vector, 'size', 'Unknown')
-                                distance = getattr(first_vector, 'distance', None)
+                                vector_dimension = getattr(first_vector, "size", "Unknown")
+                                distance = getattr(first_vector, "distance", None)
                         else:
                             # Single vector config
-                            vector_dimension = getattr(vectors, 'size', 'Unknown')
-                            distance = getattr(vectors, 'distance', None)
-                        
+                            vector_dimension = getattr(vectors, "size", "Unknown")
+                            distance = getattr(vectors, "distance", None)
+
                         # Map distance enum to readable name
                         if distance:
                             distance_str = str(distance)
-                            if 'COSINE' in distance_str.upper():
+                            if "COSINE" in distance_str.upper():
                                 distance_metric = "Cosine"
-                            elif 'EUCLID' in distance_str.upper():
+                            elif "EUCLID" in distance_str.upper():
                                 distance_metric = "Euclidean"
-                            elif 'DOT' in distance_str.upper():
+                            elif "DOT" in distance_str.upper():
                                 distance_metric = "Dot Product"
-                            elif 'MANHATTAN' in distance_str.upper():
+                            elif "MANHATTAN" in distance_str.upper():
                                 distance_metric = "Manhattan"
                             else:
                                 distance_metric = distance_str
-                
+
                 # Get HNSW config if available
-                if hasattr(collection_info.config, 'hnsw_config'):
+                if hasattr(collection_info.config, "hnsw_config"):
                     hnsw = collection_info.config.hnsw_config
-                    config_details['hnsw_config'] = {
-                        'm': getattr(hnsw, 'm', None),
-                        'ef_construct': getattr(hnsw, 'ef_construct', None),
+                    config_details["hnsw_config"] = {
+                        "m": getattr(hnsw, "m", None),
+                        "ef_construct": getattr(hnsw, "ef_construct", None),
                     }
-                
+
                 # Get optimizer config if available
-                if hasattr(collection_info.config, 'optimizer_config'):
+                if hasattr(collection_info.config, "optimizer_config"):
                     opt = collection_info.config.optimizer_config
-                    config_details['optimizer_config'] = {
-                        'indexing_threshold': getattr(opt, 'indexing_threshold', None),
+                    config_details["optimizer_config"] = {
+                        "indexing_threshold": getattr(opt, "indexing_threshold", None),
                     }
-            
+
             result = {
                 "name": name,
                 "count": collection_info.points_count,
@@ -259,35 +266,36 @@ class QdrantConnection(VectorDBConnection):
                 "vector_dimension": vector_dimension,
                 "distance_metric": distance_metric,
             }
-            
+
             # Check for embedding model metadata (if collection creator stored it)
-            if hasattr(collection_info.config, 'metadata') and collection_info.config.metadata:
+            if hasattr(collection_info.config, "metadata") and collection_info.config.metadata:
                 metadata = collection_info.config.metadata
-                if 'embedding_model' in metadata:
-                    result['embedding_model'] = metadata['embedding_model']
-                if 'embedding_model_type' in metadata:
-                    result['embedding_model_type'] = metadata['embedding_model_type']
-            
+                if "embedding_model" in metadata:
+                    result["embedding_model"] = metadata["embedding_model"]
+                if "embedding_model_type" in metadata:
+                    result["embedding_model_type"] = metadata["embedding_model_type"]
+
             if config_details:
-                result['config'] = config_details
-            
+                result["config"] = config_details
+
             return result
-            
+
         except Exception as e:
             log_error("Failed to get collection info: %s", e)
             return None
-    
+
     def _get_embedding_model_for_collection(self, collection_name: str):
         """Delegate embedding-model selection to helper resolver."""
         try:
             return resolve_embedding_model(self, collection_name)
         except Exception as e:
             log_error("Failed to resolve embedding model for %s: %s", collection_name, e)
-            from ..embedding_utils import DEFAULT_MODEL, load_embedding_model
+            from vector_inspector.core.embedding_utils import DEFAULT_MODEL, load_embedding_model
+
             model_name, model_type = DEFAULT_MODEL
             model = load_embedding_model(model_name, model_type)
             return (model, model_name, model_type)
-    
+
     def _build_qdrant_filter(self, where: Optional[Dict[str, Any]] = None) -> Optional[Filter]:
         """Delegate filter construction to helper module."""
         try:
@@ -295,7 +303,7 @@ class QdrantConnection(VectorDBConnection):
         except Exception as e:
             log_error("Failed to build filter: %s", e)
             return None
-    
+
     def query_collection(
         self,
         collection_name: str,
@@ -307,7 +315,7 @@ class QdrantConnection(VectorDBConnection):
     ) -> Optional[Dict[str, Any]]:
         """
         Query a collection for similar vectors.
-        
+
         Args:
             collection_name: Name of collection to query
             query_texts: Text queries (Qdrant will embed automatically)
@@ -315,44 +323,48 @@ class QdrantConnection(VectorDBConnection):
             n_results: Number of results to return
             where: Metadata filter
             where_document: Document content filter (limited support)
-            
+
         Returns:
             Query results or None if failed
         """
         if not self._client:
             return None
-        
+
         if not query_texts and not query_embeddings:
             log_error("Either query_texts or query_embeddings required")
             return None
-        
+
         try:
             # Build filter
             qdrant_filter = self._build_qdrant_filter(where)
-            
+
             # Perform search for each query
             all_results = {
                 "ids": [],
                 "distances": [],
                 "documents": [],
                 "metadatas": [],
-                "embeddings": []
+                "embeddings": [],
             }
-            
+
             # Use query_texts if provided (Qdrant handles embedding)
             queries = query_texts if query_texts else []
-            
+
             # If embeddings provided instead, use them
             if query_embeddings and not query_texts:
                 queries = query_embeddings
-            
+
             for query in queries:
                 # Embed text queries if needed
                 if isinstance(query, str):
                     # Generate embeddings for text query using appropriate model for this collection
                     try:
-                        model, model_name, model_type = self._get_embedding_model_for_collection(collection_name)
-                        from ..embedding_utils import encode_text
+                        model, model_name, model_type = self._get_embedding_model_for_collection(
+                            collection_name
+                        )
+
+                        from vector_inspector.core.embedding_utils import encode_text
+
                         query_vector = encode_text(query, model, model_type)
                     except Exception as e:
                         log_error("Failed to embed query text: %s", e)
@@ -374,40 +386,40 @@ class QdrantConnection(VectorDBConnection):
                 except Exception as e:
                     log_error("Query failed: %s", e)
                     continue
-                
+
                 # Transform results to standard format
                 ids = []
                 distances = []
                 documents = []
                 metadatas = []
                 embeddings = []
-                
+
                 for result in search_results:
                     ids.append(str(result.id))
                     distances.append(result.score)
-                    
+
                     # Extract document and metadata from payload
                     payload = result.payload or {}
-                    documents.append(payload.get('document', ''))
-                    
+                    documents.append(payload.get("document", ""))
+
                     # Metadata is everything except 'document'
-                    metadata = {k: v for k, v in payload.items() if k != 'document'}
+                    metadata = {k: v for k, v in payload.items() if k != "document"}
                     metadatas.append(metadata)
-                    
+
                     # Extract embedding
                     embeddings.append(result.vector if result.vector else [])
-                
+
                 all_results["ids"].append(ids)
                 all_results["distances"].append(distances)
                 all_results["documents"].append(documents)
                 all_results["metadatas"].append(metadatas)
                 all_results["embeddings"].append(embeddings)
-            
+
             return all_results
         except Exception as e:
             log_error("Query failed: %s", e)
             return None
-    
+
     def get_all_items(
         self,
         collection_name: str,
@@ -417,23 +429,23 @@ class QdrantConnection(VectorDBConnection):
     ) -> Optional[Dict[str, Any]]:
         """
         Get all items from a collection.
-        
+
         Args:
             collection_name: Name of collection
             limit: Maximum number of items to return
             offset: Number of items to skip
             where: Metadata filter
-            
+
         Returns:
             Collection items or None if failed
         """
         if not self._client:
             return None
-        
+
         try:
             # Build filter
             qdrant_filter = self._build_qdrant_filter(where)
-            
+
             # Use scroll to retrieve items
             points, next_offset = self._client.scroll(
                 collection_name=collection_name,
@@ -441,42 +453,42 @@ class QdrantConnection(VectorDBConnection):
                 limit=limit,
                 offset=offset,
                 with_payload=True,
-                with_vectors=True
+                with_vectors=True,
             )
-            
+
             # Transform to standard format
             ids = []
             documents = []
             metadatas = []
             embeddings = []
-            
+
             for point in points:
                 ids.append(str(point.id))
-                
+
                 payload = point.payload or {}
-                documents.append(payload.get('document', ''))
-                
+                documents.append(payload.get("document", ""))
+
                 # Metadata is everything except 'document'
-                metadata = {k: v for k, v in payload.items() if k != 'document'}
+                metadata = {k: v for k, v in payload.items() if k != "document"}
                 metadatas.append(metadata)
-                
+
                 # Extract embedding
                 if isinstance(point.vector, dict):
                     # Named vectors - use the first one
                     embeddings.append(list(point.vector.values())[0] if point.vector else [])
                 else:
                     embeddings.append(point.vector if point.vector else [])
-            
+
             return {
                 "ids": ids,
                 "documents": documents,
                 "metadatas": metadatas,
-                "embeddings": embeddings
+                "embeddings": embeddings,
             }
         except Exception as e:
             log_error("Failed to get items: %s", e)
             return None
-    
+
     def add_items(
         self,
         collection_name: str,
@@ -487,29 +499,39 @@ class QdrantConnection(VectorDBConnection):
     ) -> bool:
         """
         Add items to a collection.
-        
+
         Args:
             collection_name: Name of collection
             documents: Document texts
             metadatas: Metadata for each document
             ids: IDs for each document (will generate UUIDs if not provided)
             embeddings: Pre-computed embeddings (required for Qdrant)
-            
+
         Returns:
             True if successful, False otherwise
         """
         if not self._client:
             return False
-        
-        if not embeddings:
-            log_error("Embeddings are required for Qdrant")
-            return False
-        
+
+        # If embeddings not provided, compute using model resolution helper
+        if not embeddings and documents:
+            try:
+                embeddings = self.compute_embeddings_for_documents(
+                    collection_name,
+                    documents,
+                    getattr(self, "path", None)
+                    or getattr(self, "url", None)
+                    or getattr(self, "host", None),
+                )
+            except Exception as e:
+                log_error("Embeddings are required for Qdrant and computing them failed: %s", e)
+                return False
+
         try:
             # Generate IDs if not provided
             if not ids:
                 ids = [str(uuid.uuid4()) for _ in documents]
-            
+
             # Build points
             points = []
             for i, (doc_id, document, embedding) in enumerate(zip(ids, documents, embeddings)):
@@ -517,27 +539,20 @@ class QdrantConnection(VectorDBConnection):
                 payload = {"document": document}
                 if metadatas and i < len(metadatas):
                     payload.update(metadatas[i])
-                
+
                 # Convert string ID to UUID
                 point_id = self._to_uuid(doc_id)
-                
-                point = PointStruct(
-                    id=point_id,
-                    vector=embedding,
-                    payload=payload
-                )
+
+                point = PointStruct(id=point_id, vector=embedding, payload=payload)
                 points.append(point)
-            
+
             # Upsert points
-            self._client.upsert(
-                collection_name=collection_name,
-                points=points
-            )
+            self._client.upsert(collection_name=collection_name, points=points)
             return True
         except Exception as e:
             log_error("Failed to add items: %s", e)
             return False
-    
+
     def update_items(
         self,
         collection_name: str,
@@ -548,20 +563,20 @@ class QdrantConnection(VectorDBConnection):
     ) -> bool:
         """
         Update items in a collection.
-        
+
         Args:
             collection_name: Name of collection
             ids: IDs of items to update
             documents: New document texts
             metadatas: New metadata
             embeddings: New embeddings
-            
+
         Returns:
             True if successful, False otherwise
         """
         if not self._client:
             return False
-        
+
         try:
             # For Qdrant, we need to retrieve existing points, update them, and upsert
             for i, point_id in enumerate(ids):
@@ -570,40 +585,56 @@ class QdrantConnection(VectorDBConnection):
                     collection_name=collection_name,
                     ids=[point_id],
                     with_payload=True,
-                    with_vectors=True
+                    with_vectors=True,
                 )
-                
+
                 if not existing:
                     continue
-                
+
                 point = existing[0]
                 payload = point.payload or {}
                 vector = point.vector
-                
+
                 # Update fields as provided
                 if documents and i < len(documents):
-                    payload['document'] = documents[i]
-                
+                    payload["document"] = documents[i]
+
                 if metadatas and i < len(metadatas):
                     # Update metadata, keeping 'document' field
-                    doc = payload.get('document', '')
+                    doc = payload.get("document", "")
                     payload = metadatas[i].copy()
-                    payload['document'] = doc
-                
+                    payload["document"] = doc
+
+                # If embeddings provided use them; otherwise compute for updated documents
                 if embeddings and i < len(embeddings):
                     vector = embeddings[i]
-                
+                elif documents and i < len(documents) and documents[i]:
+                    try:
+                        # Compute single embedding for this document
+                        computed = self.compute_embeddings_for_documents(
+                            collection_name,
+                            [documents[i]],
+                            getattr(self, "path", None)
+                            or getattr(self, "url", None)
+                            or getattr(self, "host", None),
+                        )
+                        vector = computed[0] if computed else vector
+                    except Exception as e:
+                        log_error("Failed to compute embedding for Qdrant update: %s", e)
+                        # leave existing vector unchanged
+                        pass
+
                 # Upsert updated point
                 self._client.upsert(
                     collection_name=collection_name,
-                    points=[PointStruct(id=point_id, vector=vector, payload=payload)]
+                    points=[PointStruct(id=point_id, vector=vector, payload=payload)],
                 )
-            
+
             return True
         except Exception as e:
             log_error("Failed to update items: %s", e)
             return False
-    
+
     def delete_items(
         self,
         collection_name: str,
@@ -612,78 +643,69 @@ class QdrantConnection(VectorDBConnection):
     ) -> bool:
         """
         Delete items from a collection.
-        
+
         Args:
             collection_name: Name of collection
             ids: IDs of items to delete
             where: Metadata filter for items to delete
-            
+
         Returns:
             True if successful, False otherwise
         """
         if not self._client:
             return False
-        
+
         try:
             if ids:
                 # Delete by IDs
-                self._client.delete(
-                    collection_name=collection_name,
-                    points_selector=ids
-                )
+                self._client.delete(collection_name=collection_name, points_selector=ids)
             elif where:
                 # Delete by filter
                 qdrant_filter = self._build_qdrant_filter(where)
                 if qdrant_filter:
                     self._client.delete(
-                        collection_name=collection_name,
-                        points_selector=qdrant_filter
+                        collection_name=collection_name, points_selector=qdrant_filter
                     )
             return True
         except Exception as e:
             log_error("Failed to delete items: %s", e)
             return False
-    
+
     def delete_collection(self, name: str) -> bool:
         """
         Delete an entire collection.
-        
+
         Args:
             name: Collection name
-            
+
         Returns:
             True if successful, False otherwise
         """
         if not self._client:
             return False
-        
+
         try:
             self._client.delete_collection(collection_name=name)
             return True
         except Exception as e:
             log_error("Failed to delete collection: %s", e)
             return False
-    
-    def create_collection(
-        self, 
-        name: str, 
-        vector_size: int,
-        distance: str = "Cosine"
-    ) -> bool:
+
+    def create_collection(self, name: str, vector_size: int, distance: str = "Cosine") -> bool:
         """
         Create a new collection.
-        
+
         Args:
             name: Collection name
             vector_size: Dimension of vectors
             distance: Distance metric ("Cosine", "Euclid", "Dot")
-            
+
         Returns:
             True if successful, False otherwise
         """
         if not self._client:
             return False
-        
+
         try:
             # Map distance string to Qdrant Distance enum
             distance_map = {
@@ -692,15 +714,12 @@ class QdrantConnection(VectorDBConnection):
                 "Euclidean": Distance.EUCLID,
                 "Dot": Distance.DOT,
             }
-            
+
             qdrant_distance = distance_map.get(distance, Distance.COSINE)
-            
+
             self._client.create_collection(
                 collection_name=name,
-                vectors_config=VectorParams(
-                    size=vector_size,
-                    distance=qdrant_distance
-                )
+                vectors_config=VectorParams(size=vector_size, distance=qdrant_distance),
             )
             return True
         except Exception as e:
@@ -739,10 +758,16 @@ class QdrantConnection(VectorDBConnection):
                 distance = coll_info.get("distance_metric") or coll_info.get("distance")
             distance = distance or "Cosine"
 
-            log_info("Preparing restore: collection=%s, vector_size=%s, distance=%s",
-                     metadata.get("collection_name"), vector_size, distance)
+            log_info(
+                "Preparing restore: collection=%s, vector_size=%s, distance=%s",
+                metadata.get("collection_name"),
+                vector_size,
+                distance,
+            )
 
-            if not self.create_collection(metadata.get("collection_name"), int(vector_size), distance):
+            if not self.create_collection(
+                metadata.get("collection_name"), int(vector_size), distance
+            ):
                 log_error("Failed to create collection %s", metadata.get("collection_name"))
                 return False
 
@@ -757,19 +782,30 @@ class QdrantConnection(VectorDBConnection):
                         # leave conversion to normalize_embeddings later
                         continue
                     if len(emb) != int(vector_size):
-                        log_error("Embedding at index %d has length %d but expected %d",
-                                  i, len(emb), int(vector_size))
+                        log_error(
+                            "Embedding at index %d has length %d but expected %d",
+                            i,
+                            len(emb),
+                            int(vector_size),
+                        )
                         return False
 
             # If embeddings missing or empty, try to generate using connection utilities
             if not embeddings_present:
                 try:
-                    model, model_name, model_type = self._get_embedding_model_for_collection(metadata.get("collection_name"))
-                    from ..embedding_utils import encode_documents
+                    model, model_name, model_type = self._get_embedding_model_for_collection(
+                        metadata.get("collection_name")
+                    )
+                    from vector_inspector.core.embedding_utils import encode_documents
+
                     documents = data.get("documents", []) if data else []
                     if documents:
                         data["embeddings"] = encode_documents(documents, model, model_type)
-                        log_info("Generated %d embeddings using model %s", len(data.get("embeddings")), model_name)
+                        log_info(
+                            "Generated %d embeddings using model %s",
+                            len(data.get("embeddings")),
+                            model_name,
+                        )
                 except Exception as e:
                     log_error("Failed to generate embeddings during prepare_restore: %s", e)
                     return False
@@ -817,4 +853,3 @@ class QdrantConnection(VectorDBConnection):
             {"name": "contains", "server_side": True},
             {"name": "not contains", "server_side": True},
         ]
-