agno 2.0.0rc2__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/vectordb/couchbase/couchbase.py

@@ -3,10 +3,10 @@ import time
 from datetime import timedelta
 from typing import Any, Dict, List, Optional, Union
 
+from agno.filters import FilterExpr
 from agno.knowledge.document import Document
 from agno.knowledge.embedder import Embedder
-from agno.knowledge.embedder.openai import OpenAIEmbedder
-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
 
 try:
@@ -61,11 +61,13 @@ class CouchbaseSearch(VectorDb):
         couchbase_connection_string: str,
         cluster_options: ClusterOptions,
         search_index: Union[str, SearchIndex],
-        embedder: Embedder = OpenAIEmbedder(),
+        embedder: Optional[Embedder] = None,
         overwrite: bool = False,
         is_global_level_index: bool = False,
         wait_until_index_ready: float = 0,
         batch_limit: int = 500,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
         **kwargs,
     ):
         """
@@ -75,6 +77,8 @@ class CouchbaseSearch(VectorDb):
             bucket_name (str): Name of the Couchbase bucket.
             scope_name (str): Name of the scope within the bucket.
             collection_name (str): Name of the collection within the scope.
+            name (Optional[str]): Name of the vector database.
+            description (Optional[str]): Description of the vector database.
             couchbase_connection_string (str): Couchbase connection string.
             cluster_options (ClusterOptions): Options for configuring the Couchbase cluster connection.
             search_index (Union[str, SearchIndex], optional): Search index configuration, either as index name or SearchIndex definition.
@@ -92,10 +96,18 @@ class CouchbaseSearch(VectorDb):
         self.collection_name = collection_name
         self.connection_string = couchbase_connection_string
         self.cluster_options = cluster_options
+        if embedder is None:
+            from agno.knowledge.embedder.openai import OpenAIEmbedder
+
+            embedder = OpenAIEmbedder()
+            log_info("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder = embedder
         self.overwrite = overwrite
         self.is_global_level_index = is_global_level_index
         self.wait_until_index_ready = wait_until_index_ready
+        # Initialize base class with name and description
+        super().__init__(name=name, description=description)
+
         self.kwargs = kwargs
         self.batch_limit = batch_limit
         if isinstance(search_index, str):
@@ -451,7 +463,12 @@ class CouchbaseSearch(VectorDb):
         if errors_occurred:
             logger.warning("Some errors occurred during the upsert operation. Please check logs for details.")
 
-    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]:
+        if isinstance(filters, List):
+            log_warning("Filter Expressions are not yet supported in Couchbase. No filters will be applied.")
+            filters = None
         """Search the Couchbase bucket for documents relevant to the query."""
         query_embedding = self.embedder.get_embedding(query)
         if query_embedding is None:
@@ -871,8 +888,44 @@ class CouchbaseSearch(VectorDb):
         async_collection_instance = await self.get_async_collection()
         all_docs_to_insert: Dict[str, Any] = {}
 
-        embed_tasks = [document.async_embed(embedder=self.embedder) for document in documents]
-        await asyncio.gather(*embed_tasks, return_exceptions=True)
+        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}")
+
+            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]
+            await asyncio.gather(*embed_tasks, return_exceptions=True)
 
         for document in documents:
             try:
@@ -937,8 +990,44 @@ class CouchbaseSearch(VectorDb):
         async_collection_instance = await self.get_async_collection()
         all_docs_to_upsert: Dict[str, Any] = {}
 
-        embed_tasks = [document.async_embed(embedder=self.embedder) for document in documents]
-        await asyncio.gather(*embed_tasks, return_exceptions=True)
+        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}")
+
+            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]
+            await asyncio.gather(*embed_tasks, return_exceptions=True)
 
         for document in documents:
             try:
@@ -989,8 +1078,11 @@ class CouchbaseSearch(VectorDb):
         logger.info(f"[async] Total successfully upserted: {total_upserted_count}, Total failed: {total_failed_count}.")
 
     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]:
+        if isinstance(filters, List):
+            log_warning("Filter Expressions are not yet supported in Couchbase. No filters will be applied.")
+            filters = None
         query_embedding = self.embedder.get_embedding(query)
         if query_embedding is None:
             logger.error(f"[async] Failed to generate embedding for query: {query}")
@@ -1225,7 +1317,6 @@ class CouchbaseSearch(VectorDb):
             rows = list(result.rows())  # Collect once
 
             for row in rows:
-                print(row)
                 self.collection.remove(row.get("doc_id"))
             log_info(f"Deleted {len(rows)} documents with metadata {metadata}")
             return True
@@ -1349,3 +1440,7 @@ class CouchbaseSearch(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 []  # CouchbaseSearch doesn't use SearchType enum

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
@@ -140,6 +157,29 @@ class LanceDb(VectorDb):
 
         log_debug(f"Initialized LanceDb with table: '{self.table_name}'")
 
+    def _prepare_vector(self, embedding) -> List[float]:
+        """Prepare vector embedding for insertion, ensuring correct dimensions and type."""
+        if embedding is not None and len(embedding) > 0:
+            # Convert to list of floats
+            vector = [float(x) for x in embedding]
+
+            # Ensure vector has correct dimensions if specified
+            if self.dimensions:
+                if len(vector) != self.dimensions:
+                    if len(vector) > self.dimensions:
+                        # Truncate if too long
+                        vector = vector[: self.dimensions]
+                        log_debug(f"Truncated vector from {len(embedding)} to {self.dimensions} dimensions")
+                    else:
+                        # Pad with zeros if too short
+                        vector.extend([0.0] * (self.dimensions - len(vector)))
+                        log_debug(f"Padded vector from {len(embedding)} to {self.dimensions} dimensions")
+
+            return vector
+        else:
+            # Fallback if embedding is None or empty
+            return [0.0] * (self.dimensions or 1536)
+
     async def _get_async_connection(self) -> lancedb.AsyncConnection:
         """Get or create an async connection to LanceDB."""
         if self.async_connection is None:
@@ -161,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
@@ -174,22 +213,37 @@ class LanceDb(VectorDb):
     async def async_create(self) -> None:
         """Create the table asynchronously if it does not exist."""
         if not await self.async_exists():
-            conn = await self._get_async_connection()
-            schema = self._base_schema()
+            try:
+                conn = await self._get_async_connection()
+                schema = self._base_schema()
 
-            log_debug(f"Creating table asynchronously: {self.table_name}")
-            self.async_table = await conn.create_table(self.table_name, schema=schema, mode="overwrite", exist_ok=True)
+                log_debug(f"Creating table asynchronously: {self.table_name}")
+                self.async_table = await conn.create_table(
+                    self.table_name, schema=schema, mode="overwrite", exist_ok=True
+                )
+                log_debug(f"Successfully created async table: {self.table_name}")
+            except Exception as e:
+                logger.error(f"Error creating async table: {e}")
+                # Try to fall back to sync table creation
+                try:
+                    log_debug("Falling back to sync table creation")
+                    self.table = self._init_table()
+                    log_debug("Sync table created successfully")
+                except Exception as sync_e:
+                    logger.error(f"Sync table creation also failed: {sync_e}")
+                    raise
 
     def _base_schema(self) -> pa.Schema:
+        # Use fixed-size list for vector field as required by LanceDB
+        if self.dimensions:
+            vector_field = pa.field(self._vector_col, pa.list_(pa.float32(), self.dimensions))
+        else:
+            # Fallback to dynamic list if dimensions not known (should be rare)
+            vector_field = pa.field(self._vector_col, pa.list_(pa.float32()))
+
         return pa.schema(
             [
-                pa.field(
-                    self._vector_col,
-                    pa.list_(
-                        pa.float32(),
-                        len(self.embedder.get_embedding("test")),  # type: ignore
-                    ),
-                ),
+                vector_field,
                 pa.field(self._id, pa.string()),
                 pa.field("payload", pa.string()),
             ]
@@ -278,7 +332,7 @@ class LanceDb(VectorDb):
             data.append(
                 {
                     "id": doc_id,
-                    "vector": document.embedding,
+                    "vector": self._prepare_vector(document.embedding),
                     "payload": json.dumps(payload),
                 }
             )
@@ -305,6 +359,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
@@ -314,60 +371,36 @@ class LanceDb(VectorDb):
             return
 
         log_debug(f"Inserting {len(documents)} documents")
-        data = []
-
-        # Prepare documents for insertion.
-        embed_tasks = [document.async_embed(embedder=self.embedder) for document 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": 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()
-
-            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")
+        # Still 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:
+                    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}")
+                    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)
 
-            # Refresh sync connection to see async changes
-            self._refresh_sync_connection()
-        except Exception as e:
-            logger.error(f"Error during async document insertion: {e}")
-            raise
+        # 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."""
@@ -388,11 +421,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.
 
