agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/vectordb/lancedb/lance_db.py

@@ -2,7 +2,7 @@ import asyncio
 import json
 from hashlib import md5
 from os import getenv
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 try:
     import lancedb
@@ -10,10 +10,11 @@ try:
 except ImportError:
     raise ImportError("`lancedb` not installed. Please install using `pip install lancedb`")
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
 from agno.knowledge.reranker.base import Reranker
-from agno.utils.log import log_debug, log_info, logger
+from agno.utils.log import log_debug, log_info, log_warning, logger
 from agno.vectordb.base import VectorDb
 from agno.vectordb.distance import Distance
 from agno.vectordb.search import SearchType
@@ -25,6 +26,8 @@ class LanceDb(VectorDb):
 
     Args:
         uri: The URI of the LanceDB database.
+        name: Name of the vector database.
+        description: Description of the vector database.
         connection: The LanceDB connection to use.
         table: The LanceDB table instance to use.
         async_connection: The LanceDB async connection to use.
@@ -44,6 +47,9 @@ class LanceDb(VectorDb):
     def __init__(
         self,
         uri: lancedb.URI = "/tmp/lancedb",
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        id: Optional[str] = None,
         connection: Optional[lancedb.LanceDBConnection] = None,
         table: Optional[lancedb.db.LanceTable] = None,
         async_connection: Optional[lancedb.AsyncConnection] = None,
@@ -59,6 +65,17 @@ class LanceDb(VectorDb):
         on_bad_vectors: Optional[str] = None,  # One of "error", "drop", "fill", "null".
         fill_value: Optional[float] = None,  # Only used if on_bad_vectors is "fill"
     ):
+        # Dynamic ID generation based on unique identifiers
+        if id is None:
+            from agno.utils.string import generate_id
+
+            table_identifier = table_name or "default_table"
+            seed = f"{uri}#{table_identifier}"
+            id = generate_id(seed)
+
+        # Initialize base class with name, description, and generated ID
+        super().__init__(id=id, name=name, description=description)
+
         # Embedder for embedding the document contents
         if embedder is None:
             from agno.knowledge.embedder.openai import OpenAIEmbedder
@@ -142,7 +159,7 @@ class LanceDb(VectorDb):
 
     def _prepare_vector(self, embedding) -> List[float]:
         """Prepare vector embedding for insertion, ensuring correct dimensions and type."""
-        if embedding is not None:
+        if embedding is not None and len(embedding) > 0:
             # Convert to list of floats
             vector = [float(x) for x in embedding]
 
@@ -160,7 +177,7 @@ class LanceDb(VectorDb):
 
             return vector
         else:
-            # Fallback if embedding is None
+            # Fallback if embedding is None or empty
             return [0.0] * (self.dimensions or 1536)
 
     async def _get_async_connection(self) -> lancedb.AsyncConnection:
@@ -184,7 +201,6 @@ class LanceDb(VectorDb):
             # Re-establish sync connection to see async changes
             if self.connection and self.table_name in self.connection.table_names():
                 self.table = self.connection.open_table(self.table_name)
-                log_debug(f"Refreshed sync connection for table: {self.table_name}")
         except Exception as e:
             log_debug(f"Could not refresh sync connection: {e}")
             # If refresh fails, we can still function but sync methods might not see async changes
@@ -244,39 +260,6 @@ class LanceDb(VectorDb):
             tbl = self.connection.create_table(name=self.table_name, schema=schema, mode="overwrite", exist_ok=True)  # type: ignore
         return tbl  # type: ignore
 
