agno 2.0.1__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
@@ -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
@@ -343,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
@@ -352,80 +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": 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
+        # 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)
 
-            log_debug(f"Asynchronously inserted {len(data)} documents")
+                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}")
-            # 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."""
@@ -446,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.
+
+        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[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]:
         """
         Search for documents matching the query.
 
@@ -467,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:
@@ -508,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
@@ -521,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)
+        # Wrap sync search method to avoid sync/async table synchronization issues
+        return self.search(query=query, limit=limit, filters=filters)
 
-        # 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}")
@@ -587,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}")
@@ -616,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 []
@@ -950,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"])
 
@@ -1002,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]

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
 
@@ -64,10 +72,16 @@ class LangChainVectorDb(VectorDb):
         raise NotImplementedError
 
     def search(
-        self, query: str, num_documents: Optional[int] = None, filters: Optional[Dict[str, Any]] = None
+        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
@@ -79,7 +93,7 @@ class LangChainVectorDb(VectorDb):
         if self.vectorstore is not None and self.knowledge_retriever is None:
             log_debug("Creating knowledge retriever")
             if self.search_kwargs is None:
-                self.search_kwargs = {"k": num_documents}
+                self.search_kwargs = {"k": limit}
             if filters is not None:
                 self.search_kwargs.update(filters)
             self.knowledge_retriever = self.vectorstore.as_retriever(search_kwargs=self.search_kwargs)
@@ -91,7 +105,7 @@ class LangChainVectorDb(VectorDb):
         if not isinstance(self.knowledge_retriever, BaseRetriever):
             raise ValueError(f"Knowledge retriever is not of type BaseRetriever: {self.knowledge_retriever}")
 
-        log_debug(f"Getting {num_documents} relevant documents for query: {query}")
+        log_debug(f"Getting {limit} relevant documents for query: {query}")
         lc_documents: List[LangChainDocument] = self.knowledge_retriever.invoke(input=query)
         documents = []
         for lc_doc in lc_documents:
@@ -104,9 +118,9 @@ class LangChainVectorDb(VectorDb):
         return documents
 
     async def async_search(
-        self, query: str, num_documents: Optional[int] = None, 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, num_documents, filters)
+        return self.search(query, limit, filters)
 
     def drop(self) -> None:
         raise NotImplementedError
@@ -143,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