Update app.py

app.py

@@ -429,6 +429,58 @@ Just type your question or start a conversation, and I'll do my best to help you
         
         return None
 
+    def _generate_query_variants(self, question: str) -> List[str]:
+        """Generate lightweight query variants to improve matching against FAQs"""
+        variants: List[str] = []
+        original = question.strip()
+        variants.append(original)
+
+        # Normalized
+        norm = self._normalize_text(original)
+        variants.append(norm)
+
+        # Remove trailing punctuation and repeated spaces already handled by normalize
+
+        # Simple lemmatization-ish tweaks for common cases
+        rules = [
+            (r"\btakes\b", "take"),
+            (r"\btake\b", "takes"),
+            (r"\bdoes\b", "do"),
+            (r"\bdo\b", "does"),
+            (r"\bis\b", "are"),
+            (r"\bare\b", "is"),
+        ]
+
+        for pattern, repl in rules:
+            try:
+                v = re.sub(pattern, repl, norm)
+                if v not in variants:
+                    variants.append(v)
+            except Exception:
+                pass
+
+        # Last-word singular/plural toggle
+        words = norm.split()
+        if words:
+            last = words[-1]
+            if len(last) > 3 and last.endswith('s'):
+                alt = ' '.join(words[:-1] + [last[:-1]])
+                if alt not in variants:
+                    variants.append(alt)
+            else:
+                alt = ' '.join(words[:-1] + [last + 's'])
+                if alt not in variants:
+                    variants.append(alt)
+
+        # De-duplicate while preserving order
+        seen = set()
+        unique_variants: List[str] = []
+        for v in variants:
+            if v not in seen and v:
+                seen.add(v)
+                unique_variants.append(v)
+        return unique_variants
+
     def fetch_from_database(self, question: str) -> str:
         """Fetch answer from the database with smart matching"""
         try:
@@ -447,56 +499,66 @@ Just type your question or start a conversation, and I'll do my best to help you
             # Fallback to original method if smart matching doesn't work
             endpoints = [
                 f"{self.database_url}/faqs",
+                f"{self.database_url}/faq",
                 f"{self.database_url}/search",
                 f"{self.database_url}/query",
                 f"{self.database_url}/api/faq"
             ]
-            
+
+            param_names = ["question", "q"]
+            variants = self._generate_query_variants(question)
+
             for endpoint in endpoints:
-                try:
-                    # Try GET request with query parameter
-                    response = requests.get(endpoint, params={"question": question}, timeout=10)
-                    if response.status_code == 200:
-                        data = response.json()
-                        if isinstance(data, dict):
-                            answer = data.get('answer', data.get('response', str(data)))
-                            # Check if we got a meaningful answer
-                            if answer and answer.strip() and not self._is_no_answer_response(answer):
-                                return answer
-                        elif isinstance(data, list) and len(data) > 0:
-                            answer = str(data[0])
-                            if answer and answer.strip() and not self._is_no_answer_response(answer):
-                                return answer
-                        else:
-                            answer = str(data)
-                            if answer and answer.strip() and not self._is_no_answer_response(answer):
-                                return answer
-                except:
-                    try:
-                        # Try POST request with JSON body
-                        response = requests.post(
-                            endpoint, 
-                            json={"question": question}, 
-                            headers={"Content-Type": "application/json"},
-                            timeout=10
-                        )
-                        if response.status_code == 200:
-                            data = response.json()
-                            if isinstance(data, dict):
-                                answer = data.get('answer', data.get('response', str(data)))
-                                # Check if we got a meaningful answer
-                                if answer and answer.strip() and not self._is_no_answer_response(answer):
-                                    return answer
-                            elif isinstance(data, list) and len(data) > 0:
-                                answer = str(data[0])
-                                if answer and answer.strip() and not self._is_no_answer_response(answer):
-                                    return answer
-                            else:
-                                answer = str(data)
-                                if answer and answer.strip() and not self._is_no_answer_response(answer):
-                                    return answer
-                    except:
-                        continue
+                for variant in variants:
+                    for param_name in param_names:
+                        # Try GET
+                        try:
+                            response = requests.get(
+                                endpoint,
+                                params={param_name: variant},
+                                timeout=10
+                            )
+                            if response.status_code == 200:
+                                data = response.json()
+                                if isinstance(data, dict):
+                                    answer = data.get('answer', data.get('response', str(data)))
+                                    if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                        return answer
+                                elif isinstance(data, list) and len(data) > 0:
+                                    answer = str(data[0])
+                                    if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                        return answer
+                                else:
+                                    answer = str(data)
+                                    if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                        return answer
+                        except Exception:
+                            pass
+
+                        # Try POST JSON
+                        try:
+                            response = requests.post(
+                                endpoint,
+                                json={param_name: variant},
+                                headers={"Content-Type": "application/json"},
+                                timeout=10
+                            )
+                            if response.status_code == 200:
+                                data = response.json()
+                                if isinstance(data, dict):
+                                    answer = data.get('answer', data.get('response', str(data)))
+                                    if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                        return answer
+                                elif isinstance(data, list) and len(data) > 0:
+                                    answer = str(data[0])
+                                    if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                        return answer
+                                else:
+                                    answer = str(data)
+                                    if answer and answer.strip() and not self._is_no_answer_response(answer):
+                                        return answer
+                        except Exception:
+                            pass
             
             # If no answer found, save the question as unanswered
             saved = self.save_unanswered_question(question)
