Update src/query.py

src/query.py

@@ -6,16 +6,30 @@ import json
 # =========================
 
 def detect_category(question: str) -> str:
-    q = question.lower()
-
-    if "fee" in q or "cost" in q or "credit hour" in q:
-        return "Fees"
-    if "apply" in q or "admission" in q:
-        return "Admissions"
-    if "course" in q or "program" in q:
-        return "Academics"
-
-    return "General"
+   """Detect the category of a question based on keywords."""
+    query_lower = query.lower()
+    
+    # Category keywords based on Categories.txt
+    category_keywords = {
+        "Admissions": ["apply", "admission", "accept", "requirements", "application", "enroll"],
+        "Fees": ["fee", "tuition", "cost", "payment", "credit", "price", "pay", "refund"],
+        "Academics": ["gpa", "grades", "scores", "grade", "cgpa", "dean"],
+        "Academic Advising": ["advisor", "track", "course", "major", "register", "summer course"],
+        "IT & Systems": ["portal", "moodle", "login", "system", "technical", "support"],
+        "Emails": ["email", "gmail", "outlook", "mail", "inbox", "address", "contact email"],
+    }
+    
+    # Count keyword matches for each category
+    category_scores = {}
+    for category, keywords in category_keywords.items():
+        score = sum(1 for keyword in keywords if keyword in query_lower)
+        if score > 0:
+            category_scores[category] = score
+    
+    # Return category with highest score, or None if no matches
+    if category_scores:
+        return max(category_scores, key=category_scores.get)
+    return None
 
 
 # =========================
@@ -23,45 +37,113 @@ def detect_category(question: str) -> str:
 # =========================
 
 def retrieve_with_chroma(query_embedding, top_k=5, category_filter=None):
-    """
-    This function is called by app.py.
-    Replace its body with your real ChromaDB logic if needed.
-    """
-
-    # Example fallback data (SAFE DEFAULT)
-    docs = [
-        "The cost per credit hour is 1500 EGP for undergraduate programs."
-    ]
-
-    metas = [
-        {
-            "qa_id": 1,
-            "category": "Fees",
-            "source": "Admissions Handbook"
-        }
-    ]
-
-    return docs[:top_k], metas[:top_k]
+     """Retrieve relevant Q&A pairs from Chroma with optional category filtering."""
+    try:
+        import chromadb
+
+        # Prefer persistent client; fall back quietly
+        client = None
+        try:
+            client = chromadb.PersistentClient(path=CHROMA_PERSIST_DIR)
+        except Exception:
+            try:
+                from chromadb.config import Settings
+                client = chromadb.Client(Settings(persist_directory=CHROMA_PERSIST_DIR))
+            except Exception:
+                try:
+                    client = chromadb.EphemeralClient()
+                except Exception:
+                    return [], []
+
+        # Get qa_knowledge collection (stores JSON Q&A data)
+        col = None
+        try:
+            col = client.get_collection("qa_knowledge")
+        except Exception:
+            return [], []
+
+        # Apply category filter if provided (e.g., only Fees, Admissions, etc.)
+        if category_filter:
+            results = col.query(
+                query_embeddings=[query_embedding], 
+                n_results=top_k,
+                where={"category": category_filter}
+            )
+        else:
+            results = col.query(
+                query_embeddings=[query_embedding], 
+                n_results=top_k
+            )
+        
+        docs = results.get("documents", [[]])[0]
+        metas = results.get("metadatas", [[]])[0]
+        return docs, metas
+    except Exception as e:
+        # If there's an error, print it for debugging and return empty
+        print(f"ChromaDB error: {e}")
+        return [], []
 
 
 def local_retrieve(question, top_k=3, category_filter=None):
-    """
-    Backup keyword-based retrieval
-    """
-
-    docs = [
-        "Each credit hour costs 1500 EGP according to university fee regulations."
-    ]
-
-    metas = [
-        {
-            "qa_id": 2,
-            "category": "Fees",
-            "source": "Local FAQ"
-        }
-    ]
-
-    return docs[:top_k], metas[:top_k]
+"""Keyword-overlap retrieval over JSON data on disk with optional category filtering."""
+    from src.utils import chunk_text, list_pdfs, load_pdf_text
+
+    cwd = os.getcwd()
+    json_path = os.path.join(cwd, "data.json")
+    all_chunks = []
+    metadatas = []
+
+    if os.path.exists(json_path):
+        try:
+            with open(json_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            
+            items = []
+            for entry in data:
+                category = entry.get("category", "General")
+                
+                # Apply category filter if provided
+                if category_filter and category != category_filter:
+                    continue
+                
+                qa_id = entry.get("id", "")
+                qtext = str(entry.get("question", "")).strip()
+                atext = str(entry.get("answer", "")).strip()
+                
+                if qtext or atext:
+                    combined = f"Question: {qtext}\nAnswer: {atext}"
+                    items.append(combined)
+                    # Store metadata with each item
+                    metadatas.append({
+                        "source": json_path,
+                        "qa_id": str(qa_id),
+                        "category": category,
+                        "question": qtext,
+                        "answer": atext
+                    })
+        except Exception as e:
+            print(f"Error reading data.json: {e}")
+            items = []
+            metadatas = []
+    else:
+        items = []
+        metadatas = []
+    
+    # Use items directly (already have metadata)
+    if not items:
+        return [], []
+
+    # naive keyword overlap scoring
+    q_tokens = set(w.lower() for w in query.split())
+    scores = []
+    for item in items:
+        item_tokens = set(w.lower().strip('.,()\"') for w in item.split())
+        scores.append(len(q_tokens & item_tokens))
+
+    ranked = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)
+    top = [items[i] for i, s in ranked[:top_k] if s > 0]
+    top_meta = [metadatas[i] for i, s in ranked[:top_k] if s > 0]
+    return top, top_meta
 
 
 # =========================