-    def doc_exists(self, document: Document) -> bool:
-        """
-        Validating if the document exists or not
-
-        Args:
-            document (Document): Document to validate
-        """
-        try:
-            if self.table is not None:
-                cleaned_content = document.content.replace("\x00", "\ufffd")
-                doc_id = md5(cleaned_content.encode()).hexdigest()
-                result = self.table.search().where(f"{self._id}='{doc_id}'").to_arrow()
-                return len(result) > 0
-        except Exception:
-            # Search sometimes fails with stale cache data, it means the doc doesn't exist
-            return False
-
-        return False
-
-    async def async_doc_exists(self, document: Document) -> bool:
-        """
-        Asynchronously validate if the document exists
-
-        Args:
-            document (Document): Document to validate
-
-        Returns:
-            bool: True if document exists, False otherwise
-        """
-        if self.connection:
-            self.table = self.connection.open_table(name=self.table_name)
-        return self.doc_exists(document)
-
     def insert(self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
         """
         Insert documents into the database.
@@ -293,9 +276,6 @@ class LanceDb(VectorDb):
         data = []
 
         for document in documents:
-            if self.doc_exists(document):
-                continue
-
             # Add filters to document metadata if provided
             if filters:
                 meta_data = document.meta_data.copy() if document.meta_data else {}
@@ -304,7 +284,9 @@ class LanceDb(VectorDb):
 
             document.embed(embedder=self.embedder)
             cleaned_content = document.content.replace("\x00", "\ufffd")
-            doc_id = str(md5(cleaned_content.encode()).hexdigest())
+            # Include content_hash in ID to ensure uniqueness across different content hashes
+            base_id = document.id or md5(cleaned_content.encode()).hexdigest()
+            doc_id = str(md5(f"{base_id}_{content_hash}".encode()).hexdigest())
             payload = {
                 "name": document.name,
                 "meta_data": document.meta_data,
@@ -343,6 +325,9 @@ class LanceDb(VectorDb):
         """
         Asynchronously insert documents into the database.
 
+        Note: Currently wraps sync insert method since LanceDB async insert has sync/async table
+        synchronization issues causing empty vectors. We still do async embedding for performance.
+
         Args:
             documents (List[Document]): List of documents to insert
             filters (Optional[Dict[str, Any]]): Filters to apply while inserting documents
@@ -352,115 +337,36 @@ class LanceDb(VectorDb):
             return
 
         log_debug(f"Inserting {len(documents)} documents")
-        data = []
 
+        # Still do async embedding for performance
         if self.embedder.enable_batch and hasattr(self.embedder, "async_get_embeddings_batch_and_usage"):
-            # Use batch embedding when enabled and supported
             try:
-                # Extract content from all documents
                 doc_contents = [doc.content for doc in documents]
-
-                # Get batch embeddings and usage
                 embeddings, usages = await self.embedder.async_get_embeddings_batch_and_usage(doc_contents)
 
-                # Process documents with pre-computed embeddings
                 for j, doc in enumerate(documents):
-                    try:
-                        if j < len(embeddings):
-                            doc.embedding = embeddings[j]
-                            doc.usage = usages[j] if j < len(usages) else None
-                    except Exception as e:
-                        logger.error(f"Error assigning batch embedding to document '{doc.name}': {e}")
-
+                    if j < len(embeddings):
+                        doc.embedding = embeddings[j]
+                        doc.usage = usages[j] if j < len(usages) else None
             except Exception as e:
-                # Check if this is a rate limit error - don't fall back as it would make things worse
                 error_str = str(e).lower()
                 is_rate_limit = any(
                     phrase in error_str
                     for phrase in ["rate limit", "too many requests", "429", "trial key", "api calls / minute"]
                 )
-
                 if is_rate_limit:
                     logger.error(f"Rate limit detected during batch embedding. {e}")
                     raise e
                 else:
                     logger.warning(f"Async batch embedding failed, falling back to individual embeddings: {e}")
-                    # Fall back to individual embedding
                     embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
                     await asyncio.gather(*embed_tasks, return_exceptions=True)
         else:
-            # Use individual embedding
-            embed_tasks = [document.async_embed(embedder=self.embedder) for document in documents]
+            embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
             await asyncio.gather(*embed_tasks, return_exceptions=True)
 
-        for document in documents:
-            if await self.async_doc_exists(document):
-                continue
-
-            # Add filters to document metadata if provided
-            if filters:
-                meta_data = document.meta_data.copy() if document.meta_data else {}
-                meta_data.update(filters)
-                document.meta_data = meta_data
-
-            cleaned_content = document.content.replace("\x00", "\ufffd")
-            doc_id = str(md5(cleaned_content.encode()).hexdigest())
-            payload = {
-                "name": document.name,
-                "meta_data": document.meta_data,
-                "content": cleaned_content,
-                "usage": document.usage,
-                "content_id": document.content_id,
-                "content_hash": content_hash,
-            }
-            data.append(
-                {
-                    "id": doc_id,
-                    "vector": self._prepare_vector(document.embedding),
-                    "payload": json.dumps(payload),
-                }
-            )
-            log_debug(f"Parsed document: {document.name} ({document.meta_data})")
-
-        if not data:
-            log_debug("No new data to insert")
-            return
-
-        try:
-            await self._get_async_connection()
-
-            # Ensure the async table is created before inserting
-            if self.async_table is None:
-                try:
-                    await self.async_create()
-                except Exception as create_e:
-                    logger.error(f"Failed to create async table: {create_e}")
-                    # Continue to fallback logic below
-
-            if self.async_table is None:
-                # Fall back to sync insertion if async table creation failed
-                logger.warning("Async table not available, falling back to sync insertion")
-                return self.insert(content_hash, documents, filters)
-
-            if self.on_bad_vectors is not None:
-                await self.async_table.add(data, on_bad_vectors=self.on_bad_vectors, fill_value=self.fill_value)  # type: ignore
-            else:
-                await self.async_table.add(data)  # type: ignore
-
-            log_debug(f"Asynchronously inserted {len(data)} documents")
-
-            # Refresh sync connection to see async changes
-            self._refresh_sync_connection()
-        except Exception as e:
-            logger.error(f"Error during async document insertion: {e}")
-            # Try falling back to sync insertion as a last resort
-            try:
-                logger.warning("Async insertion failed, attempting sync fallback")
-                self.insert(content_hash, documents, filters)
-                logger.info("Sync fallback successful")
-            except Exception as sync_e:
-                logger.error(f"Sync fallback also failed: {sync_e}")
-                raise e from sync_e
+        # Use sync insert to avoid sync/async table synchronization issues
+        self.insert(content_hash, documents, filters)
 
     def upsert_available(self) -> bool:
         """Check if upsert is available in LanceDB."""
@@ -481,11 +387,42 @@ class LanceDb(VectorDb):
     async def async_upsert(
         self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None
     ) -> None:
-        if self.content_hash_exists(content_hash):
-            self._delete_by_content_hash(content_hash)
-        await self.async_insert(content_hash=content_hash, documents=documents, filters=filters)
+        """
+        Asynchronously upsert documents into the database.
 
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+        Note: Uses async embedding for performance, then sync upsert for reliability.
+        """
+        if len(documents) > 0:
+            # Do async embedding for performance
+            if self.embedder.enable_batch and hasattr(self.embedder, "async_get_embeddings_batch_and_usage"):
+                try:
+                    doc_contents = [doc.content for doc in documents]
+                    embeddings, usages = await self.embedder.async_get_embeddings_batch_and_usage(doc_contents)
+                    for j, doc in enumerate(documents):
+                        if j < len(embeddings):
+                            doc.embedding = embeddings[j]
+                            doc.usage = usages[j] if j < len(usages) else None
+                except Exception as e:
+                    error_str = str(e).lower()
+                    is_rate_limit = any(
+                        phrase in error_str
+                        for phrase in ["rate limit", "too many requests", "429", "trial key", "api calls / minute"]
+                    )
+                    if is_rate_limit:
+                        raise e
+                    else:
+                        embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
+                        await asyncio.gather(*embed_tasks, return_exceptions=True)
+            else:
+                embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
+                await asyncio.gather(*embed_tasks, return_exceptions=True)
+
+        # Use sync upsert for reliability
+        self.upsert(content_hash=content_hash, documents=documents, filters=filters)
+
+    def search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         """
         Search for documents matching the query.
 
@@ -502,6 +439,10 @@ class LanceDb(VectorDb):
 
         results = None
 
+        if isinstance(filters, list):
+            log_warning("Filter Expressions are not yet supported in LanceDB. No filters will be applied.")
+            filters = None
+
         if self.search_type == SearchType.vector:
             results = self.vector_search(query, limit)
         elif self.search_type == SearchType.keyword:
@@ -543,11 +484,14 @@ class LanceDb(VectorDb):
         return search_results
 
     async def async_search(
-        self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     ) -> List[Document]:
         """
         Asynchronously search for documents matching the query.
 
+        Note: Currently wraps sync search method since LanceDB async search has sync/async table
+        synchronization issues. Performance impact is minimal for search operations.
+
         Args:
             query (str): Query string to search for
             limit (int): Maximum number of results to return
@@ -556,53 +500,12 @@ class LanceDb(VectorDb):
         Returns:
             List[Document]: List of matching documents
         """
-        # TODO: Search is not yet supported in async (https://github.com/lancedb/lancedb/pull/2049)
-        if self.connection:
-            self.table = self.connection.open_table(name=self.table_name)
+        # Wrap sync search method to avoid sync/async table synchronization issues
+        return self.search(query=query, limit=limit, filters=filters)
 
-        results = None
-
-        if self.search_type == SearchType.vector:
-            results = self.vector_search(query, limit)
-        elif self.search_type == SearchType.keyword:
-            results = self.keyword_search(query, limit)
-        elif self.search_type == SearchType.hybrid:
-            results = self.hybrid_search(query, limit)
-        else:
-            logger.error(f"Invalid search type '{self.search_type}'.")
-            return []
-
-        if results is None:
-            return []
-
-        search_results = self._build_search_results(results)
-
-        # Filter results based on metadata if filters are provided
-        if filters and search_results:
-            filtered_results = []
-            for doc in search_results:
-                if doc.meta_data is None:
-                    continue
-
-                # Check if all filter criteria match
-                match = True
-                for key, value in filters.items():
-                    if key not in doc.meta_data or doc.meta_data[key] != value:
-                        match = False
-                        break
-
-                if match:
-                    filtered_results.append(doc)
-
-            search_results = filtered_results
-
-        if self.reranker and search_results:
-            search_results = self.reranker.rerank(query=query, documents=search_results)
-
-        log_info(f"Found {len(search_results)} documents")
-        return search_results
-
-    def vector_search(self, query: str, limit: int = 5) -> List[Document]:
+    def vector_search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         query_embedding = self.embedder.get_embedding(query)
         if query_embedding is None:
             logger.error(f"Error getting embedding for Query: {query}")
@@ -622,7 +525,9 @@ class LanceDb(VectorDb):
 
         return results.to_pandas()
 
-    def hybrid_search(self, query: str, limit: int = 5) -> List[Document]:
+    def hybrid_search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         query_embedding = self.embedder.get_embedding(query)
         if query_embedding is None:
             logger.error(f"Error getting embedding for Query: {query}")
@@ -651,7 +556,9 @@ class LanceDb(VectorDb):
 
         return results.to_pandas()
 
-    def keyword_search(self, query: str, limit: int = 5) -> List[Document]:
+    def keyword_search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         if self.table is None:
             logger.error("Table not initialized. Please create the table first")
             return []
@@ -1048,3 +955,7 @@ class LanceDb(VectorDb):
         except Exception as e:
             logger.error(f"Error updating metadata for content_id '{content_id}': {e}")
             raise
+
+    def get_supported_search_types(self) -> List[str]:
+        """Get the supported search types for this vector database."""
+        return [SearchType.vector, SearchType.keyword, SearchType.hybrid]

agno/vectordb/langchaindb/langchaindb.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
-from agno.utils.log import log_debug, logger
+from agno.utils.log import log_debug, log_warning, logger
 from agno.vectordb.base import VectorDb
 
 
@@ -11,16 +12,23 @@ class LangChainVectorDb(VectorDb):
         vectorstore: Optional[Any] = None,
         search_kwargs: Optional[dict] = None,
         knowledge_retriever: Optional[Any] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
     ):
         """
         Initialize LangChainVectorDb.
 
         Args:
             vectorstore: The LangChain vectorstore instance
+            name (Optional[str]): Name of the vector database.
+            description (Optional[str]): Description of the vector database.
             search_kwargs: Additional search parameters for the retriever
             knowledge_retriever: An optional LangChain retriever instance
         """
         self.vectorstore = vectorstore
+        # Initialize base class with name and description
+        super().__init__(name=name, description=description)
+
         self.search_kwargs = search_kwargs
         self.knowledge_retriever = knowledge_retriever
 
@@ -63,9 +71,17 @@ class LangChainVectorDb(VectorDb):
         logger.warning("LangChainKnowledgeBase.async_upsert() not supported - please check the vectorstore manually.")
         raise NotImplementedError
 
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         """Returns relevant documents matching the query"""
 
+        if isinstance(filters, List):
+            log_warning(
+                "Filter Expressions are not supported in LangChainDB. No filters will be applied. Use filters as a dictionary."
+            )
+            filters = None
+
         try:
             from langchain_core.documents import Document as LangChainDocument
             from langchain_core.retrievers import BaseRetriever
@@ -102,7 +118,7 @@ class LangChainVectorDb(VectorDb):
         return documents
 
     async def async_search(
-        self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     ) -> List[Document]:
         return self.search(query, limit, filters)
 
@@ -141,3 +157,7 @@ class LangChainVectorDb(VectorDb):
             metadata (Dict[str, Any]): The metadata to update
         """
         raise NotImplementedError("update_metadata not supported for LangChain vectorstores")
+
+    def get_supported_search_types(self) -> List[str]:
+        """Get the supported search types for this vector database."""
+        return []  # LangChainVectorDb doesn't use SearchType enum

agno/vectordb/lightrag/lightrag.py

@@ -1,8 +1,9 @@
 import asyncio
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import httpx
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.vectordb.base import VectorDb
@@ -21,9 +22,14 @@ class LightRag(VectorDb):
         api_key: Optional[str] = None,
         auth_header_name: str = "X-API-KEY",
         auth_header_format: str = "{api_key}",
+        name: Optional[str] = None,
+        description: Optional[str] = None,
     ):
         self.server_url = server_url
         self.api_key = api_key
