Update app.py

app.py

@@ -18,7 +18,7 @@ import re
 from typing import Dict, List, Tuple
 import time
 from contextlib import contextmanager
-import threading  # Required for background logging
+
 import logging
 import traceback
 import sys
@@ -59,26 +59,27 @@ class PipelineTimer:
             yield
         finally:
             step_end = time.time()
-            self.step_times[step_name] = round((step_end - step_start) * 1000, 2)
+            self.step_times[step_name] = round((step_end - step_start) * 1000, 2)  # Convert to milliseconds
             self.current_step = None
     
     def get_total_time(self):
+        """Get total elapsed time since reset"""
         return round((time.time() - self.start_time) * 1000, 2)
     
     def get_timing_summary(self):
+        """Get a summary of all timing data"""
+        total_time = self.get_total_time()
         return {
-            'total_time_ms': self.get_total_time(),
+            'total_time_ms': total_time,
             'step_times': self.step_times,
             'timestamp': datetime.now().isoformat()
         }
 
+# Initialize global timer
 timer = PipelineTimer()
 
 # === Configuration ===
-if "GEMINI_API_KEY" not in os.environ:
-    print("WARNING: GEMINI_API_KEY environment variable not found.")
-    
-genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
+genai.configure(api_key=os.environ["GEMINI_API_KEY"])
 embedding_model = "models/embedding-001"
 llm_model_name = "models/gemma-3-4b-it"
 collection_name = "xeno_collection"
@@ -93,52 +94,27 @@ def get_google_sheets_credentials():
     creds = Credentials.from_service_account_info(credentials_dict, scopes=scope)
     return creds
 
-# Initialize Sheets
-try:
-    client_gspread = gspread.authorize(get_google_sheets_credentials())
-    spreadsheet = client_gspread.open("Response_Log")
-    response_sheet = spreadsheet.sheet1
-except Exception as e:
-    print(f"Error connecting to Google Sheets: {e}")
-    # Dummy classes for dev/fallback
-    class DummySheet:
-        def append_row(self, *args, **kwargs): pass
-        def worksheet(self, *args): return self
-        def add_worksheet(self, *args, **kwargs): return self
-    spreadsheet = DummySheet()
-    response_sheet = DummySheet()
-
-# Timing Sheet
-try:
-    timing_sheet = spreadsheet.worksheet("Timing_Log")
-except:
-    try:
-        timing_sheet = spreadsheet.add_worksheet(title="Timing_Log", rows="1000", cols="15")
-        headers = [
-            "Timestamp", "Session_ID", "Question", "Total_Time_MS",
-            "Intent_Classification_MS", "Memory_Retrieval_MS", "RAG_Retrieval_MS", 
-            "Embedding_Generation_MS", "Similarity_Calculation_MS", "Context_Processing_MS",
-            "LLM_Generation_MS", "Memory_Update_MS", "Logging_MS", "Error_Step", "Notes"
-        ]
-        timing_sheet.append_row(headers)
-    except:
-        timing_sheet = None
+client_gspread = gspread.authorize(get_google_sheets_credentials())
 
-# Feedback Sheet
+# Open the Google Sheet and get both sheets
+spreadsheet = client_gspread.open("Response_Log")
+response_sheet = spreadsheet.sheet1  # Main response log
 try:
-    feedback_sheet = spreadsheet.worksheet("Feedback_Log")
+    timing_sheet = spreadsheet.worksheet("Timing_Log")
 except:
-    try:
-        feedback_sheet = spreadsheet.add_worksheet(title="Feedback_Log", rows="1000", cols="6")
-        headers = ["Timestamp", "Session_ID", "User_Message", "Bot_Response", "Rating", "Flag_Reason"]
-        feedback_sheet.append_row(headers)
-    except:
-        feedback_sheet = None
-
-# === Logging Functions ===
+    # Create timing sheet if it doesn't exist
+    timing_sheet = spreadsheet.add_worksheet(title="Timing_Log", rows="1000", cols="15")
+    # Add headers
+    headers = [
+        "Timestamp", "Session_ID", "Question", "Total_Time_MS",
+        "Intent_Classification_MS", "Memory_Retrieval_MS", "RAG_Retrieval_MS", 
+        "Embedding_Generation_MS", "Similarity_Calculation_MS", "Context_Processing_MS",
+        "LLM_Generation_MS", "Memory_Update_MS", "Logging_MS", "Error_Step", "Notes"
+    ]
+    timing_sheet.append_row(headers)
 
 def log_response(question, answer, source_ids, knowledge_pairs, session_id):
-    """Log the main chat interaction"""
+    """Original response logging function"""
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     knowledge_question_1 = knowledge_pairs[0][0] if len(knowledge_pairs) > 0 else "N/A"
     knowledge_answer_1 = knowledge_pairs[0][1] if len(knowledge_pairs) > 0 else "N/A"
@@ -150,194 +126,222 @@ def log_response(question, answer, source_ids, knowledge_pairs, session_id):
     ]
     try:
         response_sheet.append_row(row)
-        print(f"Logged response: {question} | Sources: {source_ids}")
+        print(f"Logged response: {question} | Source IDs: {source_ids}")
     except Exception as e:
-        print(f"Failed to log response: {e}")
+        print(f"Failed to log to Google Sheet: {e}")
+        with open("/tmp/response_log.txt", "a") as f:
+            f.write(f"{timestamp},{question},{answer},{source_ids},{knowledge_question_1},{knowledge_answer_1},{knowledge_question_2},{knowledge_answer_2}\n")
 
 def log_timing_data(question, session_id, timing_summary, error_step=None, notes=None):
-    """Log performance metrics"""
-    if timing_sheet is None: return
+    """Log timing data to the timing sheet"""
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     step_times = timing_summary['step_times']
+    
     row = [
-        timestamp, session_id, question[:100], timing_summary['total_time_ms'],
-        step_times.get('intent_classification', 0), step_times.get('memory_retrieval', 0),
-        step_times.get('rag_retrieval', 0), step_times.get('embedding_generation', 0),
-        step_times.get('similarity_calculation', 0), step_times.get('context_processing', 0),
-        step_times.get('llm_generation', 0), step_times.get('memory_update', 0),
-        step_times.get('response_logging', 0), error_step or "", notes or ""
+        timestamp,
+        session_id,
+        question[:100] + "..." if len(question) > 100 else question,  # Truncate long questions
+        timing_summary['total_time_ms'],
+        step_times.get('intent_classification', 0),
+        step_times.get('memory_retrieval', 0),
+        step_times.get('rag_retrieval', 0),
+        step_times.get('embedding_generation', 0),
+        step_times.get('similarity_calculation', 0),
+        step_times.get('context_processing', 0),
+        step_times.get('llm_generation', 0),
+        step_times.get('memory_update', 0),
+        step_times.get('response_logging', 0),
+        error_step or "",
+        notes or ""
     ]
-    try:
-        timing_sheet.append_row(row)
-    except Exception as e:
-        print(f"Failed to log timing: {e}")
-
-# === Feedback Functions ===
-
-def _log_feedback_background(row):
-    """Background worker to send feedback to Google Sheets"""
-    try:
-        if feedback_sheet:
-            feedback_sheet.append_row(row)
-            print("Feedback logged successfully.")
-        else:
-            print("Feedback sheet not available.")
-    except Exception as e:
-        print(f"Failed to log feedback: {e}")
-
-def handle_vote(data: gr.LikeData, history, session_id):
-    """
-    Handles the Google AI Studio style Thumbs Up/Down events.
-    Triggered when user clicks the icon on the chat bubble.
-    """
-    if not history: return
     
     try:
