feat: (0.6)New UI (#1855)

Co-authored-by: 夏姜 <wenfengjiang.jwf@digital-engine.com>
Co-authored-by: aries_ckt <916701291@qq.com>
Co-authored-by: wb-lh513319 <wb-lh513319@alibaba-inc.com>
Co-authored-by: csunny <cfqsunny@163.com>

dbgpt/app/knowledge/api.py

@@ -8,8 +8,10 @@ from fastapi import APIRouter, Depends, File, Form, UploadFile
 
 from dbgpt._private.config import Config
 from dbgpt.app.knowledge.request.request import (
+    ChunkEditRequest,
     ChunkQueryRequest,
     DocumentQueryRequest,
+    DocumentRecallTestRequest,
     DocumentSummaryRequest,
     DocumentSyncRequest,
     EntityExtractRequest,
@@ -19,7 +21,10 @@ from dbgpt.app.knowledge.request.request import (
     KnowledgeSpaceRequest,
     SpaceArgumentRequest,
 )
-from dbgpt.app.knowledge.request.response import KnowledgeQueryResponse
+from dbgpt.app.knowledge.request.response import (
+    ChunkQueryResponse,
+    KnowledgeQueryResponse,
+)
 from dbgpt.app.knowledge.service import KnowledgeService
 from dbgpt.app.openapi.api_v1.api_v1 import no_stream_generator, stream_generator
 from dbgpt.app.openapi.api_view_model import Result
@@ -33,8 +38,11 @@ from dbgpt.rag import ChunkParameters
 from dbgpt.rag.embedding.embedding_factory import EmbeddingFactory
 from dbgpt.rag.knowledge.base import ChunkStrategy
 from dbgpt.rag.knowledge.factory import KnowledgeFactory
+from dbgpt.rag.retriever import BaseRetriever
 from dbgpt.rag.retriever.embedding import EmbeddingRetriever
 from dbgpt.serve.rag.api.schemas import (
+    ChunkServeRequest,
+    DocumentServeRequest,
     KnowledgeConfigResponse,
     KnowledgeDomainType,
     KnowledgeStorageType,
@@ -81,6 +89,7 @@ def space_list(request: KnowledgeSpaceRequest):
     try:
         return Result.succ(knowledge_space_service.get_knowledge_space(request))
     except Exception as e:
+        logger.exception(f"Space list error!{str(e)}")
         return Result.failed(code="E000X", msg=f"space list error {e}")
 
 
@@ -93,21 +102,73 @@ def space_delete(request: KnowledgeSpaceRequest):
         return Result.failed(code="E000X", msg=f"space delete error {e}")
 
 
-@router.post("/knowledge/{space_name}/arguments")
-def arguments(space_name: str):
+@router.post("/knowledge/{space_id}/arguments")
+def arguments(space_id: str):
     print(f"/knowledge/space/arguments params:")
     try:
-        return Result.succ(knowledge_space_service.arguments(space_name))
+        return Result.succ(knowledge_space_service.arguments(space_id))
     except Exception as e:
         return Result.failed(code="E000X", msg=f"space arguments error {e}")
 
 
-@router.post("/knowledge/{space_name}/argument/save")
-def arguments_save(space_name: str, argument_request: SpaceArgumentRequest):
+@router.post("/knowledge/{space_name}/recall_test")
+def recall_test(
+    space_name: str,
+    request: DocumentRecallTestRequest,
+):
+    print(f"/knowledge/{space_name}/recall_test params:")
+    try:
+        return Result.succ(knowledge_space_service.recall_test(space_name, request))
+    except Exception as e:
+        return Result.failed(code="E000X", msg=f"{space_name} recall_test error {e}")
+
+
+@router.get("/knowledge/{space_id}/recall_retrievers")
+def recall_retrievers(
+    space_id: str,
+):
+    print(f"/knowledge/{space_id}/recall_retrievers params:")
+    try:
+        logger.info(f"get_recall_retrievers {space_id}")
+
+        subclasses = set()
+
+        def recursively_find_subclasses(cls):
+            for subclass in cls.__subclasses__():
+                subclasses.add(subclass)
+                recursively_find_subclasses(subclass)
+
+        recursively_find_subclasses(BaseRetriever)
+
+        retrievers_with_name = []
+        base_name_method = BaseRetriever.name.__func__
+        for cls in subclasses:
+            if hasattr(cls, "name"):
+                cls_name_method = getattr(cls, "name")
+                if cls_name_method.__func__ != base_name_method:
+                    retrievers_with_name.append(cls)
+
+        retriever_names = {}
+        for retriever_cls in retrievers_with_name:
+            try:
+                name = retriever_cls.name()
+                retriever_names[name] = retriever_cls
+            except Exception as e:
+                logger.error(f"Error calling name method on {retriever_cls}: {e}")
+
+        return Result.succ(list(retriever_names.keys()))
+    except Exception as e:
+        return Result.failed(
+            code="E000X", msg=f"{space_id} get_recall_retrievers error {e}"
+        )
+
+
+@router.post("/knowledge/{space_id}/argument/save")
+def arguments_save(space_id: str, argument_request: SpaceArgumentRequest):
     print(f"/knowledge/space/argument/save params:")
     try:
         return Result.succ(
-            knowledge_space_service.argument_save(space_name, argument_request)
+            knowledge_space_service.argument_save(space_id, argument_request)
         )
     except Exception as e:
         return Result.failed(code="E000X", msg=f"space save error {e}")
@@ -127,6 +188,27 @@ def document_add(space_name: str, request: KnowledgeDocumentRequest):
         return Result.failed(code="E000X", msg=f"document add error {e}")
 
 
+@router.post("/knowledge/{space_name}/document/edit")
+def document_edit(
+    space_name: str,
+    request: KnowledgeDocumentRequest,
+    service: Service = Depends(get_rag_service),
+):
+    print(f"/document/edit params: {space_name}, {request}")
+    space = service.get({"name": space_name})
+    if space is None:
+        return Result.failed(
+            code="E000X",
+            msg=f"knowledge_space {space_name} can not be found",
+        )
+    serve_request = DocumentServeRequest(**request.dict())
+    serve_request.id = request.doc_id
+    try:
+        return Result.succ(service.update_document(request=serve_request))
+    except Exception as e:
+        return Result.failed(code="E000X", msg=f"document edit error {e}")
+
+
 @router.get("/knowledge/document/chunkstrategies")
 def chunk_strategies():
     """Get chunk strategies"""
@@ -211,12 +293,13 @@ async def space_config() -> Result[KnowledgeConfigResponse]:
 
 @router.post("/knowledge/{space_name}/document/list")
 def document_list(space_name: str, query_request: DocumentQueryRequest):
-    print(f"/document/list params: {space_name}, {query_request}")
+    logger.info(f"/document/list params: {space_name}, {query_request}")
     try:
         return Result.succ(
             knowledge_space_service.get_knowledge_documents(space_name, query_request)
         )
     except Exception as e:
+        logger.exception(f"document list error!{str(e)}")
         return Result.failed(code="E000X", msg=f"document list error {e}")
 
 
@@ -343,18 +426,53 @@ async def batch_document_sync(
         # )
         return Result.succ({"tasks": doc_ids})
     except Exception as e:
+        logger.exception("document sync batch error!")
         return Result.failed(code="E000X", msg=f"document sync batch error {e}")
 
 
 @router.post("/knowledge/{space_name}/chunk/list")
-def document_list(space_name: str, query_request: ChunkQueryRequest):
-    print(f"/document/list params: {space_name}, {query_request}")
+def chunk_list(
+    space_name: str,
+    query_request: ChunkQueryRequest,
+    service: Service = Depends(get_rag_service),
+):
+    print(f"/chunk/list params: {space_name}, {query_request}")
     try:
-        return Result.succ(knowledge_space_service.get_document_chunks(query_request))
+        query = {
+            "id": query_request.id,
+            "document_id": query_request.document_id,
+            "doc_name": query_request.doc_name,
+            "doc_type": query_request.doc_type,
+            "content": query_request.content,
+        }
+        chunk_res = service.get_chunk_list(
+            query, query_request.page, query_request.page_size
+        )
+        res = ChunkQueryResponse(
+            data=chunk_res.items,
+            total=chunk_res.total_count,
+            page=chunk_res.page,
+        )
+        return Result.succ(res)
     except Exception as e:
         return Result.failed(code="E000X", msg=f"document chunk list error {e}")
 
 
+@router.post("/knowledge/{space_name}/chunk/edit")
+def chunk_edit(
+    space_name: str,
+    edit_request: ChunkEditRequest,
+    service: Service = Depends(get_rag_service),
+):
+    print(f"/chunk/edit params: {space_name}, {edit_request}")
+    try:
+        serve_request = ChunkServeRequest(**edit_request.dict())
+        serve_request.id = edit_request.chunk_id
+        return Result.succ(service.update_chunk(request=serve_request))
+    except Exception as e:
+        return Result.failed(code="E000X", msg=f"document chunk edit error {e}")
+
+
 @router.post("/knowledge/{vector_name}/query")
 def similar_query(space_name: str, query_request: KnowledgeQueryRequest):
     print(f"Received params: {space_name}, {query_request}")