[feat][abaoxomtieu] threading code, and llm refactor

apis/V1/configs/llm_config.py

@@ -16,4 +16,4 @@ llm = GoogleGenerativeAI(
     verbose=True,
     google_api_key=GOOGLE_API_KEY,
 )
-set_llm_cache(InMemoryCache())
+# set_llm_cache(InMemoryCache())

apis/V1/configs/thread_config.py

@@ -0,0 +1,20 @@
+import asyncio
+import functools
+import threading
+from concurrent.futures import ThreadPoolExecutor
+
+# Create a ThreadPoolExecutor
+executor = ThreadPoolExecutor()
+
+def run_in_thread(func, *args, **kwargs):
+    loop = asyncio.get_event_loop()
+    func_name = func.__name__
+
+    # Function to wrap the original function to print the thread ID
+    def wrapper(*args, **kwargs):
+        thread_id = threading.get_ident()
+        print(f"[Running function '{func_name}' in thread ID: {thread_id}]")
+        return func(*args, **kwargs)
+
+    # Run the wrapped function in the executor
+    return loop.run_in_executor(executor, functools.partial(wrapper, *args, **kwargs))

apis/V1/prompts/prompt.py

@@ -0,0 +1,107 @@
+def classify_document_prompt(document):
+    prompt = f"""
+    Document: {document}
+
+    You must return in JSON format, field is mandatory:
+    {{
+        type: must be "Business" or "RnD" based on document content
+    }}
+    """
+    return prompt
+
+
+def translate_BIZ_prompt(
+    abstract,
+    sentence,
+    word,
+    language_1="English",
+    language_2="Vietnamese",
+):
+    prompt = f"""
+    # Introduction: You are an expert in translating {language_1} words into {language_2} for Finance and Economics topics. Translate the given word or phrase based on the context of the abstract and sentence.
+    # System instructions:
+    0. No yapping
+    1. Read the abstract, surrounding sentences which contain word/phase to understand the context of paper/article.
+    2. Translate the given word or phrase into {language_2} using the context.
+    3. If the word or phrase is not in the dictionary, return "not in dictionary" with {language_2} language.
+    4. If the word or phrase is an acronym, expand it and provide the translation.
+    5. Output must be in Vietnamese.
+    # Examples:
+    Abstract: "Inflation is the rate at which the general level of prices for goods and services rises, eroding purchasing power."
+    Surrounding sentences: "Inflation is the rate at which the general level of prices for goods and services rises."
+    Word: "Inflation"
+    Answer: lạm phát
+
+    Abstract: "GDP, or Gross Domestic Product, measures the total value of all goods and services produced within a country in a given period."
+    Surrounding sentences: "GDP, or Gross Domestic Product, measures the total value of all goods and services produced within a country."
+    Word: "GDP"
+    Answer: Tổng sản phẩm quốc nội
+    
+    # Here is my question:
+    Abstract: {abstract}
+    Surrounding sentences: {sentence}
+    Word: {word}
+    Answer: 
+    
+    # Output must be returned in Vietnamese only:
+    
+"""
+    return prompt
+
+
+def translate_RnD_prompt(
+    abstract,
+    sentence,
+    word,
+    language_1="English",
+    language_2="Vietnamese",
+):
+    prompt = f"""
+    # Introduction: You are an expert in translating {language_1} words into {language_2} for Finance and Economics topics. Translate the given word or phrase based on the context of the abstract and sentence.
+    # System instructions:
+    0. No yapping
+    1. Read the abstract, surrounding sentences which contain word/phase to understand the context of paper/article.
+    2. Translate the given word or phrase into {language_2} using the context.
+    3. If the word or phrase is not in the dictionary, return "not in dictionary" with {language_2} language.
+    4. If the word or phrase is an acronym, expand it and provide the translation.
+    5. Output must be in Vietnamese.
+    # Examples:
+    Abstract: "In recent years, there has been significant progress in the development of Transformer-based models for natural language processing tasks. These models, such as BERT, have set new benchmarks in various language understanding tasks."
+    Surrounding sentence: "outperforms a Transformer-based BERT baseline on the GLUE language benchmark"
+    Word: "outperforms"
+    Answer: vượt trội
+
+    Abstract: "The integration of machine learning techniques in medical diagnosis has shown promising results. Our study focuses on the application of deep learning to detect early signs of diseases."
+    Surrounding sentence: "The integration of machine learning techniques in medical diagnosis has shown promising results."
+    Word: "integration"
+    Answer: tích hợp
+    
+    # Here is my question:
+    Abstract: {abstract}
+    Surrounding sentences: {sentence}
+    Word: {word}
+    Answer: 
+    
+    # Output must be returned in Vietnamese only:
+"""
+    return prompt
+
+
+def summarizeNclassify_doc_prompt(docs):
+    prompt = f"""
+    # Introduction: You are an expert in summarizing and classify document/paper type.
+    # System instructions: 
+    0. No yapping
+    1. You are given a first part of document/paper.
+    2. You must understand the document/paper
+    3. Return a concise summary about the document/paper, and the classifing document type.
+    
+    # Here is my document/paper: {docs}
+
+    You must return in JSON format, field is mandatory:
+    {{
+        summary: a concise summary about the document/paper
+        type: must be "Business" or "RnD" based on document content
+    }}
+"""
+    return prompt