@@ -409,6 +473,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:
@@ -450,11 +518,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
@@ -463,53 +534,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)
-
-        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
+        # Wrap sync search method to avoid sync/async table synchronization issues
+        return self.search(query=query, limit=limit, filters=filters)
 
-                # 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}")
@@ -529,7 +559,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}")
@@ -558,7 +590,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 []
@@ -638,26 +672,25 @@ class LanceDb(VectorDb):
             return await self.async_table.count_rows()
         return 0
 
-    def _async_get_count_sync(self) -> int:
-        """Helper method to run async_get_count in a new thread with its own event loop"""
-        import asyncio
-
-        return asyncio.run(self.async_get_count())
-
     def get_count(self) -> int:
         # If we have data in the async table but sync table isn't available, try to get count from async table
         if self.async_table is not None:
             try:
                 import asyncio
 
-                # Check if we're already in an async context
+                # Check if we're already in an event loop
                 try:
-                    return self._async_get_count_sync()
+                    asyncio.get_running_loop()
+                    # We're in an async context, can't use asyncio.run
+                    log_debug("Already in async context, falling back to sync table for count")
                 except RuntimeError:
                     # No event loop running, safe to use asyncio.run
-                    return asyncio.run(self.async_get_count())
-            except Exception:
-                pass
+                    try:
+                        return asyncio.run(self.async_get_count())
+                    except Exception as e:
+                        log_debug(f"Failed to get async count: {e}")
+            except Exception as e:
+                log_debug(f"Error in async count logic: {e}")
 
         if self.exists() and self.table:
             return self.table.count_rows()
@@ -893,17 +926,28 @@ class LanceDb(VectorDb):
                 logger.error("Table not initialized")
                 return
 
-            # Search for documents with the given content_id
-            query_filter = f"payload->>'content_id' = '{content_id}'"
-            results = self.table.search().where(query_filter).to_pandas()
+            # Get all documents and filter in Python (LanceDB doesn't support JSON operators)
+            total_count = self.table.count_rows()
+            results = self.table.search().select(["id", "payload"]).limit(total_count).to_pandas()
 
             if results.empty:
+                logger.debug("No documents found")
+                return
+
+            # Find matching documents with the given content_id
+            matching_rows = []
+            for _, row in results.iterrows():
+                payload = json.loads(row["payload"])
+                if payload.get("content_id") == content_id:
+                    matching_rows.append(row)
+
+            if not matching_rows:
                 logger.debug(f"No documents found with content_id: {content_id}")
                 return
 
             # Update each matching document
             updated_count = 0
-            for _, row in results.iterrows():
+            for row in matching_rows:
                 row_id = row["id"]
                 current_payload = json.loads(row["payload"])
 
@@ -945,3 +989,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]