MCQ test1

api/main.py

@@ -473,8 +473,39 @@ async def generate_mcqs(request: MCQGenerateRequest):
         else:
             raise HTTPException(status_code=400, detail="Invalid source_type")
         
-        # Filter valid MCQs
+        # Filter valid MCQs first.
         valid_mcqs = [mcq for mcq in mcqs if mcq_validator.validate_mcq(mcq)]
+
+        # If strict validation drops too many questions, top up with normalized
+        # parsed MCQs so caller still gets requested count.
+        if len(valid_mcqs) < request.num_questions:
+            for mcq in mcqs:
+                if len(valid_mcqs) >= request.num_questions:
+                    break
+                if mcq in valid_mcqs:
+                    continue
+
+                question = str(mcq.get("question", "")).strip()
+                options_map = mcq.get("options", {}) or {}
+                correct = str(mcq.get("correct_answer", "A")).strip().upper()
+
+                normalized = {
+                    "question": question,
+                    "options": {
+                        "A": str(options_map.get("A", "Option A")),
+                        "B": str(options_map.get("B", "Option B")),
+                        "C": str(options_map.get("C", "Option C")),
+                        "D": str(options_map.get("D", "Option D")),
+                    },
+                    "correct_answer": correct if correct in ["A", "B", "C", "D"] else "A",
+                    "explanation": str(mcq.get("explanation", "Based on the provided context.")),
+                    "difficulty": str(mcq.get("difficulty", request.difficulty or "medium")).lower(),
+                }
+
+                if normalized["question"]:
+                    valid_mcqs.append(normalized)
+
+        valid_mcqs = valid_mcqs[:request.num_questions]
         
         return {
             "status": "success",

mcq/generator.py

@@ -39,8 +39,23 @@ class MCQGenerator:
         
         # Parse MCQs from response
         mcqs = self._parse_mcqs_improved(response, text, num_questions)
-        
-        # Ensure we return the requested number or fewer
+
+        # Retry once with stricter generation if count is short.
+        if len(mcqs) < num_questions:
+            retry_prompt = prompt + "\nIMPORTANT: Return EXACTLY the requested number of questions in the specified format."
+            retry_response = self.llm.generate(
+                prompt=retry_prompt,
+                max_new_tokens=min(tokens_needed + 250, 1400),
+                temperature=0.6
+            )
+            retry_mcqs = self._parse_mcqs_improved(retry_response, text, num_questions)
+            mcqs = self._merge_unique_mcqs(mcqs, retry_mcqs)
+
+        # Last-resort synthetic top-up so API returns requested count.
+        if len(mcqs) < num_questions:
+            synthetic = self._generate_synthetic_mcqs(text, num_questions - len(mcqs))
+            mcqs = self._merge_unique_mcqs(mcqs, synthetic)
+
         return mcqs[:num_questions]
     
     def generate_from_document(
@@ -194,6 +209,7 @@ Now generate {num_questions} questions:
         question = lines[0].rstrip('?')
         if question.endswith(':'):
             question = question[:-1]
+        question = re.sub(r'^\s*(Q|Question)\s*\d+\s*[:.)-]\s*', '', question, flags=re.IGNORECASE).strip()
         
         if not question or len(question) < 5:
             return None
@@ -239,6 +255,22 @@ Now generate {num_questions} questions:
             }
         
         return None
+
+    def _merge_unique_mcqs(self, base: List[Dict], extra: List[Dict]) -> List[Dict]:
+        """Merge MCQ lists and keep unique questions by normalized text."""
+        merged = []
+        seen = set()
+
+        for item in (base + extra):
+            question = str(item.get('question', '')).strip()
+            key = re.sub(r'^\s*(Q|Question)\s*\d+\s*[:.)-]\s*', '', question, flags=re.IGNORECASE).lower()
+            if not key or key in seen:
+                continue
+            seen.add(key)
+            item['question'] = re.sub(r'^\s*(Q|Question)\s*\d+\s*[:.)-]\s*', '', question, flags=re.IGNORECASE).strip()
+            merged.append(item)
+
+        return merged
     
     def _parse_mcqs_fallback(self, response: str) -> List[Dict]:
         """Fallback parsing for various formats"""