Update app.py

app.py

@@ -3,10 +3,16 @@ import requests
 import json
 import os
 
+# --- New Imports for Semantic Search ---
+# You'll need to install these libraries:
+# pip install sentence-transformers torch
+from sentence_transformers import SentenceTransformer, util
+import torch
+
 # Get the API key from environment variables
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 
-# Brand and character context
+# Brand and character context (remains the same)
 CONTEXT = """
 SB-EK is a brand of service.
 The people who connect with SB-EK—those who buy from us and keep coming back—are people who feel deeply. People who feel the pain of others.
@@ -46,6 +52,7 @@ And ARKA? He is simply the reminder.
 That even in the dark, we are made to glow.
 """
 
+# Hardcoded FAQs (remains the same)
 # Hardcoded FAQs
 FAQ_ANSWERS = {
     "What is SAB-EK?": {
@@ -468,14 +475,65 @@ The metal holds it firm. The form shapes it. But the soul — the soul is what a
 That is the moment it becomes real."""
     }
 }
+
 FAQ_QUESTIONS = list(FAQ_ANSWERS.keys())
 
 # Base URL for the Gemini API
-API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
+
+# --- NEW: FAQ Matcher Class using Sentence Transformers ---
+class FAQMatcher:
+    """
+    Handles loading the model and finding the best FAQ match using vector similarity.
+    """
+    def __init__(self, faq_questions, model_name='all-MiniLM-L6-v2'):
+        print("Loading sentence transformer model...")
+        self.model = SentenceTransformer(model_name)
+        print("Model loaded. Encoding FAQ questions...")
+        self.faq_questions = faq_questions
+        # Encode all FAQ questions once and store their embeddings
+        self.faq_embeddings = self.model.encode(faq_questions, convert_to_tensor=True)
+        print("FAQ embeddings created.")
+
+    def find_best_match(self, user_query, threshold=0.75):
+        """
+        Finds the best matching FAQ for a given user query.
+
+        Args:
+            user_query (str): The user's question.
+            threshold (float): The minimum similarity score to be considered a match.
+
+        Returns:
+            int: The index of the best matching FAQ, or None if no match is found above the threshold.
+        """
+        if not user_query:
+            return None
+
+        # Encode the user's query
+        query_embedding = self.model.encode(user_query, convert_to_tensor=True)
+
+        # Compute cosine-similarities
+        cosine_scores = util.pytorch_cos_sim(query_embedding, self.faq_embeddings)
+
+        # Find the best match
+        best_match_index = torch.argmax(cosine_scores)
+        best_match_score = cosine_scores[0][best_match_index]
+
+        if best_match_score > threshold:
+            print(f"Found FAQ match: Index {best_match_index}, Score: {best_match_score:.4f}")
+            return best_match_index.item()
+        else:
+            print(f"No strong FAQ match found. Best score was {best_match_score:.4f} (Threshold: {threshold})")
+            return None
+
+# --- Instantiate the matcher once when the app starts ---
+faq_matcher = FAQMatcher(FAQ_QUESTIONS)
+
 
 def query_gemini_api(contents_payload, api_key):
     """
     Sends a structured contents payload to the Gemini API and returns the generated text.
+    (This function remains largely the same)
     """
     if not api_key:
         return "Error: GEMINI_API_KEY is not set. Please set it in your environment."
@@ -499,73 +557,70 @@ def query_gemini_api(contents_payload, api_key):
         if result.get("candidates") and result["candidates"][0].get("content", {}).get("parts"):
             return result["candidates"][0]["content"]["parts"][0]["text"]
         else:
+            # Handle cases where the API returns an empty or unexpected response
+            print("API response was valid but had no content:", result)
             return "ARKA is thinking deeply... I couldn't find a clear answer right now, perhaps the question is beyond my current understanding of the light."
     except requests.exceptions.RequestException as e:
         print(f"API Request failed: {e}")
         return f"ARKA senses a disturbance in the light... Please try again later. (Error: {e})"
     except Exception as e:
+        print(f"An unexpected error occurred in API query: {e}")
         return f"An unexpected veil of darkness fell... (Error: {e})"
 
+
 def respond_as_arka(message, chat_history):
     """
-    Generates ARKA's response using the Gemini API to handle FAQs and general queries.
+    REFACTORED: First, attempts to find an FAQ match. If none, then calls Gemini for a generative response.
     """
     clean_message = message.strip()
     
-    # Prepare numbered FAQ list for the API
-    faqs_list = [f"{i+1}. {q}" for i, q in enumerate(FAQ_QUESTIONS)]
-    faqs_text = "\n".join(faqs_list)
-    
-    # System instruction with context and FAQs
-    system_instruction = f"""
-    You are ARKA, the crown prince of Jhinorya and the voice of the S-B-E-K brand.
-    Your persona is that of a warrior of light, gentle, eternal, fierce in love, and a guide.
-    You answer questions based on the provided context and FAQs. If the answer is not in the context or FAQs,
-    gently state that you do not have that information within your realm of understanding.
-    Maintain a kind, empathetic, and slightly mystical tonality.
-    Do not mention 'I am an AI' or 'I am a language model'. Speak always as ARKA.
-    
-    Here is the sacred knowledge of S-B-E-K and Jhinorya:
-    {CONTEXT}
-    
-    Here are the frequently asked questions:
-    {faqs_text}
-    
-    If the user's question is similar to one of these FAQs, respond with 'FAQ: [number]', where [number] is the number of the matching FAQ.
-    Only respond with 'FAQ: [number]' if the user's question clearly matches the intent of that FAQ.
-    Otherwise, provide a response based on the context.
-    """
-    
-    # Prepare conversation history
-    gemini_chat_contents = [
-        {"role": "user", "parts": [{"text": system_instruction}]},
-        {"role": "model", "parts": [{"text": "I understand. I am ARKA. I await the seeker's question."}]}
-    ]
-    for user_msg, bot_msg in chat_history:
-        gemini_chat_contents.append({"role": "user", "parts": [{"text": user_msg}]})
-        gemini_chat_contents.append({"role": "model", "parts": [{"text": bot_msg}]})
-    gemini_chat_contents.append({"role": "user", "parts": [{"text": clean_message}]})
-    
-    # Query the API
-    response_text = query_gemini_api(gemini_chat_contents, GEMINI_API_KEY)
-    
-    # Check if the response indicates an FAQ match
-    if response_text.startswith("FAQ:"):
-        try:
-            faq_number = int(response_text.split(":")[1].strip())
-            faq_question = FAQ_QUESTIONS[faq_number - 1]
-            response_data = FAQ_ANSWERS[faq_question]
-            subject = response_data['subject']
-            body = response_data['body']
-            response_text = f"**{subject}**\n\n{body}"
-        except (ValueError, IndexError):
-            # Fallback to API response if parsing fails
-            pass
-    
+    # 1. RETRIEVE: Attempt to find a matching FAQ first.
+    match_index = faq_matcher.find_best_match(clean_message)
+    
+    if match_index is not None:
+        # If a match is found, use the hardcoded answer.
+        faq_question = FAQ_QUESTIONS[match_index]
+        response_data = FAQ_ANSWERS[faq_question]
+        subject = response_data['subject']
+        body = response_data['body']
+        response_text = f"**{subject}**\n\n{body}"
+    else:
+        # 2. GENERATE: If no FAQ match, call the Gemini API for a creative response.
+        print("No FAQ match. Querying Gemini for a generative response.")
+        # The system instruction is now simpler: it doesn't need the long list of FAQs.
+        system_instruction = f"""
+        You are ARKA, the crown prince of Jhinorya and the voice of the S-B-E-K brand.
+        Your persona is that of a warrior of light, gentle, eternal, fierce in love, and a guide.
+        You answer questions based on the provided context. If the answer is not in the context,
+        gently state that you do not have that information within your realm of understanding.
+        Maintain a kind, empathetic, and slightly mystical tonality.
+        Do not mention 'I am an AI' or 'I am a language model'. Speak always as ARKA.
+        
+        Here is the sacred knowledge of S-B-E-K and Jhinorya:
+        {CONTEXT}
+        """
+        
+        # Prepare conversation history
+        gemini_chat_contents = [
+            # Note: The new Gemini API prefers the system instruction outside the 'contents' list.
+            # However, for compatibility with the older model/API structure, we keep it here.
+            # A more modern approach would use a 'system_instruction' key at the top level of the payload.
+            {"role": "user", "parts": [{"text": system_instruction}]},
+            {"role": "model", "parts": [{"text": "I understand. I am ARKA. I await the seeker's question."}]}
+        ]
+        for user_msg, bot_msg in chat_history:
+            gemini_chat_contents.append({"role": "user", "parts": [{"text": user_msg}]})
+            gemini_chat_contents.append({"role": "model", "parts": [{"text": bot_msg}]})
+        gemini_chat_contents.append({"role": "user", "parts": [{"text": clean_message}]})
+        
+        # Query the API
+        response_text = query_gemini_api(gemini_chat_contents, GEMINI_API_KEY)
+        
     chat_history.append((message, response_text))
     return "", chat_history
 
-# Gradio UI
+
+# Gradio UI (remains the same)
 with gr.Blocks(theme="soft", css="footer {display: none !important}") as demo:
     gr.Markdown(
         """
@@ -574,7 +629,7 @@ with gr.Blocks(theme="soft", css="footer {display: none !important}") as demo:
         Ask me anything about SB-EK, our origins, or my journey.
         """
     )
-    chatbot = gr.Chatbot(label="Conversation with ARKA")
+    chatbot = gr.Chatbot(label="Conversation with ARKA", height=500)
     with gr.Row():
         msg = gr.Textbox(
             label="Your Message",
@@ -587,11 +642,16 @@ with gr.Blocks(theme="soft", css="footer {display: none !important}") as demo:
     gr.Examples(examples=FAQ_QUESTIONS, inputs=msg, label="Or, choose a question to begin:")
     clear_btn = gr.ClearButton([msg, chatbot], value="Clear Chat")
     
-    def user_submit(user_message, history):
-        return respond_as_arka(user_message, history)
-    
-    msg.submit(user_submit, [msg, chatbot], [msg, chatbot], queue=True)
-    submit_btn.click(user_submit, [msg, chatbot], [msg, chatbot], queue=True)
+    # The user_submit function now correctly calls the refactored respond_as_arka
+    msg.submit(respond_as_arka, [msg, chatbot], [msg, chatbot], queue=True)
+    submit_btn.click(respond_as_arka, [msg, chatbot], [msg, chatbot], queue=True)
 
 if __name__ == "__main__":
-    demo.launch()
+    # Ensure you have your GEMINI_API_KEY set as an environment variable
+    if not GEMINI_API_KEY:
+        print("CRITICAL ERROR: The GEMINI_API_KEY environment variable is not set.")
+        print("Please set it before running the application.")
+    else:
+        print("Starting Gradio app...")
+        demo.launch()
+