-        # Determine rating
-        rating = "Positive" if data.liked else "Negative"
-        
-        # Get the interaction from history using data.index
-        # history is a list of [user_msg, bot_msg]
-        interaction_index = data.index
-        
-        # Safety check on index
-        if interaction_index < len(history):
-            interaction = history[interaction_index]
-            user_msg = interaction[0]
-            bot_msg = interaction[1]
-            
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            row = [timestamp, session_id, user_msg, bot_msg, rating, "Quick Vote (Icon Click)"]
-            
-            # Run in background thread
-            threading.Thread(target=_log_feedback_background, args=(row,)).start()
-            print(f"Vote registered: {rating}")
-            
-    except Exception as e:
-        print(f"Error handling vote: {e}")
-
-def submit_manual_flag(reason, history, session_id):
-    """Handles the manual text feedback submission"""
-    if not history: return "No conversation to flag."
-    
-    try:
-        last_interaction = history[-1]
-        user_msg = last_interaction[0]
-        bot_msg = last_interaction[1]
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
-        row = [timestamp, session_id, user_msg, bot_msg, "Negative", reason]
-        threading.Thread(target=_log_feedback_background, args=(row,)).start()
-        
-        return "Report submitted. Thank you."
+        timing_sheet.append_row(row)
+        print(f"Logged timing data: Total {timing_summary['total_time_ms']}ms")
     except Exception as e:
-        return f"Error submitting report: {str(e)}"
+        print(f"Failed to log timing data: {e}")
+        # Fallback to local file
+        with open("/tmp/timing_log.txt", "a") as f:
+            f.write(f"{timestamp},{session_id},{question},{timing_summary}\n")
 
-# === Core Logic & Classes ===
+# === LangGraph Memory Setup ===
 conn = sqlite3.connect("xeno_memory.db", check_same_thread=False)
 memory = SqliteSaver(conn=conn)
 
 def update_memory(config, user_message, assistant_message):
+    """Update memory with timing"""
     with timer.time_step("memory_update"):
         full_checkpoint = memory.get(config) or {}
         messages = full_checkpoint.get("channel_values", {}).get("messages", [])
+        
         messages.append({"role": "user", "content": user_message})
         messages.append({"role": "assistant", "content": assistant_message})