@@ -559,40 +621,51 @@ Just type your question or start a conversation, and I'll do my best to help you
         try:
             endpoints = [
                 f"{self.database_url}/faqs",
+                f"{self.database_url}/faq",
                 f"{self.database_url}/search",
                 f"{self.database_url}/query",
                 f"{self.database_url}/api/faq"
             ]
-            
+
+            param_names = ["question", "q"]
+            variants = self._generate_query_variants(question)
+
             for endpoint in endpoints:
-                try:
-                    response = requests.get(endpoint, params={"question": question}, timeout=10)
-                    if response.status_code == 200:
-                        data = response.json()
-                        if isinstance(data, dict):
-                            return data.get('answer', data.get('response', str(data)))
-                        elif isinstance(data, list) and len(data) > 0:
-                            return str(data[0])
-                        else:
-                            return str(data)
-                except:
-                    try:
-                        response = requests.post(
-                            endpoint, 
-                            json={"question": question}, 
-                            headers={"Content-Type": "application/json"},
-                            timeout=10
-                        )
-                        if response.status_code == 200:
-                            data = response.json()
-                            if isinstance(data, dict):
-                                return data.get('answer', data.get('response', str(data)))
-                            elif isinstance(data, list) and len(data) > 0:
-                                return str(data[0])
-                            else:
-                                return str(data)
-                    except:
-                        continue
+                for variant in variants:
+                    for param_name in param_names:
+                        try:
+                            response = requests.get(
+                                endpoint,
+                                params={param_name: variant},
+                                timeout=10
+                            )
+                            if response.status_code == 200:
+                                data = response.json()
+                                if isinstance(data, dict):
+                                    return data.get('answer', data.get('response', str(data)))
+                                elif isinstance(data, list) and len(data) > 0:
+                                    return str(data[0])
+                                else:
+                                    return str(data)
+                        except Exception:
+                            pass
+                        try:
+                            response = requests.post(
+                                endpoint,
+                                json={param_name: variant},
+                                headers={"Content-Type": "application/json"},
+                                timeout=10
+                            )
+                            if response.status_code == 200:
+                                data = response.json()
+                                if isinstance(data, dict):
+                                    return data.get('answer', data.get('response', str(data)))
+                                elif isinstance(data, list) and len(data) > 0:
+                                    return str(data[0])
+                                else:
+                                    return str(data)
+                        except Exception:
+                            pass
             
             return None
         except: