tmp

src/enums/question.py

@@ -11,4 +11,12 @@ class QuestionTypeEnum(str, Enum):
 
 class ChoiceTypeEnum(str, Enum):
     SINGLE_CHOICE = "single-choice"
-    MULTIPLE_CHOICE = "multiple-choice"
+    MULTIPLE_CHOICE = "multiple-choice"
+
+class ParagraphQuestionTypeEnum(str, Enum):
+    FACT = "fact"
+    MAIN_IDEA = "main_idea"
+    VOCAB = "vocab"
+    INFERENCE = "inference"
+    PURPOSE = "purpose"
+    

src/factories/gen_question_for_paragraph/types/base.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+
+from src.interfaces.question import ICreateQuestionForParagraph
+
+class Question(ABC):        
+    @abstractmethod
+    def generate_questions(self, data: ICreateQuestionForParagraph):
+        pass

src/factories/gen_question_for_paragraph/types/synthetic.py

@@ -0,0 +1,14 @@
+import random
+
+from src.enums import QuestionTypeEnum
+from src.interfaces.question import ICreateQuestionForParagraph
+from src.factories.gen_question_for_paragraph.types.base import Question
+from src.llms.models import GeminiLLM
+
+
+class ParagraphQuestion(Question):
+    def __init__(self):
+        self.llm = GeminiLLM()
+
+    def generate_questions(self, data: ICreateQuestionForParagraph):
+        

src/interfaces/question.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel, Field, field_validator
-from typing import Optional, List
+from typing import Optional, List, Text
 
-from src.enums import QuestionTypeEnum
+from src.enums import QuestionTypeEnum, ParagraphQuestionTypeEnum
 
 
 class ModelInput(BaseModel):
@@ -9,13 +9,19 @@ class ModelInput(BaseModel):
     user_id: Optional[str] = None
     context: str
     name: str
+    
+class IQuestionConfig(BaseModel):
+    question_type: QuestionTypeEnum
+    list_words: List[str]
+    num_question: int = Field(..., ge=1, le=5)
 
-class ICQuestion(BaseModel):
-    context: str
-    name: str
+class ICreateQuestionForParagraph(BaseModel):
+    description: Text
+    num_ans_per_question: int = Field(..., ge=2, le=6)
+    list_create_question: List[IQuestionConfig]
 
 class ICreateQuestion(BaseModel):
-    question_type: QuestionTypeEnum
+    question_type: ParagraphQuestionTypeEnum
     list_words: List[str]
     num_ans_per_question: int = Field(..., ge=2, le=10)
     num_question: int = Field(..., ge=1, le=10)

src/llms/prompts/paragraph.py

@@ -0,0 +1,55 @@
+GEN_QUESTION_FOR_PARAGRAPH = """
+You are an expert Artificial Intelligence specializing in creating reading comprehension questions from a given English paragraph for language learners. Your task is to generate a set of high-quality, diverse multiple-choice questions with a precise JSON structure.
+
+### Primary Task
+Generate a list of multiple-choice questions about the provided English paragraph, strictly adhering to the input parameters. The total number of questions must equal the sum of all count parameters (FACT_COUNT + MAIN_IDEA_COUNT + ...).
+
+### Input
+You will receive the following parameters:
+1.  **Paragraph (PARAGRAPH):** [The English text for which questions should be generated]
+2.  **Count of Fact-based Questions (FACT_COUNT):** [Integer]
+3.  **Count of Main Idea Questions (MAIN_IDEA_COUNT):** [Integer]
+4.  **Count of Vocabulary-in-Context Questions (VOCAB_COUNT):** [Integer]
+5.  **Count of Inference Questions (INFERENCE_COUNT):** [Integer]
+6.  **Count of Author's Purpose/Tone Questions (AUTHOR_PURPOSE_COUNT):** [Integer]
+7.  **Total Options Per Question (OPTIONS_PER_QUESTION):** [Integer, e.g., 4]
+
+### Detailed Guidelines
+
+1.  **Adherence to Counts:** Strictly adhere to the specified number of questions for each type.
+2.  **Language:** The questions, choices, and paragraph must all be in **English**.
+3.  **Answer Structure:** Each question must have **EXACTLY ONE** correct answer.
+
+#### Distractor Generation Rules
+* **Fact & Main Idea:** Distractors must contain information **present in the paragraph** but which does not correctly answer the question, or is a **slightly altered/incorrect fact**.
+* **Inference:** Distractors should be plausible-sounding inferences that **cannot be definitively proven** by the text alone.
+* **Vocabulary:** Distractors should be synonyms or related words that are **incorrect** in the specific context of the sentence.
+
+#### Specific Techniques for Each Question Type:
+* **Fact:** Focus on extracting Named Entities (NER) such as Names, Dates, Figures, or direct definitions.
+* **MainIdea:** Questions should start with phrases like: *What is the main idea of this paragraph?*, *Which of the following best summarizes...*
+* **Inference:** Questions must use keywords: *It can be inferred that...*, *What does the author imply by...*, *Which statement is most likely true based on...*
+* **Purpose:** Questions should focus on: *What is the author's primary purpose?*, *What is the tone of the paragraph?*
+
+### Output Format
+Generate a **single JSON object** (with no preceding or trailing text explanations) with the following structure:
+
+```json
+{
+  "paragraph": "[The English text used]",
+  "questions": [
+    {
+      "question": "...",
+      "type": "FACT", // Type must be one of the following exact values: FACT, MAIN_IDEA, VOCAB, INFERENCE, PURPOSE
+      "choices": [
+        "...", // Option A
+        "...", // Option B
+        "...", // Option C
+        "..."  // Option D (Total choices must equal OPTIONS_PER_QUESTION)
+      ],
+      "answer": "A" // The correct answer (must be a single character 'A', 'B', 'C', or 'D')
+    }
+    // ... (continue until the total required number of questions is met)
+  ]
+}
+"""

