rag-gateway
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
zhaoqingang
2025-03-04 370120fd4154ce6c5f69d16a4a343a016cf2e816 
 app/api/v2/chat.py


@@ -1,69 +1,143 @@


import json


import uuid


from typing import List




from fastapi import Depends, APIRouter


from fastapi import Depends, APIRouter, File, UploadFile


from sqlalchemy.orm import Session


from starlette.responses import StreamingResponse, Response


from werkzeug.http import HTTP_STATUS_CODES




from app.api import get_current_user, get_api_key


from app.config.const import dialog_chat, advanced_chat, base_chat, agent_chat, workflow_chat, basic_chat, \


    smart_message_error, http_400, http_500, http_200


from app.models import UserModel


from app.models.base_model import get_db


from app.models.v2.chat import RetrievalRequest


from app.models.v2.session_model import ChatData


from app.service.v2.chat import service_chat_dialog, get_chat_info, service_chat_basic, \


    service_chat_workflow, service_chat_parameters, service_chat_sessions


    service_chat_workflow, service_chat_parameters, service_chat_sessions, service_chat_upload, \


    service_chat_sessions_list, service_chat_session_log, service_chunk_retrieval, service_base_chunk_retrieval




chat_router_v2 = APIRouter()






@chat_router_v2.post("/{chatId}/run")


async def api_chat_dialog(chatId:str, dialog: ChatData, db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)




# 对话


@chat_router_v2.post("/chat/{chatId}/completions")


