feat: knowledge exists and list_docs

Author: zakahan

veadk/database/database_adapter.py

@@ -28,6 +28,25 @@ def __init__(self, client):
 
         self.client: RedisDatabase = client
 
+    def index_exists(self, index: str) -> bool:
+        """
+        Check if the index (key) exists in Redis.
+
+        Args:
+            index: The Redis key to check
+
+        Returns:
+            bool: True if the key exists, False otherwise
+        """
+        try:
+            # Use Redis EXISTS command to check if key exists
+            return bool(self.client._client.exists(index))
+        except Exception as e:
+            logger.error(
+                f"Failed to check if key exists in Redis: index={index} error={e}"
+            )
+            return False
+
     def add(self, data: list[str], index: str, **kwargs):
         logger.debug(f"Adding documents to Redis database: index={index}")
 
@@ -99,6 +118,24 @@ def __init__(self, client):
 
         self.client: MysqlDatabase = client
 
+    def index_exists(self, index: str) -> bool:
+        """
+        Check if the table (index) exists in MySQL database.
+
+        Args:
+            index: The table name to check
+
+        Returns:
+            bool: True if the table exists, False otherwise
+        """
+        try:
+            return self.client.table_exists(index)
+        except Exception as e:
+            logger.error(
+                f"Failed to check if table exists in MySQL: index={index} error={e}"
+            )
+            return False
+
     def create_table(self, table_name: str):
         logger.debug(f"Creating table for SQL database: table_name={table_name}")
 
@@ -188,6 +225,25 @@ def __init__(self, client):
 
         self.client: OpenSearchVectorDatabase = client
 
+    def index_exists(self, index: str) -> bool:
+        """
+        Check if the collection (index) exists in OpenSearch.
+
+        Args:
+            index: The collection name to check
+
+        Returns:
+            bool: True if the collection exists, False otherwise
+        """
+        try:
+            self._validate_index(index)
+            return self.client.collection_exists(index)
+        except Exception as e:
+            logger.error(
+                f"Failed to check if collection exists in OpenSearch: index={index} error={e}"
+            )
+            return False
+
     def _validate_index(self, index: str):
         """
         Verify whether the string conforms to the naming rules of index_name in OpenSearch.
@@ -259,6 +315,25 @@ def __init__(self, client):
 
         self.client: VikingDatabase = client
 
+    def index_exists(self, index: str) -> bool:
+        """
+        Check if the collection (index) exists in VikingDB.
+
+        Args:
+            index: The collection name to check
+
+        Returns:
+            bool: True if the collection exists, False otherwise
+        """
+        try:
+            self._validate_index(index)
+            return self.client.collection_exists(index)
+        except Exception as e:
+            logger.error(
+                f"Failed to check if collection exists in VikingDB: index={index} error={e}"
+            )
+            return False
+
     def _validate_index(self, index: str):
         """
         Only English letters, numbers, and underscores (_) are allowed.
@@ -341,6 +416,25 @@ def __init__(self, client):
 
         self.client: VikingMemoryDatabase = client
 
+    def index_exists(self, index: str) -> bool:
+        """
+        Check if the collection (index) exists in VikingMemoryDB.
+
+        Note:
+            VikingMemoryDatabase does not support checking if a collection exists.
+            This method always returns False.
+
+        Args:
+            index: The collection name to check
+
+        Returns:
+            bool: Always returns False as VikingMemoryDatabase does not support this functionality
+        """
+        logger.warning(
+            "VikingMemoryDatabase does not support checking if a collection exists"
+        )
+        raise NotImplementedError("VikingMemoryDatabase does not support index_exists")
+
     def _validate_index(self, index: str):
         if not (
             isinstance(index, str)
@@ -388,6 +482,23 @@ def __init__(self, client):
 
         self.client: LocalDataBase = client
 
+    def index_exists(self, index: str) -> bool:
+        """
+        Check if the index exists in LocalDataBase.
+
+        Note:
+            LocalDataBase does not support checking if an index exists.
+            This method always returns False.
+
+        Args:
+            index: The index name to check (not used in LocalDataBase)
+
+        Returns:
+            bool: Always returns False as LocalDataBase does not support this functionality
+        """
+        logger.warning("LocalDataBase does not support checking if an index exists")
+        return True
+
     def add(self, data: list[str], **kwargs):
         self.client.add(data)
 

veadk/database/viking/viking_database.py

@@ -41,7 +41,8 @@
 doc_del_path = "/api/knowledge/collection/delete"
 doc_add_path = "/api/knowledge/doc/add"
 doc_info_path = "/api/knowledge/doc/info"
-list_docs_path = "/api/knowledge/point/list"
+list_point_path = "/api/knowledge/point/list"
+list_docs_path = "/api/knowledge/doc/list"
 delete_docs_path = "/api/knowledge/point/delete"
 
 
@@ -550,7 +551,7 @@ def list_chunks(
 
         list_doc_req = prepare_request(
             method="POST",
-            path=list_docs_path,
+            path=list_point_path,
             config=self.config,
             data=request_params,
         )
@@ -579,6 +580,38 @@ def list_chunks(
         ]
         return data
 
+    def list_docs(
+        self, collection_name: str, offset: int = 0, limit: int = -1
+    ) -> list[dict]:
+        request_params = {
+            "collection_name": collection_name,
+            "project": self.config.project,
+            "offset": offset,
+            "limit": limit,
+        }
+
+        list_doc_req = prepare_request(
+            method="POST",
+            path=list_docs_path,
+            config=self.config,
+            data=request_params,
+        )
+        resp = requests.request(
+            method=list_doc_req.method,
+            url="https://{}{}".format(g_knowledge_base_domain, list_doc_req.path),
+            headers=list_doc_req.headers,
+            data=list_doc_req.body,
+        )
+
+        result = resp.json()
+        if result["code"] != 0:
+            logger.error(f"Error in list_docs: {result['message']}")
+            raise ValueError(f"Error in list_docs: {result['message']}")
+
+        if not result["data"]["doc_list"]:
+            return []
+        return result["data"]["doc_list"]
+
     def delete_by_id(self, collection_name: str, id: str) -> bool:
         request_params = {
             "collection_name": collection_name,

veadk/knowledgebase/knowledgebase.py

@@ -158,6 +158,21 @@ def delete_doc(self, app_name: str, id: str) -> bool:
         index = build_knowledgebase_index(app_name)
         return self._adapter.delete_doc(index=index, id=id)
 
-    def list_docs(self, app_name: str, offset: int = 0, limit: int = 100) -> list[dict]:
+    def list_chunks(
+        self, app_name: str, offset: int = 0, limit: int = 100
+    ) -> list[dict]:
         index = build_knowledgebase_index(app_name)
         return self._adapter.list_chunks(index=index, offset=offset, limit=limit)
+
+    def list_docs(self, app_name: str, offset: int = 0, limit: int = 100) -> list[dict]:
+        if self.backend == "viking":
+            index = build_knowledgebase_index(app_name)
+            return self._adapter.list_docs(index=index, offset=offset, limit=limit)
+        else:
+            raise NotImplementedError(
+                f"list_docs not supported for {self.backend}, only viking support list_docs"
+            )
+
+    def exists(self, app_name: str) -> bool:
+        index = build_knowledgebase_index(app_name)
+        return self._adapter.index_exists(index=index)