src/llms/tools/paragraph.py

@@ -0,0 +1,48 @@
+GEN_QUESTION_FOR_PARAGRAPH_OUTPUT_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "parse_paragraph_questions",
+        "description": (
+            "Parse the generated reading comprehension questions from a paragraph into structured JSON."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "paragraph": {
+                    "type": "string",
+                    "description": "The English paragraph used to generate questions."
+                },
+                "questions": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "question": {
+                                "type": "string",
+                                "description": "The text of the generated multiple-choice question."
+                            },
+                            "type": {
+                                "type": "string",
+                                "enum": ["FACT", "MAIN_IDEA", "VOCAB", "INFERENCE", "PURPOSE"],
+                                "description": "The type of question."
+                            },
+                            "choices": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of answer options. Length must match `options_per_question`."
+                            },
+                            "answer": {
+                                "type": "string",
+                                "enum": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"],
+                                "description": "The correct answer (single character representing the choice)."
+                            }
+                        },
+                        "required": ["question", "type", "choices", "answer"]
+                    },
+                    "description": "List of generated questions with choices and answers."
+                }
+            },
+            "required": ["paragraph", "questions"]
+        }
+    }
+}

src/routers/public/quesion.py

@@ -4,7 +4,7 @@ from fastapi.responses import JSONResponse
 from src.factories.gen_question.factory import create_question_instance
 from src.utils.response import res_ok
 from src.utils.text_process import vietnamese_to_english, english_to_vietnamese, get_all_summary, get_all_questions
-from src.interfaces.question import ModelInput, ICQuestion, ICreateQuestion
+from src.interfaces.question import ModelInput, ICreateQuestion, ICreateQuestionForParagraph
 from src.services.AI.abstractive_summarizer import AbstractiveSummarizer
 from src.services.AI.question_generator import QuestionGenerator    
 from src.services.AI.false_ans_generator import FalseAnswerGenerator
@@ -21,37 +21,10 @@ async def generate_question(body: ICreateQuestion):
         num_question=body.num_question,
         num_ans_per_question=body.num_ans_per_question,
     )
-    print(list_questions)
     return JSONResponse(status_code=200, content=res_ok(list_questions))
 
 @route.post('/sentence')
-async def generate_questions_from_sentence(body: ICQuestion, request: Request):
-    """Process user request
-
-    Args:
-        request (ModelInput): request model
-        bg_task (BackgroundTasks): run process_request() on other thread
-        and respond to request
-
-    Returns:
-        dict(str: int): response
-    """
-    # bg_task.add_task(process_request, request)
-
-
-    # # Tạo một dictionary để lưu trữ kết quả
-    # results = []
-
-    # def background_task():
-    #     nonlocal results
-    #     results = process_request(request)
-
-    # # Thêm tác vụ nền để xử lý yêu cầu
-    # bg_task.add_task(background_task)
-
-
-    # Thực hiện xử lý yêu cầu và lưu kết quả vào Firestore
-    # Không dùng background vì để nó chạy trong cùng 1 thread để chờ xử lí xong mới có results
+async def generate_questions_from_sentence(body: ICreateQuestionForParagraph, request: Request):
     new_questions = []
     error_sentences = []
     model_input = ModelInput(**body.model_dump(), user_id=None)