-        checkpoint = {
-            "v": 1, "id": str(uuid.uuid4()), "ts": datetime.now().isoformat(),
+        
+        checkpoint_to_save = {
+            "v": 1,
+            "id": str(uuid.uuid4()),
+            "ts": datetime.now().isoformat(),
             "channel_values": {"messages": messages},
-            "channel_versions": {}, "versions_seen": {},
+            "channel_versions": {},
+            "versions_seen": {},   
         }
-        memory.put(config, checkpoint, {}, {})
+        
+        memory.put(config, checkpoint_to_save, {}, {})
 
 def retrieve_memory(config):
+    """Retrieve memory with timing"""
     with timer.time_step("memory_retrieval"):
         full_checkpoint = memory.get(config) or {}
         return full_checkpoint.get("channel_values", {}).get("messages", [])
 
+# === Intent Classification System ===
 class IntentClassifier:
     def __init__(self):
         self.intent_patterns = {
             'greeting': {
-                'patterns': [r'\b(hi|hello|hey|greetings)\b', r'^(hi|hello)[\s!.]*$'],
-                'responses': ["Hello! I'm XENO Assistant. How can I help you with XENO financial services?"]
+                'patterns': [
+                    r'\b(hi|hello|hey|good morning|good afternoon|good evening|greetings)\b',
+                    r'^(hi|hello|hey)[\s!.]*$',
+                    r'\b(how are you|how do you do)\b'
+                ],
+                'responses': [
+                    "Hello! I'm XENO Assistant. How can I help you with XENO financial services today?",
+                    "Hi there! I'm here to assist you with any questions about XENO services. What can I help you with?",
+                    "Good day! Welcome to XENO Support. How may I assist you today?"
+                ]
             },
             'thanks': {
-                'patterns': [r'\b(thank|thanks)\b'],
-                'responses': ["You're welcome! Let me know if you need anything else."]
+                'patterns': [
+                    r'\b(thank you|thanks|thank u|thx|appreciate|grateful)\b',
+                    r'^(thanks|thank you)[\s!.]*$',
+                    r'\b(much appreciated|thanks a lot|thank you so much)\b'
+                ],
+                'responses': [
+                    "You're welcome! Is there anything else I can help you with regarding XENO services?",
+                    "Happy to help! Feel free to ask if you have any other questions about XENO.",
+                    "Glad I could assist you! Let me know if you need help with anything else."
+                ]
+            },
+            'goodbye': {
+                'patterns': [
+                    r'\b(bye|goodbye|see you|farewell|take care|have a good day)\b',
+                    r'^(bye|goodbye)[\s!.]*$',
+                    r'\b(talk to you later|see you later|until next time)\b'
+                ],
+                'responses': [
+                    "Goodbye! Thank you for using XENO services. Have a great day!",
+                    "Take care! Feel free to return anytime you need help with XENO services.",
+                    "Have a wonderful day! Don't hesitate to reach out if you need assistance with XENO."
+                ]
             }
         }
     
     def classify_intent(self, message: str) -> Tuple[str, str]:
+        """Classify intent with timing"""
         message_lower = message.lower().strip()
+        
         for intent_name, intent_data in self.intent_patterns.items():
             for pattern in intent_data['patterns']:
                 if re.search(pattern, message_lower, re.IGNORECASE):
-                    return intent_name, intent_data['responses'][0]
+                    import random
+                    response = random.choice(intent_data['responses'])
+                    return intent_name, response
+        
         return 'query', ''
+    
+    def is_simple_intent(self, intent: str) -> bool:
+        simple_intents = ['greeting', 'thanks']
+        return intent in simple_intents
 
 intent_classifier = IntentClassifier()
 
-# === Knowledge Base & ChromaDB ===
-try:
-    df_kb = pd.read_json("XENO_Uganda_KnowledgeBase_Advisory.json")
-    df_kb.dropna(subset=['Content'], inplace=True)
-    xeno_data_list = df_kb.to_dict('records')
-    
+# === Load and Clean Knowledge Base ===
+df_kb = pd.read_json("XENO_Uganda_KnowledgeBase_Advisory.json")
+df_kb.dropna(subset=['Content'], inplace=True)
+
+def prepare_documents(data):
     documents, metadatas, ids = [], [], []
-    for item in xeno_data_list:
+    for item in data:
         documents.append(f"Question: {item['Question']}\nAnswer: {item['Content']}")
-        metadatas.append({"question": item["Question"], "content": item["Content"], "id": str(item["ID"])})
-        ids.append(str(item["ID"]))
-
+        metadatas.append({
+            "question": item["Question"],
+            "content": item["Content"],
+            "section": item.get("Section", ""),
+            "source": item.get("Source", ""),
+            "owner": item.get("Owner", ""),
+            "tag": item.get("Tag", ""),
+            "id": item["ID"]
+        })
+        ids.append(item["ID"])
+    return documents, metadatas, ids
+
+xeno_data_list = df_kb.to_dict('records')
+documents, metadatas, ids = prepare_documents(xeno_data_list)
+
+# === Setup ChromaDB ===
+try:
     client = chromadb.PersistentClient(path="/tmp/xeno_db")
     try:
         collection = client.get_collection(name=collection_name)
+        print(f"Loaded existing ChromaDB collection: {collection_name}")
     except:
+        print(f"Creating new ChromaDB collection: {collection_name}")
         collection = client.create_collection(name=collection_name)
-        if documents: collection.add(documents=documents, metadatas=metadatas, ids=ids)
-    
-    vector_store = Chroma(client=client, collection_name=collection_name)
-    retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 4})
+        collection.add(documents=documents, metadatas=metadatas, ids=ids)
 except Exception as e:
-    print(f"DB Init Error: {e}")
-    # Define dummy retriever to allow UI to load even if DB fails
-    class DummyRetriever:
-        def invoke(self, *args): return []
-    retriever = DummyRetriever()
+    print(f"Failed to initialize ChromaDB: {e}")
+    raise
 
