Update flask_api.py

flask_api.py

@@ -21,6 +21,11 @@ app = Flask(__name__)
 UPLOAD_FOLDER = '/tmp/uploads'
 ALLOWED_EXTENSIONS = {'pdf', 'txt', 'csv'}
 
+# Minimum cosine similarity score for a retrieved chunk to be considered
+# relevant. Scores are in [0, 1]. 0.60 means the question must share at
+# least ~60% semantic overlap with the best matching passage in the doc.
+RELEVANCE_THRESHOLD = 0.60
+
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 
 # Global variables
@@ -29,9 +34,9 @@ current_pdf = None
 
 # ── Progress tracking ────────────────────────────────────────────────────────
 processing_progress = {
-    "stage": "idle",       # human-readable stage name
-    "percent": 0,          # 0-100
-    "message": "",         # optional detail line
+    "stage": "idle",
+    "percent": 0,
+    "message": "",
 }
 
 def set_progress(stage: str, percent: int, message: str = ""):
@@ -47,11 +52,11 @@ def allowed_file(filename):
 
 
 def process_pdf(pdf_path):
-    """Process the uploaded PDF and create the RAG index"""
+    """Process the uploaded document and create the RAG index."""
     global query_engine, current_pdf
 
     set_progress("Setting up models", 5)
-    print(f"📂 Processing PDF: {pdf_path}")
+    print(f"📂 Processing file: {pdf_path}")
     print("⏳ This may take 2-5 minutes...")
 
     llm = Groq(model="openai/gpt-oss-120b", temperature=0.0)
@@ -65,20 +70,16 @@ def process_pdf(pdf_path):
     Settings.node_parser = SentenceSplitter(chunk_size=1024, chunk_overlap=150)
 
     set_progress("Creating vector store", 25)
-    print("🔧 Creating vector store...")
     client = QdrantClient(":memory:")
     vector_store = QdrantVectorStore(client=client, collection_name="active_document")
     storage_context = StorageContext.from_defaults(vector_store=vector_store)
 
     set_progress("Loading document pages", 40)
-    print("📄 Loading documents...")
     documents = SimpleDirectoryReader(input_files=[pdf_path]).load_data()
 
     set_progress("Generating embeddings", 55, f"{len(documents)} chunks to embed")
     print("🔄 Creating embeddings (this is the slow part)...")
 
-    # Smoothly interpolate progress from 55→88% while embeddings run,
-    # so the bar doesn't freeze on 55% for 2+ minutes.
     import threading, time as _time
 
     stop_interpolation = threading.Event()
@@ -88,9 +89,8 @@ def process_pdf(pdf_path):
         while not stop_interpolation.is_set():
             _time.sleep(1)
             elapsed = _time.monotonic() - start
-            # Assume embeddings take ~180 s; clamp interpolated value to 88%
             frac = min(elapsed / 180, 1.0)
-            pct  = int(55 + frac * 33)   # 55 → 88
+            pct  = int(55 + frac * 33)
             set_progress("Generating embeddings", pct, f"{len(documents)} chunks to embed")
 
     interp_thread = threading.Thread(target=_interpolate, daemon=True)
@@ -102,7 +102,7 @@ def process_pdf(pdf_path):
         show_progress=True
     )
 
-    stop_interpolation.set()   # embeddings done — stop the interpolation thread
+    stop_interpolation.set()
 
     set_progress("Building query engine", 90)
 
@@ -132,11 +132,32 @@ def process_pdf(pdf_path):
     return True
 
 
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+CONVERSATIONAL_TRIGGERS = (
+    "how are you", "how r u", "hey", "hi", "hello", "good morning",
+    "good afternoon", "good evening", "what's up", "whats up",
+    "who are you", "what are you", "thanks", "thank you", "bye",
+    "goodbye", "ok", "okay", "cool", "nice", "great", "awesome",
+)
+
+def is_conversational(question: str) -> bool:
+    q = question.lower().strip()
+    return (
+        len(question.split()) <= 6 and
+        any(trigger in q for trigger in CONVERSATIONAL_TRIGGERS)
+    )
+
+def top_score(source_nodes) -> float:
+    """Return the highest similarity score among retrieved nodes."""
+    scores = [n.score for n in source_nodes if n.score is not None]
+    return max(scores) if scores else 0.0
+
+
 # ── Routes ───────────────────────────────────────────────────────────────────
 
 @app.route('/progress', methods=['GET'])
 def get_progress():
-    """Return current processing progress"""
     return jsonify(processing_progress), 200
 
 