+        # Initialize base class with name and description
+        super().__init__(name=name, description=description)
+
         self.auth_header_name = auth_header_name
         self.auth_header_format = auth_header_format
 
@@ -87,14 +93,18 @@ class LightRag(VectorDb):
         """Async upsert documents into the vector database"""
         pass
 
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         result = asyncio.run(self.async_search(query, limit=limit, filters=filters))
         return result if result is not None else []
 
     async def async_search(
-        self, query: str, limit: Optional[int] = None, filters: Optional[Dict[str, Any]] = None
+        self, query: str, limit: Optional[int] = None, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     ) -> Optional[List[Document]]:
         mode: str = "hybrid"  # Default mode, can be "local", "global", or "hybrid"
+        if filters is not None:
+            log_warning("Filters are not supported in LightRAG. No filters will be applied.")
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 response = await client.post(
@@ -372,3 +382,7 @@ class LightRag(VectorDb):
             metadata (Dict[str, Any]): The metadata to update
         """
         raise NotImplementedError("update_metadata not supported for LightRag - use LightRag's native methods")
+
+    def get_supported_search_types(self) -> List[str]:
+        """Get the supported search types for this vector database."""
+        return []  # LightRag doesn't use SearchType enum

agno/vectordb/llamaindex/llamaindexdb.py

@@ -1,7 +1,8 @@
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Union
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
-from agno.utils.log import logger
+from agno.utils.log import log_warning, logger
 from agno.vectordb.base import VectorDb
 
 try:
@@ -17,8 +18,18 @@ class LlamaIndexVectorDb(VectorDb):
     knowledge_retriever: BaseRetriever
     loader: Optional[Callable] = None
 
-    def __init__(self, knowledge_retriever: BaseRetriever, loader: Optional[Callable] = None, **kwargs):
+    def __init__(
+        self,
+        knowledge_retriever: BaseRetriever,
+        loader: Optional[Callable] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        **kwargs,
+    ):
         super().__init__(**kwargs)
+        # Initialize base class with name and description
+        super().__init__(name=name, description=description)
+
         self.knowledge_retriever = knowledge_retriever
         self.loader = loader
 
@@ -58,7 +69,9 @@ class LlamaIndexVectorDb(VectorDb):
         logger.warning("LlamaIndexVectorDb.async_upsert() not supported - please check the vectorstore manually.")
         raise NotImplementedError
 
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def search(
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
+    ) -> List[Document]:
         """
         Returns relevant documents matching the query.
 
@@ -72,6 +85,9 @@ class LlamaIndexVectorDb(VectorDb):
         Raises:
             ValueError: If the knowledge retriever is not of type BaseRetriever.
         """
+        if filters is not None:
+            log_warning("Filters are not supported in LlamaIndex. No filters will be applied.")
+
         if not isinstance(self.knowledge_retriever, BaseRetriever):
             raise ValueError(f"Knowledge retriever is not of type BaseRetriever: {self.knowledge_retriever}")
 
@@ -89,7 +105,7 @@ class LlamaIndexVectorDb(VectorDb):
         return documents
 
     async def async_search(
-        self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None
+        self, query: str, limit: int = 5, filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     ) -> List[Document]:
         return self.search(query, limit, filters)
 
@@ -144,3 +160,7 @@ class LlamaIndexVectorDb(VectorDb):
             "LlamaIndexVectorDb.delete_by_content_id() not supported - please check the vectorstore manually."
         )
         return False
+
+    def get_supported_search_types(self) -> List[str]:
+        """Get the supported search types for this vector database."""
+        return []  # LlamaIndexVectorDb doesn't use SearchType enum