-# === Prompt & Generation ===
-SYSTEM_PROMPT = """You are a friendly XENO Support Assistant. 
-Use only the information provided in the context to answer. 
-If context is missing, apologize and say you cannot assist. Do not hallucinate."""
+vector_store = Chroma(client=client, collection_name=collection_name)
+retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 4})
 
+# === Prompt System ===
+SYSTEM_PROMPT = """You are a friendly XENO Support Assistant, an AI-powered helpful and professional customer service representative.
+Use only the information provided in the knowledge base context to answer user queries.
+Do not hallucinate. If context doesn't contain relevant info, say so in a calm polite manner by saying I'm sorry, I can't assist with that.
+Only use context that is clearly relevant to the user's question.
+For greetings like "hi" or "hello", respond politely without using the context.
+remember previous conversations."""
+
+# === Context Processing ===
 def process_context(results, cosine_scores, max_results=2):
+    """Process context with timing"""
     with timer.time_step("context_processing"):
-        if not results: return "", [], []
         sorted_indices = np.argsort(cosine_scores)[::-1][:max_results]
         formatted_context = ""
         source_ids = []
         knowledge_pairs = []
         for i, idx in enumerate(sorted_indices, 1):
-            if idx < len(results):
-                result = results[idx]
-                question = result.metadata.get('question', 'N/A')
-                answer = result.metadata.get('content', 'N/A')
-                formatted_context += f"Info {i}: Q: {question}\n A: {answer}\n---\n"
-                source_ids.append(str(result.metadata.get('id', 'N/A')))
-                knowledge_pairs.append((question, answer))
+            result = results[idx]
+            score = cosine_scores[idx]
+            question = result.metadata.get('question', 'N/A')
+            answer = result.metadata.get('content', 'N/A')
+            formatted_context += f"Knowledge Entry {i}:\n"
+            formatted_context += f"Q: {question}\n"
+            formatted_context += f"A: {answer}\n"
+            formatted_context += "-" * 40 + "\n"
+            source_ids.append(result.metadata.get('id', 'N/A'))
+            knowledge_pairs.append((question, answer))
         return formatted_context, source_ids, knowledge_pairs
 
+# === LLM Generation ===
 def generate_xeno_response(context, question, chat_history):
+    """Generate response with timing"""
     with timer.time_step("llm_generation"):
         model = genai.GenerativeModel(llm_model_name)
-        hist_text = "\n".join([f"{m['role']}: {m['content']}" for m in chat_history]) if chat_history else ""
-        prompt = f"{SYSTEM_PROMPT}\nHistory:\n{hist_text}\nContext:\n{context}\nQuestion:\n{question}"
+        formatted_history = "\n".join(
+            [f"{msg['role'].capitalize()}: {msg['content']}" for msg in chat_history]
+        ) if chat_history else "None"
+        
+        prompt = f"{SYSTEM_PROMPT}\n### HISTORY ###\n{formatted_history}\n### CONTEXT ###\n{context}\n### QUESTION ###\n{question}"
+        
         response = model.generate_content(prompt)
         return response.text.strip()
 
-# === Main Pipeline ===
-def get_context_and_answer(message, history, session_id):
+# === Main Interface Logic ===
+def get_context_and_answer(message, history, session_id="default"):
+    """Main pipeline with comprehensive timing"""
+    # Reset timer for new request
     timer.reset()
     error_step = None
     notes = []
@@ -345,108 +349,154 @@ def get_context_and_answer(message, history, session_id):
     try:
         config = {"configurable": {"thread_id": str(session_id), "checkpoint_ns": ""}}
         
+        # Step 1: Intent Classification
         with timer.time_step("intent_classification"):
             intent, direct_response = intent_classifier.classify_intent(message)
         
+        # Step 2: Memory Retrieval
         chat_history = retrieve_memory(config)
-        answer, source_ids, knowledge_pairs = "", "N/A", []
+        
+        answer = ""
+        source_ids = "N/A"
+        knowledge_pairs = []
 
         if intent != 'query':
             answer = direct_response
-            notes.append(f"Intent: {intent}")
-        else:
-            try:
-                with timer.time_step("rag_retrieval"):
-                    queried_results = retriever.invoke(message)
-                
-                with timer.time_step("embedding_generation"):
-                    q_embed = genai.embed_content(model=embedding_model, content=message, task_type="retrieval_query")['embedding']
-                    d_embeds = [genai.embed_content(model=embedding_model, content=d.page_content, task_type="retrieval_document")['embedding'] for d in queried_results]
-                
-                with timer.time_step("similarity_calculation"):
-                    if d_embeds:
-                        cosine_scores = util.cos_sim(torch.tensor(q_embed).float(), torch.tensor(d_embeds).float())[0].tolist()
+            notes.append(f"Simple intent: {intent}")
+        else: 
+            if len(message.strip()) < 3:
+                answer = "I'd be happy to help! Could you please provide more details about what you'd like to know?"
+                notes.append("Message too short")
+            else:
+                try:
+                    # Step 3: RAG Retrieval
+                    with timer.time_step("rag_retrieval"):
+                        queried_results = retriever.invoke(message)
+                    
+                    # Step 4: Embedding Generation
+                    with timer.time_step("embedding_generation"):
+                        query_embedding = genai.embed_content(
+                            model=embedding_model, 
+                            content=message, 
+                            task_type="retrieval_query"
+                        )['embedding']
+                        
+                        doc_embeddings = [
+                            genai.embed_content(
+                                model=embedding_model, 
+                                content=doc.page_content, 
+                                task_type="retrieval_document"
+                            )['embedding'] 
+                            for doc in queried_results
+                        ]
+                    
+                    # Step 5: Similarity Calculation
+                    with timer.time_step("similarity_calculation"):
+                        cosine_scores = util.cos_sim(
+                            torch.tensor(query_embedding).float(), 
+                            torch.tensor(doc_embeddings).float()
+                        )[0].tolist()
                         max_score = max(cosine_scores)
-                    else:
-                        cosine_scores, max_score = [], 0
-
-                if max_score < 0.4:
-                    answer = "I'm sorry, I couldn't find specific information for your question.Could You please specify exactly what seems to be the issue"
-                    notes.append(f"Low score: {max_score}")
-                else:
-                    context, source_ids_list, knowledge_pairs = process_context(queried_results, cosine_scores)
-                    answer = generate_xeno_response(context, message, chat_history)
-                    source_ids = ", ".join(source_ids_list)
-                    notes.append(f"Score: {max_score:.2f}")
-
-            except Exception as e:
-                error_step = "rag_pipeline"
-                answer = "I apologize, but I'm having a technical issue."
-                print(f"RAG Error: {e}")
 
+                    if max_score < 0.4:
+                        answer = "I'm sorry, I couldn't find specific information for your question. Could you try rephrasing it, or contact XENO support directly?"
+                        notes.append(f"Low similarity score: {max_score:.3f}")
+                    else:
+                        # Step 6: Context Processing (timed within function)
+                        context, source_ids_list, knowledge_pairs = process_context(queried_results, cosine_scores)
+                        
+                        # Step 7: LLM Generation (timed within function)
+                        answer = generate_xeno_response(context, message, chat_history)
+                        source_ids = ", ".join(source_ids_list)
+                        notes.append(f"Max similarity: {max_score:.3f}")
+
+                except Exception as e:
+                    error_step = timer.current_step or "rag_processing"
+                    print(f"Error during RAG processing: {e}")
+                    answer = "I apologize, but I'm having a technical issue. Please try again shortly or contact XENO support."
+                    notes.append(f"Error: {str(e)}")
+
+        # Step 8: Memory Update (timed within function)
         update_memory(config, message, answer)
         
+        # Step 9: Response Logging
         with timer.time_step("response_logging"):
             log_response(message, answer, source_ids, knowledge_pairs, session_id)
         
-        log_timing_data(message, session_id, timer.get_timing_summary(), error_step, "; ".join(notes))
+        # Log timing data
+        timing_summary = timer.get_timing_summary()
+        log_timing_data(
+            message, 
+            session_id, 
+            timing_summary, 
+            error_step=error_step,
+            notes="; ".join(notes) if notes else None
+        )
+        
         return answer
-
+        
     except Exception as e:
-        log_timing_data(message, session_id, timer.get_timing_summary(), "pipeline_crash", str(e))
-        return "System Error. Please try again."
+        error_step = timer.current_step or "main_pipeline"
+        logging.error(f"Error in main pipeline: {e}")
+        logging.error(traceback.format_exc())
+        
+        # Still log timing data even on error
+        timing_summary = timer.get_timing_summary()
+        log_timing_data(
+            message, 
+            session_id, 
+            timing_summary, 
+            error_step=error_step,
+            notes=f"Pipeline error: {str(e)}"
+        )
+        
+        return "I apologize, but I encountered an error processing your request. Please try again."
 
-# === UI Logic ===
+# === Enhanced Gradio UI ===
 def respond(message, history, session_id):
-    if not session_id: session_id = str(uuid.uuid4())
+    """Gradio's main response function"""
+    if not session_id:
+        session_id = str(uuid.uuid4())
+    
     bot_response = get_context_and_answer(message, history, session_id)
     history.append([message, bot_response])
+    
     return "", history
 
 def create_interface():
-    # 'fill_height=True' is key for the modern full-screen chat look
-    with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo:
-        gr.Markdown("## ASKXENO Support")
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # ASKXENO
+        **Welcome to XENO AI Support!**
+        
+        I can help you with questions about XENO financial services including:
+        - Account management and setup
+        - Transaction processes and fees
+        - Platform features and troubleshooting
+        - General service information
         
-        session_id_box = gr.Textbox(label="Session ID", value=str(uuid.uuid4()), visible=False)
+        *Simply type your question below to get started!*
+        """)
+        
+        session_id_box = gr.Textbox(label="Session ID", value=str(uuid.uuid4()), interactive=True)
         
-        # likeable=True adds the Thumbs Up/Down icons to bubbles
         chatbot = gr.Chatbot(
             label="XENO Assistant",
-            scale=1,
-            likeable=True,  
-            show_copy_button=True,
-            bubble_full_width=False
+            bubble_full_width=False,
+            height=500
         )
         
-        with gr.Row(variant="compact"):
+        with gr.Row():
             msg = gr.Textbox(
-                placeholder="Ask about XENO services...",
-                scale=6,
-                lines=1,
-                show_label=False,
-                autofocus=True,
-                container=False
+                label="Your Message",
+                placeholder="Type your question here...",
+                scale=3,
             )
-            send_btn = gr.Button("Send", variant="primary", scale=1, min_width=80)
-
-        # Collapsible Flagging Section
-        with gr.Accordion("Report an Issue", open=False):
-            with gr.Row():
-                flag_reason = gr.Textbox(placeholder="Describe the issue (e.g. incorrect fees)", show_label=False, scale=4)
-                flag_btn = gr.Button("Submit Report", scale=1)
-            flag_status = gr.Label(value="", show_label=False)
+            send_button = gr.Button("Send", variant="primary", scale=1)
 
-        # Event Wiring
+        send_button.click(respond, [msg, chatbot, session_id_box], [msg, chatbot])
         msg.submit(respond, [msg, chatbot, session_id_box], [msg, chatbot])
-        send_btn.click(respond, [msg, chatbot, session_id_box], [msg, chatbot])
-        
-        # Handle the native Google AI Studio style likes
-        chatbot.like(handle_vote, [chatbot, session_id_box], None)
-        
-        # Handle manual text flagging
-        flag_btn.click(submit_manual_flag, [flag_reason, chatbot, session_id_box], [flag_status])
-
+            
     return demo
 
 if __name__ == "__main__":