async def api_chat_dialog(chatId:str, dialog: ChatData, current_user: UserModel = Depends(get_current_user),db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    chat_info = await get_chat_info(db, chatId)


    if not chat_info:


        error_msg = json.dumps({"message": smart_message_error, "error": "**ERROR**: parameter exception", "status": http_400})


        error_msg = json.dumps(


            {"message": smart_message_error, "error": "\n**ERROR**: parameter exception", "status": http_400})


        return StreamingResponse(f"data: {error_msg}\n\n",


                                 media_type="text/event-stream")


    session_id = dialog.sessionId


    if chat_info.mode == dialog_chat:


        if not dialog.query:


            error_msg = json.dumps(


                {"message": smart_message_error, "error": "**ERROR**: question cannot be empty.", "status": http_400})


            return StreamingResponse(f"data: {error_msg}\n\n",


                                     media_type="text/event-stream")


        if not session_id:


            session = await service_chat_sessions(db, chatId, dialog.query)


            if not session or session.get("code") != 0:


                error_msg = json.dumps(


                    {"message": smart_message_error, "error": "**ERROR**: chat agent error", "status": http_500})


                return StreamingResponse(f"data: {error_msg}\n\n",


                                         media_type="text/event-stream")


            session_id = session.get("data", {}).get("id")


        return StreamingResponse(service_chat_dialog(db, chatId ,dialog.query, session_id, 1, chat_info.mode), media_type="text/event-stream")


    elif chat_info.mode == agent_chat or chat_info.mode == workflow_chat or chat_info.mode == advanced_chat or chat_info.mode == base_chat:


        if not session_id:


            session_id = str(uuid.uuid4()).replace("-", "")


        return StreamingResponse(service_chat_workflow(db, chatId, dialog, session_id, 1, chat_info.mode),


                                 media_type="text/event-stream")


    elif chat_info.mode == basic_chat:


        return StreamingResponse(service_chat_basic(db, chatId, dialog.question, dialog_chat.sessionId, 1),


                                 media_type="text/event-stream")


    else:


        error_msg = json.dumps({"message": smart_message_error, "error": "**ERROR**: chat agent error", "status": http_500})


    if not dialog.query:


        error_msg = json.dumps(


            {"message": smart_message_error, "error": "\n**ERROR**: question cannot be empty.", "status": http_400})


        return StreamingResponse(f"data: {error_msg}\n\n",


                                 media_type="text/event-stream")


    if not session_id:


        session = await service_chat_sessions(db, chatId, dialog.query)


        print(session)


        if not session or session.get("code") != 0:


            error_msg = json.dumps(


                {"message": smart_message_error, "error": "\n**ERROR**: chat agent error", "status": http_500})


            return StreamingResponse(f"data: {error_msg}\n\n",


                                     media_type="text/event-stream")


        session_id = session.get("data", {}).get("id")


    return StreamingResponse(service_chat_dialog(db, chatId, dialog.query, session_id, current_user.id, chat_info.mode),


                             media_type="text/event-stream")




@chat_router_v2.post("/agent/{chatId}/completions")


async def api_chat_dialog(chatId:str, dialog: ChatData, current_user: UserModel = Depends(get_current_user),db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    chat_info = await get_chat_info(db, chatId)


    if not chat_info:


        error_msg = json.dumps(


            {"message": smart_message_error, "error": "\n**ERROR**: parameter exception", "status": http_400})


        return StreamingResponse(f"data: {error_msg}\n\n",


                                 media_type="text/event-stream")


    session_id = dialog.sessionId


    if not session_id:


        session_id = str(uuid.uuid4()).replace("-", "")


    return StreamingResponse(service_chat_workflow(db, chatId, dialog, session_id, current_user.id, chat_info.mode),


                             media_type="text/event-stream")






@chat_router_v2.get("/{chatId}/parameters")


async def api_chat_parameters(chatId:str, db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


@chat_router_v2.post("/workflow/{chatId}/completions")


async def api_chat_dialog(chatId:str, dialog: ChatData, current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    chat_info = await get_chat_info(db, chatId)


    if not chat_info:


        error_msg = json.dumps(


            {"message": smart_message_error, "error": "\n**ERROR**: parameter exception", "status": http_400})


        return StreamingResponse(f"data: {error_msg}\n\n",


                                 media_type="text/event-stream")


    session_id = dialog.sessionId


    if not session_id:


        session_id = str(uuid.uuid4()).replace("-", "")


    return StreamingResponse(service_chat_workflow(db, chatId, dialog, session_id, current_user.id, chat_info.mode),


                             media_type="text/event-stream")






@chat_router_v2.post("/complex/{chatId}/completions")


async def api_chat_dialog(chatId:str, dialog: ChatData, current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    chat_info = await get_chat_info(db, chatId)


    if not chat_info:


        error_msg = json.dumps(


            {"message": smart_message_error, "error": "\n**ERROR**: parameter exception", "status": http_400})


        return StreamingResponse(f"data: {error_msg}\n\n",


                                 media_type="text/event-stream")


    session_id = dialog.sessionId


    if not session_id:


        session_id = str(uuid.uuid4()).replace("-", "")






    return StreamingResponse(service_chat_basic(db, chatId, dialog, session_id, current_user.id, chat_info.mode),


                             media_type="text/event-stream")








@chat_router_v2.get("/chat/{chatId}/parameters")


async def api_chat_parameters(chatId:str, current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    status_code = http_200


    data = await service_chat_parameters(db, chatId, 1)


    data = await service_chat_parameters(db, chatId, current_user.id)


    if not data:


        status_code = http_400


    return Response(json.dumps(data), media_type="application/json", status_code=status_code)


        data = json.dumps({"code": http_400})


    return Response(data, media_type="application/json", status_code=status_code)




# @chat_router_v2.get("/{chatId}/parameters")


# async def api_chat_parameters(chatId:str, db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


#     status_code = http_200


#     data = await service_chat_parameters(db, chatId, 1)


#     if not data:


#         status_code = http_400


#     return Response(json.dumps(data), media_type="application/json", status_code=status_code)




@chat_router_v2.post("/{chatId}/upload")


async def api_chat_upload(chatId:str, file: List[UploadFile] = File(...), current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    status_code = http_200


    data = await service_chat_upload(db, chatId, file, current_user.id)


    if not data:


        status_code = http_400


        data = "{}"


    return Response(data, media_type="application/json", status_code=status_code)








@chat_router_v2.get("/chat/sessions")


async def api_chat_sessions(chatId:str, current:int=1, pageSize:int=100, keyword:str="", current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    data = await service_chat_sessions_list(db, chatId, current, pageSize, current_user.id, keyword)


    return Response(data, media_type="application/json", status_code=http_200)






@chat_router_v2.get("/chat/session_log")


async def api_chat_sessions(sessionId:str, current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


    data = await service_chat_session_log(db, sessionId)


    return Response(data, media_type="application/json", status_code=http_200)








# @chat_router_v2.post("/conversation/mindmap")


# async def api_conversation_mindmap(chatId:str, current:int=1, current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)


#     data = await service_chat_sessions_list(db, chatId, current, pageSize, current_user.id, keyword)


#     return Response(data, media_type="application/json", status_code=http_200)








@chat_router_v2.post("/retrieval")


async def retrieve_chunks(request_data: RetrievalRequest, api_key: str = Depends(get_api_key)):


    records = await service_chunk_retrieval(request_data.query, request_data.knowledge_id, request_data.retrieval_setting.top_k, request_data.retrieval_setting.score_threshold, api_key)


    return {"records": records}