Testing

enhanced_rag_mcq.py

@@ -657,43 +657,6 @@ class EnhancedRAGMCQGenerator:
             print(f"Raw response: {response[:500]}...")
             raise ValueError(f"Failed to parse LLM response: {e}")
 
-    def _batch_invoke(self, prompts: List[str]) -> List[str]:
-        if not prompts:
-            return []
-
-        # Try to use transformers pipeline (batch mode)
-        pl = getattr(self.llm, "pipeline", None)
-        if pl is not None:
-            try:
-                # Call the pipeline with a list. Transformers will return a list of generation outputs.
-                raw_outputs = pl(prompts)
-
-                responses = []
-                for out in raw_outputs:
-                    # The pipeline may return either a dict (single result) or a list of dicts (if return_full_text or num_return_sequences was set)
-                    if isinstance(out, list) and out:
-                        text = out[0].get("generated_text", "")
-                    elif isinstance(out, dict):
-                        text = out.get("generated_text", "")
-                    else:
-                        # fallback: coerce to string
-                        text = str(out)
-                    responses.append(text)
-
-                if len(responses) == len(prompts):
-                    return responses
-                else:
-                    print("⚠️ Batch pipeline returned unexpected shape — falling back")
-            except Exception as e:
-                # Batch mode failed. Fall back to sequential invocations.
-                print(f"⚠️ Batch invoke failed: {e}. Falling back to sequential.")
-
-        # Sequential invocation to preserve behavior
-        results = []
-        for p in prompts:
-            results.append(self.llm.invoke(p))
-        return results
-
     def generate_batch(self,
                       topics: List[str],
                       question_per_topic: int = 5,
@@ -707,9 +670,8 @@ class EnhancedRAGMCQGenerator:
         if question_types is None:
             question_types = [QuestionType.DEFINITION, QuestionType.APPLICATION]
 
+        mcqs = []
         total_questions = len(topics) * question_per_topic
-        prompt_metadatas = [] # stores tuples (topic, difficulty, question_type)
-        formatted_prompts = []
 
         print(f"🎯 Generating {total_questions} MCQs...")
 
@@ -717,76 +679,21 @@ class EnhancedRAGMCQGenerator:
             print(f"📝 Processing topic {i+1}/{len(topics)}: {topic}")
 
             for j in range(question_per_topic):
-                difficulty = difficulties[j % len(difficulties)]
-                question_type = question_types[j % len(question_types)]
-
-                query = topic
-
-                # retrieve context once per prompt
-                contexts = self.retriever.retrieve_diverse_contexts(query, k=self.config.get("k", 5)) if hasattr(self, "retriever") else []
-                context_text = "\n\n".join([d.page_content for d in contexts]) if contexts else topic
-
-                # Build prompt with PromptTemplateManager
-                prompt_template = self.template_manager.get_template(question_type)
-                prompt_input = {
-                    "context": context_text,
-                    "topic": topic,
-                    "difficulty": difficulty.value if hasattr(difficulty, 'value') else str(difficulty),
-                    "question_type": question_type.value if hasattr(question_type, 'value') else str(question_type)
-                }
-                formatted = prompt_template.format(**prompt_input)
-
-                # Length check and fallback
-                is_safe, token_count = self.check_prompt_length(formatted)
-                if not is_safe:
-                    truncated = formatted[: self.config.get("max_prompt_chars", 2000)]
-                    formatted = truncated
-
-                prompt_metadatas.append((topic, difficulty, question_type))
-                formatted_prompts.append(formatted)
-
-        total = len(formatted_prompts)
-        if total == 0:
-            return []
+                try:
+                    # Cycle through difficulties and question types
+                    difficulty = difficulties[j % len(difficulties)]
+                    question_type = question_types[j % len(question_types)]
 
-        print(f"📦 Sending {total} prompts to the LLM in batch mode (if supported)")
-        start_t = time.time()
-        raw_responses = self._batch_invoke(formatted_prompts)
-        elapsed = time.time() - start_t
-        print(f"⏱ LLM batch time: {elapsed:.2f}s for {total} prompts")
+                    mcq = self.generate_mcq(topic, difficulty, question_type)
+                    mcqs.append(mcq)
 
-        # Parse raw responses back into MCQQuestion objects
-        mcqs = []
-        for meta, response in zip(prompt_metadatas, raw_responses):
-            topic, difficulty, question_type = meta
-            try:
-                response_data = self._extract_json_from_response(response)
-
-                # Reconstruct MCQQuestion
-                options = []
-                for label, text in response_data["options"].items():
-                    is_correct = label == response_data["correct_answer"]
-                    options.append(self.MCQOption(label=label, text=text, is_correct=is_correct))
-
-                mcq = self.MCQQuestion(
-                    question_id=response_data.get("id", None),
-                    topic=topic,
-                    question_text=response_data["question"],
-                    options=options,
-                    explanation=response_data.get("explanation", ""),
-                    difficulty=(difficulty if hasattr(difficulty, 'name') else difficulty),
-                    question_type=(question_type if hasattr(question_type, 'name') else question_type),
-                    confidence_score=response_data.get("confidence_score", 0.0)
-                )
-
-                if hasattr(self, 'validator'):
-                    mcq = self.validator.calculate_quality_score(mcq)
-
-                mcqs.append(mcq)
-            except Exception as e:
-                print(f"❌ Failed parsing response for topic={topic}: {e}")
+                    print(f"  ✅ Generated question {j+1}/{question_per_topic} "
+                          f"(Quality: {mcq.confidence_score:.1f})")
+
+                except Exception as e:
+                    print(f"  ❌ Failed to generate question {j+1}: {e}")
 
-        print(f"🎉 Generated {len(mcqs)}/{total} MCQs successfully (batched)")
+        print(f"🎉 Generated {len(mcqs)}/{total_questions} MCQs successfully")
         return mcqs
 
     def export_mcqs(self, mcqs: List[MCQQuestion], output_path: str):

fastapi_app.py

@@ -68,14 +68,10 @@ async def mcq_gen(
 ):
     if not generator:
         raise HTTPException(status_code=500, detail="Generator not initialized")
-    
-    print("generator initialized")
 
     topic_list = [t.strip() for t in topics.split(',') if t.strip()]
     if not topic_list:
         raise HTTPException(status_code=400, detail="At least one topic must be provided")
-    
-    print("topic validated")
 
     # Validate and convert enum values
     try:
@@ -84,16 +80,12 @@ async def mcq_gen(
         valid_difficulties = [d.value for d in DifficultyLevel]
         raise HTTPException(status_code=400, detail=f"Invalid difficulty. Must be one of: {valid_difficulties}")
 
-    print("difficulty validated")
-
     try:
         qtype_enum = QuestionType(qtype.lower())
     except ValueError:
         valid_types = [q.value for q in QuestionType]
         raise HTTPException(status_code=400, detail=f"Invalid question type. Must be one of: {valid_types}")
 
-    print("question type validated")
-
     # Save uploaded PDF to temporary folder
     filename = file.filename if file.filename else "uploaded_file"
     file_path = os.path.join(tmp_folder, filename)
@@ -101,8 +93,6 @@ async def mcq_gen(
         shutil.copyfileobj(file.file, buffer)
     file.file.close()
 
-    print(f"file read and written to {file_path}")
-
     try:
         # Load and index the uploaded document
         docs, _ = generator.load_documents(tmp_folder)
@@ -110,8 +100,6 @@ async def mcq_gen(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Document processing error: {e}")
 
-    print("loaded and indexed the document")
-
     start_time = time.time()
     try:
         mcqs = generator.generate_batch(