apis/V1/prompts/translate.py

@@ -57,4 +57,4 @@ prompt = PromptTemplate(
 )
 
 # Chain the prompt with the LLM and parser
-chain = prompt | llm | parser
+chain_translate = prompt | llm | parser

apis/V1/prompts/translate_abstract_BIZ.py

@@ -11,6 +11,7 @@ system_instructions = SystemMessage(
 2. Translate the given word or phrase into Vietnamese using the context.
 3. If the word or phrase is not in the dictionary, return "Không tìm thấy từ này trong từ điển".
 4. If the word or phrase is an acronym, expand it and provide the translation.
+5. Output must be in Vietnamese.
 """
 )
 
@@ -22,25 +23,26 @@ system_examples = SystemMessage(
 Abstract: "The efficient market hypothesis (EMH) suggests that financial markets are informationally efficient, meaning that asset prices fully reflect all available information."
 Sentence: "The efficient market hypothesis (EMH) suggests that financial markets are informationally efficient."
 Word: "efficient"
-Answer: "hiệu quả"
+hiệu quả
 
 Abstract: "Quantitative easing (QE) is a monetary policy whereby a central bank purchases government securities or other securities from the market in order to increase the money supply and encourage lending and investment."
 Sentence: "Quantitative easing (QE) is a monetary policy whereby a central bank purchases government securities."
 Word: "Quantitative easing"
-Answer: "Nới lỏng định lượng"
+Nới lỏng định lượng
 
 Abstract: "Inflation is the rate at which the general level of prices for goods and services rises, eroding purchasing power."
 Sentence: "Inflation is the rate at which the general level of prices for goods and services rises."
 Word: "Inflation"
-Answer: "lạm phát"
+lạm phát
 
 Abstract: "GDP, or Gross Domestic Product, measures the total value of all goods and services produced within a country in a given period."
 Sentence: "GDP, or Gross Domestic Product, measures the total value of all goods and services produced within a country."
 Word: "GDP"
-Answer: "Tổng sản phẩm quốc nội"
+Tổng sản phẩm quốc nội
 """
 )
 
+
 # Function to create the prompt template dynamically based on input
 def create_prompt(abstract, sentence, word):
     user_message = HumanMessage(
@@ -52,7 +54,6 @@ Word: {word}
 Translate the word to Vietnamese based on the context of the sentence and abstract.
 If the word is not in the dictionary, return "Không tìm thấy từ này trong từ điển".
 If it is an acronym, expand and translate it.
-{{format_instructions}}
 """
     )
     messages = [system_instructions, system_examples, user_message]
@@ -60,15 +61,14 @@ If it is an acronym, expand and translate it.
 
     return chat_prompt.format()
 
+
 # Use the JSON output parser
-parser = JsonOutputParser(pydantic_object=TranslateOutput)
 
 # Create the prompt template
 prompt = PromptTemplate(
     input_variables=["abstract", "sentence", "word"],
     template=create_prompt("{abstract}", "{sentence}", "{word}"),
-    partial_variables={"format_instructions": parser.get_format_instructions()},
 )
 
 # Chain the prompt with the LLM and parser
-chain_BIZ = prompt | llm | parser
+chain_BIZ = prompt | llm

apis/V1/prompts/translate_abstract_RnD.py

@@ -10,6 +10,7 @@ system_instructions = SystemMessage(
 2. Translate the given word or phrase into Vietnamese using the context.
 3. If the word or phrase is not in the dictionary, return "Không tìm thấy từ này trong từ điển".
 4. If the word or phrase is an acronym, expand it and provide the translation.
+5. Output must be in Vietnamese.
 """
 )
 
