Update main.py

main.py

@@ -125,7 +125,7 @@ def get_summarizer():
 def get_qa_model():
     global qa_model
     if qa_model is None:
-        qa_model= pipeline("question-answering", model="google-bert/bert-large-uncased-whole-word-masking-finetuned-squad")
+        qa_model= pipe = pipeline("question-answering", model="deepset/roberta-base-squad2")
     return qa_model
 
 def get_image_captioner():
@@ -804,77 +804,33 @@ async def summarize_document(request: Request, file: UploadFile = File(...)):
         
 
 
+from typing import Optional
+
 @app.post("/qa")
 @limiter.limit("5/minute")
 async def question_answering(
     request: Request,
-    file: UploadFile = File(...),
+    file: Optional[UploadFile] = File(None),  # Make file optional
     question: str = Form(...),
     language: str = Form("fr")
 ):
-    """
-    Enhanced QA endpoint with:
-    - Better error handling
-    - Model validation
-    - Detailed logging
-    - Original functionality preserved
-    """
-    # Validate input immediately
-    if not file.filename:
-        raise HTTPException(400, "No filename provided")
-    
+    # Validate question
     if not question.strip():
         raise HTTPException(400, "Question cannot be empty")
 
-    try:
-        # 1. File Processing
-        file_ext, content = await process_uploaded_file(file)
-        
-        # 2. Text Extraction with enhanced error context
+    # Check if the question is about the document
+    is_doc_question = any(
+        kw in question.lower() 
+        for kw in ["document", "file", "text", "this pdf", "this doc"]
+    )
+
+    # (A) If file is provided and question is about it → Document QA
+    if file and is_doc_question:
         try:
+            file_ext, content = await process_uploaded_file(file)
             text = extract_text(content, file_ext)
-            if not text.strip():
-                raise HTTPException(400, "No extractable text found")
-            
-            # Clean and truncate text (preserve original logic)
             text = re.sub(r'\s+', ' ', text).strip()[:5000]
-        except Exception as e:
-            logger.error(f"Text extraction failed for {file.filename}: {str(e)}", exc_info=True)
-            raise HTTPException(422, f"Failed to process {file_ext} file: {str(e)}")
 
-        # 3. Theme Detection (original logic preserved)
-        theme_keywords = ["thème", "sujet principal", "quoi le sujet", "theme", "main topic"]
-        if any(kw in question.lower() for kw in theme_keywords):
-            try:
-                summarizer = get_summarizer()
-                summary_output = summarizer(
-                    text,
-                    max_length=min(100, len(text)//4),
-                    min_length=30,
-                    do_sample=False,
-                    truncation=True
-                )
-                
-                theme = summary_output[0].get("summary_text", text[:200] + "...")
-                return {
-                    "question": question,
-                    "answer": f"Le document traite principalement de : {theme}",
-                    "confidence": 0.95,
-                    "language": language
-                }
-            except Exception as e:
-                logger.warning(f"Theme detection fallback for '{question}': {str(e)}")
-                theme = text[:200] + ("..." if len(text) > 200 else "")
-                return {
-                    "question": question,
-                    "answer": f"D'après le document : {theme}",
-                    "confidence": 0.7,
-                    "language": language,
-                    "warning": "theme_summary_fallback"
-                }
-
-        # 4. Standard QA (original logic preserved)
-        try:
             qa = get_qa_model()
             result = qa(question=question, context=text[:3000])
             
@@ -882,17 +838,41 @@ async def question_answering(
                 "question": question,
                 "answer": result["answer"],
                 "confidence": result["score"],
+                "source": "document",
                 "language": language
             }
         except Exception as e:
-            logger.error(f"QA failed for question '{question}': {str(e)}", exc_info=True)
-            raise HTTPException(500, "Failed to generate answer")
+            logger.error(f"Doc QA failed: {str(e)}")
+            raise HTTPException(500, "Failed to analyze document")
 
-    except HTTPException:
-        raise  # Re-raise existing HTTP exceptions
-    except Exception as e:
-        logger.critical(f"Unexpected error processing request: {str(e)}", exc_info=True)
-        raise HTTPException(500, "Internal server error")
+    # (B) If no file or general question → Open-domain QA (RAG)
+    else:
+        try:
+            rag = get_rag_model()
+            answer = rag(question)[0]["generated_text"]
+            
+            return {
+                "question": question,
+                "answer": answer,
+                "confidence": 0.8,  # RAG doesn't return scores
+                "source": "general knowledge",
+                "language": language
+            }
+        except Exception as e:
+            logger.error(f"RAG failed: {str(e)}")
+            raise HTTPException(500, "Failed to fetch general answer")
+
+
+
+
+
+
+
+
+
+
+
+            
 @app.post("/visualize/natural")
 async def natural_language_visualization(
     file: UploadFile = File(...),