@@ -151,7 +172,7 @@ def upload_pdf():
         return jsonify({'success': False, 'message': 'No file selected'}), 400
 
     if not allowed_file(file.filename):
-        return jsonify({'success': False, 'message': 'Only PDF files are allowed'}), 400
+        return jsonify({'success': False, 'message': 'Only PDF, TXT, and CSV files are allowed'}), 400
 
     try:
         filename = secure_filename(file.filename)
@@ -163,14 +184,14 @@ def upload_pdf():
 
         return jsonify({
             'success': True,
-            'message': 'PDF uploaded and processed successfully',
+            'message': 'File uploaded and processed successfully',
             'filename': filename
         }), 200
 
     except Exception as e:
         set_progress("Error", 0, str(e))
-        print(f"❌ Error processing PDF: {str(e)}")
-        return jsonify({'success': False, 'message': f'Error processing PDF: {str(e)}'}), 500
+        print(f"❌ Error processing file: {str(e)}")
+        return jsonify({'success': False, 'message': f'Error processing file: {str(e)}'}), 500
 
 
 @app.route('/chat', methods=['POST'])
@@ -178,7 +199,7 @@ def chat():
     global query_engine, current_pdf
 
     if query_engine is None:
-        return jsonify({'success': False, 'message': 'No PDF uploaded yet.'}), 400
+        return jsonify({'success': False, 'message': 'No document uploaded yet.'}), 400
 
     data = request.get_json()
     if not data or 'question' not in data:
@@ -189,22 +210,8 @@ def chat():
         return jsonify({'success': False, 'message': 'Question cannot be empty'}), 400
 
     try:
-        # Detect conversational/casual questions and short-circuit before
-        # hitting the query engine — these should never return sources
-        CONVERSATIONAL_TRIGGERS = (
-            "how are you", "how r u", "hey", "hi", "hello", "good morning",
-            "good afternoon", "good evening", "what's up", "whats up",
-            "who are you", "what are you", "thanks", "thank you", "bye",
-            "goodbye", "ok", "okay", "cool", "nice", "great", "awesome",
-        )
-        q_lower = question.lower().strip()
-        is_conversational = (
-            len(question.split()) <= 6 and  # short questions only
-            any(trigger in q_lower for trigger in CONVERSATIONAL_TRIGGERS)
-        )
-
-        if is_conversational:
-            # Use the LLM directly without the query engine (no document context)
+        # ── 1. Conversational short-circuit (no document lookup) ──────────
+        if is_conversational(question):
             from llama_index.core.llms import ChatMessage
             chat_response = Settings.llm.chat([
                 ChatMessage(role="user", content=question)
@@ -216,13 +223,34 @@ def chat():
                 'document': current_pdf
             }), 200
 
+        # ── 2. Retrieve nodes and check relevance BEFORE generating ───────
+        retriever = query_engine.retriever
+        source_nodes = retriever.retrieve(question)
+
+        best_score = top_score(source_nodes)
+        print(f"🎯 Best retrieval score: {best_score:.4f} (threshold: {RELEVANCE_THRESHOLD})")
+
+        if best_score < RELEVANCE_THRESHOLD:
+            # Question is out of scope — don't hallucinate an answer
+            return jsonify({
+                'success': True,
+                'answer': (
+                    f"I couldn't find anything relevant to that in **{current_pdf}**. "
+                    "Could you rephrase, or ask something more specific to the document?"
+                ),
+                'sources': [],
+                'document': current_pdf,
+                'relevance_score': round(best_score, 4),
+                'below_threshold': True,
+            }), 200
+
+        # ── 3. Score is good — generate answer normally ───────────────────
         response = query_engine.query(question)
 
         answer = response.response
         if len(answer) > 2000:
             answer = answer[:2000] + "..."
 
-        # Only return sources with a real score (not None)
         sources = []
         for node in response.source_nodes:
             score = float(node.score) if node.score is not None else 0.0
@@ -235,7 +263,13 @@ def chat():
                     'text_snippet': node.text[:100] + '...' if len(node.text) > 100 else node.text
                 })
 
-        return jsonify({'success': True, 'answer': answer, 'sources': sources, 'document': current_pdf}), 200
+        return jsonify({
+            'success': True,
+            'answer': answer,
+            'sources': sources,
+            'document': current_pdf,
+            'relevance_score': round(best_score, 4),
+        }), 200
 
     except Exception as e:
         return jsonify({'success': False, 'message': f'Error: {str(e)}'}), 500