@@ -20,25 +21,26 @@ system_examples = SystemMessage(
 Abstract: "In recent years, there has been significant progress in the development of Transformer-based models for natural language processing tasks. These models, such as BERT, have set new benchmarks in various language understanding tasks."
 Sentence: "outperforms a Transformer-based BERT baseline on the GLUE language benchmark"
 Word: "outperforms"
-Answer: "vượt trội"
+vượt trội
 
 Abstract: "This paper explores the use of reinforcement learning in optimizing neural network architectures. We demonstrate that our approach achieves state-of-the-art results on several benchmark datasets."
 Sentence: "Our approach achieves state-of-the-art results on several benchmark datasets."
 Word: "approach"
-Answer: "phương pháp"
+phương pháp
 
 Abstract: "The integration of machine learning techniques in medical diagnosis has shown promising results. Our study focuses on the application of deep learning to detect early signs of diseases."
 Sentence: "The integration of machine learning techniques in medical diagnosis has shown promising results."
 Word: "integration"
-Answer: "tích hợp"
+tích hợp
 
 Abstract: "Transformer-based models like BERT have transformed NLP tasks by achieving new state-of-the-art results."
 Sentence: "Transformer-based models like BERT have transformed NLP tasks."
 Word: "BERT"
-Answer: "Bidirectional Encoder Representations from Transformers"
+Bidirectional Encoder Representations from Transformers
 """
 )
 
+
 def create_prompt(abstract, sentence, word):
     user_message = HumanMessage(
         content=f"""
@@ -49,7 +51,6 @@ Word: {word}
 Translate the word to Vietnamese based on the context of the sentence and abstract.
 If the word is not in the dictionary, return "Không tìm thấy từ này trong từ điển".
 If it is an acronym, expand and translate it.
-{{format_instructions}}
 """
     )
     messages = [system_instructions, system_examples, user_message]
@@ -57,15 +58,14 @@ If it is an acronym, expand and translate it.
 
     return chat_prompt.format()
 
+
 # Use the JSON output parser
-parser = JsonOutputParser(pydantic_object=TranslateOutput)
 
 # Create the prompt template
 prompt = PromptTemplate(
     input_variables=["abstract", "sentence", "word"],
     template=create_prompt("{abstract}", "{sentence}", "{word}"),
-    partial_variables={"format_instructions": parser.get_format_instructions()},
 )
 
 # Chain the prompt with the LLM and parser
-chain_RnD = prompt | llm | parser
+chain_RnD = prompt | llm

apis/V1/routes/auth.py

@@ -9,8 +9,8 @@ from ..utils.response_fmt import jsonResponseFmt
 from ..middlewares.auth_middleware import get_current_user
 from ..utils.utils import get_current_time
 from ..models.users import UserSchema
+from ..configs.thread_config import run_in_thread
 
-print(get_current_time())
 router = APIRouter(prefix="/auth", tags=["Authentications"])
 
 collection_name = db["user"]
@@ -22,9 +22,8 @@ user_dependency = Annotated[User, Depends(get_current_user)]
     "/login", status_code=status.HTTP_200_OK, response_model=_LoginResponseInterface
 )
 async def login(credential: Credential):
-    # print("credential", credential)
-    token = login_control(credential.credential)
-    print("token", token)
+
+    token = await run_in_thread(login_control, credential.credential)
     return jsonResponseFmt({"token": token})
 
 
@@ -35,7 +34,7 @@ async def get_me(user: user_dependency):
     return jsonResponseFmt(user)
 
 
-@router.get("/logout", status_code=status.HTTP_200_OK)
+@router.post("/logout", status_code=status.HTTP_200_OK)
 async def logout(user: user_dependency, response: Response):
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)

apis/V1/routes/chat.py

@@ -0,0 +1,80 @@
+from fastapi import APIRouter, status
+from ..utils.response_fmt import jsonResponseFmt
+from ..configs.thread_config import run_in_thread
+from ..prompts.document_type_clf import chain_type_classify
+from ..prompts.summarize_doc import chain_summarize
+from ..prompts.translate_abstract_BIZ import chain_BIZ
+from ..prompts.translate_abstract_RnD import chain_RnD
+from ..configs.llm_config import llm
+from ..prompts.prompt import (
+    classify_document_prompt,
+    summarizeNclassify_doc_prompt,
+    translate_BIZ_prompt,
+    translate_RnD_prompt,
+)
+from pydantic import BaseModel, Field
+from langchain_core.output_parsers import JsonOutputParser
+
+router = APIRouter(prefix="/llm", tags=["LLM"])
+
+# @router.post("/classify_document_type", status_code=status.HTTP_200_OK)
+# async def classify_document_type(text: str):
+#     def type_classify(text):
+#         response = chain_type_classify.invoke(text)
+#         return response
+#     result = await run_in_thread(type_classify, text)
+#     return jsonResponseFmt(result)
+
+class SummaryNClassifyDocument(BaseModel):
+    text: str
+@router.post("/summary", status_code=status.HTTP_200_OK)
+async def summarize_doc(body: SummaryNClassifyDocument):
+    import asyncio
+    await asyncio.sleep(5)
+    prompt = summarizeNclassify_doc_prompt(body.text)
+    result = await run_in_thread(llm.invoke, prompt)
+    result = JsonOutputParser().parse(result)
+    return jsonResponseFmt(result)
+
+
+class TranslateAbstract(BaseModel):
+    abstract: str = Field(description="Abstract of paper", min_length=1)
+    sentence: str = Field(description="Surrounding sentence to translate", min_length=1)
+    word: str = Field(description="Word to translate", min_length=1)
+
+
+@router.post("/translate_RnD", status_code=status.HTTP_200_OK)
+async def translate_RnD(body: TranslateAbstract):
+
+    result = await run_in_thread(
+        llm.invoke, translate_RnD_prompt(body.abstract, body.sentence, body.word)
+    )
+    # result = JsonOutputParser().parse(result)
+    print(result)
+    return jsonResponseFmt(result)
+
+
+@router.post("/translate_BIZ", status_code=status.HTTP_200_OK)
+async def translate_BIZ(body: TranslateAbstract):
+
+    result = await run_in_thread(
+        translate_BIZ_prompt, body.abstract, body.sentence, body.word
+    )
+    # result = JsonOutputParser().parse(result)
+    print(result)
+    return jsonResponseFmt(result)
+
+
+class ClassifyDocumentType(BaseModel):
+    text: str = Field(description="Text to classify", min_length=1)
+
+
+@router.post("/classify_document_type", status_code=status.HTTP_200_OK)
+async def classify_document_type(body: ClassifyDocumentType):
+    # def type_classify(text):
+    #     response = chain_type_classify.invoke(text)
+    #     return response
+
+    result = await run_in_thread(llm.invoke, summarize_doc(body.text))
+    result = JsonOutputParser().parse(result)
+    return jsonResponseFmt(result)

apis/V1/routes/project.py

@@ -1,4 +1,15 @@
-from fastapi import APIRouter, status, Path, Depends, Query, File, Form, UploadFile, HTTPException, BackgroundTasks
+from fastapi import (
+    APIRouter,
+    status,
+    Path,
+    Depends,
+    Query,
+    File,
+    Form,
+    UploadFile,
+    HTTPException,
+    BackgroundTasks,
+)
 from fastapi.responses import FileResponse
 import os
 import re
@@ -14,53 +25,71 @@ from ..providers.firebase_provider import (
     delete_file_from_storage,
     download_file_from_storage,
     list_all_files_in_storage,
-    upload_file_to_storage)
+    upload_file_to_storage,
+)
 from ..utils.utils import get_current_time
+from ..configs.thread_config import run_in_thread
+from pydantic import BaseModel, Field
+
 router = APIRouter(prefix="/project", tags=["Projects"])
 collection = db["project"]
 
 user_dependency = Annotated[User, Depends(get_current_user)]
 
 
-@router.get('/list', status_code=status.HTTP_200_OK)
+@router.post("/list", status_code=status.HTTP_200_OK)
 async def list_projects(user: user_dependency):
     if user is None:
         return jsonResponseFmt(None, "Authentication failed", 401)
     user_id = user.get("id")
-    projects = ProjectSchema.read_all_project_by_user_id(user_id)
-    return jsonResponseFmt(projects, "List of projects", 200)
+    result = await run_in_thread(ProjectSchema.read_all_project_by_user_id, user_id)
+    return jsonResponseFmt(result, "List of projects", 200)
+
 
+class ProjectDetail(BaseModel):
+    project_id: str = Field(description="Project ID", min_length=1)
 
-@router.get('/{project_id}', status_code=status.HTTP_200_OK)
-async def get_project(background_tasks: BackgroundTasks, user: user_dependency, project_id: str = Path(min_length=0)):
+
+@router.post("/get_project", status_code=status.HTTP_200_OK)
+async def get_project(
+    background_tasks: BackgroundTasks,
+    user: user_dependency,
+    body: ProjectDetail,
+):
     if user is None:
         return jsonResponseFmt(None, "Authentication failed", 401)
     user_id = user.get("id")
-    project_data = ProjectSchema.read_project_by_id(project_id, user_id)
+    project_data = await run_in_thread(
+        ProjectSchema.read_project_by_id, body.project_id, user_id
+    )
     if project_data is None:
         jsonResponseFmt(None, "Project not found", 404)
     file_name = project_data.get("file")
-    sanitized_file_name = re.sub(r'[<>:"/\\|?*]', '_', file_name)
+    sanitized_file_name = re.sub(r'[<>:"/\\|?*]', "_", file_name)
     destination = "storage/" + sanitized_file_name
-    download_file_from_storage(
-        file_name=file_name, destination_path=destination)
+    await run_in_thread(download_file_from_storage, file_name, destination)
 
     def remove_file(path: str):
         os.remove(path)
+
     background_tasks.add_task(remove_file, destination)
-    return FileResponse(path=destination, filename="file.pdf", media_type='application/pdf')
+    return FileResponse(
+        path=destination, filename="file.pdf", media_type="application/pdf"
+    )
 
 
-@router.post('/create', status_code=status.HTTP_201_CREATED)
+@router.post("/create", status_code=status.HTTP_201_CREATED)
 async def create_project(
     user: user_dependency,
     title: str = Form(min_length=1, max_length=100),
-    file: UploadFile = File(...)
+    file: UploadFile = File(...),
 ):
     if user is None:
         return jsonResponseFmt(None, "Authentication failed", 401)
     if file.content_type != "application/pdf":
-        return jsonResponseFmt(None, "Invalid file format. Only PDF files are allowed", 400)
+        return jsonResponseFmt(
+            None, "Invalid file format. Only PDF files are allowed", 400
+        )
     try:
         file_path = os.path.join("storage/", file.filename)
         user_id = user.get("id")
@@ -68,8 +97,10 @@ async def create_project(
         file_name = user_email + "/" + get_current_time() + "_" + file.filename
         with open(file_path, "wb") as buffer:
             shutil.copyfileobj(file.file, buffer)
-        upload_file_to_storage(file_path=file_path, file_name=file_name)
-        ProjectSchema(title=title, file=file_name).create(user_id)
+
+        await run_in_thread(upload_file_to_storage, file_path, file_name)
+        await run_in_thread(ProjectSchema(title=title, file=file_name).create, user_id)
+        # ProjectSchema(title=title, file=file_name).create(user_id)
         return jsonResponseFmt(None, "Project created successfully", 201)
     except Exception as e:
         return jsonResponseFmt(None, str(e), 500)

apis/V1/routes/upload.py

@@ -8,6 +8,8 @@ from ..middlewares.auth_middleware import get_current_user
 from ..utils.response_fmt import jsonResponseFmt
 import os
 from typing import Dict
+from ..configs.thread_config import run_in_thread
+from pydantic import BaseModel, Field
 
 router = APIRouter(prefix="/upload", tags=["Upload"])
 
@@ -16,25 +18,34 @@ user_dependency = Annotated[User, Depends(get_current_user)]
 UserService: Dict[str, AskImage] = {}
 
 
-@router.get("/pdf_url", status_code=status.HTTP_200_OK)
-async def upload_pdf_URL(user: user_dependency, pdf_url: str = Query(min_length=3)):
+class UploadPDFURL(BaseModel):
+    pdf_url: str = Field(description="An url of a pdf paper", min_length=1)
+
+
+@router.post("/pdf_url", status_code=status.HTTP_200_OK)
+async def upload_pdf_URL(user: user_dependency, body: UploadPDFURL):
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)
     try:
         user_id = user["id"]
         user_name = user["name"]
-        response = requests.get(pdf_url)
+        response = requests.get(body.pdf_url)
         if response.status_code == 200:
             os.makedirs("storage", exist_ok=True)
             with open(f"storage//{user_id}.pdf", "wb") as f:
                 f.write(response.content)
             UserService[user_id] = AskImage()
-            convert_result = UserService[user_id].uploaded(
-                f"storage//{user_id}.pdf", user_name)
+            convert_result = await run_in_thread(
+                UserService[user_id].uploaded, f"storage//{user_id}.pdf", user_name
+            )
+            # convert_result = UserService[user_id].uploaded(
+            #     f"storage//{user_id}.pdf", user_name)
             if convert_result == True:
                 return jsonResponseFmt(None, msg="Success", code=200)
             else:
-                return jsonResponseFmt(None, msg="Uploaded but unable to extract content", code=409)
+                return jsonResponseFmt(
+                    None, msg="Uploaded but unable to extract content", code=409
+                )
     except:
         return jsonResponseFmt(None, msg="Error", code=400)
 
@@ -51,25 +62,40 @@ async def upload_pdf(pdf_file: UploadFile, user: user_dependency):
         with open(f"storage//{user_id}.pdf", "wb") as f:
             f.write(contents)
         UserService[user_id] = AskImage()
-        convert_result = UserService[user_id].uploaded(
-            f"storage//{user_id}.pdf", user_name)
+        # convert_result = UserService[user_id].uploaded(
+        #     f"storage//{user_id}.pdf", user_name
+        # )
+        convert_result = await run_in_thread(
+            UserService[user_id].uploaded, f"storage//{user_id}.pdf", user_name
+        )
         if convert_result == True:
             return jsonResponseFmt(None, msg="Success", code=200)
         else:
-            return jsonResponseFmt(None, msg="Uploaded but unable to extract content", code=409)
+            return jsonResponseFmt(
+                None, msg="Uploaded but unable to extract content", code=409
+            )
     except Exception as e:
         print(e)
         return jsonResponseFmt(None, msg="e", code=400)
 
 
-@router.get("/explain_word", status_code=status.HTTP_200_OK)
-async def explain_word(user: user_dependency, current_page: int = Query(ge=0), word: str = Query(min_length=2)):
+class ExplainWord(BaseModel):
+    current_page: int = Field(description="Current page is seeing", ge=0)
+    word: str = Field("Word or phase need to be explain", min_length=1)
+
+
+@router.post("/explain_word", status_code=status.HTTP_200_OK)
+async def explain_word(
+    user: user_dependency,
+    body: ExplainWord,
+):
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)
     user_id = user["id"]
     try:
         AI = UserService[user_id]
-        res = AI.explain_word(word=word, current_page=current_page)
+        # res = AI.explain_word(word=word, current_page=current_page)
+        res = await run_in_thread(AI.explain_word, body.word, body.current_page)
         return jsonResponseFmt(res, msg="Success", code=200)
 
     except Exception as e:
@@ -77,14 +103,25 @@ async def explain_word(user: user_dependency, current_page: int = Query(ge=0), w
         return jsonResponseFmt(None, msg=e, code=400)
 
 
-@router.get("/ask", status_code=status.HTTP_200_OK)
-async def ask(user: user_dependency, current_page: int = Query(ge=0), question: str = Query(min_length=1)):
+class AskQuestion(BaseModel):
+    current_page: int = Field(..., ge=0)
+    question: str = Field(..., min_length=1)
+
+
+@router.post("/ask", status_code=status.HTTP_200_OK)
+async def ask(
+    user: user_dependency,
+    body: AskQuestion,
+):
+    print("current", body.current_page)
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)
     user_id = user["id"]
     try:
         AI = UserService[user_id]
-        res = AI.ask(question=question, current_page=current_page)
+
+        # res = AI.ask(question=question, current_page=current_page)
+        res = await run_in_thread(AI.ask, body.question, body.current_page)
         return jsonResponseFmt(res, msg="Success", code=200)
     except Exception as e:
         print(e)

apis/V1/routes/word.py

@@ -11,6 +11,7 @@ from ..controllers.word_controller import (
     update_word_controller,
     delete_word_controller,
 )
+from ..configs.thread_config import run_in_thread
 
 router = APIRouter(prefix="/word", tags=["Words"])
 collection = db["word"]
@@ -18,11 +19,12 @@ collection = db["word"]
 user_dependency = Annotated[User, Depends(get_current_user)]
 
 
-@router.get("/listWord", status_code=status.HTTP_200_OK)
+@router.post("/listWord", status_code=status.HTTP_200_OK)
 async def list_words(user: user_dependency):
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)
-    word = list_word_controlller(user)
+    # word = list_word_controlller(user)
+    word = await run_in_thread(list_word_controlller, user)
     return jsonResponseFmt(word)
 
 
@@ -31,7 +33,8 @@ async def add_word(word: Word, user: user_dependency):
     print("word", word)
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)
-    return add_word_controller(user, word)
+    # return add_word_controller(user, word)
+    return await run_in_thread(add_word_controller, user, word)
 
 
 @router.put("/updateWord/{word_id}", status_code=status.HTTP_200_OK)
@@ -40,17 +43,16 @@ async def update_word(
 ):
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)
-    return update_word_controller(user, word_id, word_data)
+    # return update_word_controller(user, word_id, word_data)
+    return await run_in_thread(update_word_controller, user, word_id, word_data)
 
 
 @router.delete("/deleteWord/{word_id}", status_code=status.HTTP_200_OK)
 async def delete_word(user: user_dependency, word_id: str = Path(min_length=1)):
     if user is None:
         return jsonResponseFmt(None, msg="Authentication failed", code=401)
-    return delete_word_controller(user, word_id)
+    # return delete_word_controller(user, word_id)
+    return await run_in_thread(delete_word_controller, user, word_id)
+
 
 
-@router.post("/test")
-async def test(word: Word):
-    user_id = "6661455a0b293703d07f73ba"
-    print(WordSchema(**word.dict()).add_word(user_id))

apis/__init__.py

@@ -3,9 +3,11 @@ from .V1.routes.auth import router as auth_router
 from .V1.routes.word import router as word_router
 from .V1.routes.upload import router as upload_router
 from .V1.routes.project import router as project_router
+from .V1.routes.chat import router as chat_router
 api_router = APIRouter()
 
 api_router.include_router(auth_router)
 api_router.include_router(word_router)
 api_router.include_router(upload_router)
 api_router.include_router(project_router)
+api_router.include_router(chat_router)

apis/create_app.py

@@ -19,11 +19,12 @@ def create_app():
     # CORs handling
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=["*"],
+        allow_origins=["*"],  # Allow all origins
         allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
+        allow_methods=["*"],  # Allow all methods (GET, POST, etc.)
+        allow_headers=["*"],  # Allow all headers
     )
+
     add_routes(
         app,
         chain_summarize,