Update app.py

app.py

@@ -2,11 +2,6 @@ import uuid
 import os
 import gradio as gr
 import pandas as pd
-import torch
-import numpy as np
-from sentence_transformers import util
-import google.generativeai as genai
-import chromadb
 from langchain_chroma import Chroma
 import gspread
 from google.oauth2.service_account import Credentials
@@ -14,68 +9,187 @@ from langgraph.checkpoint.sqlite import SqliteSaver
 import sqlite3
 import json
 from datetime import datetime
+import re
+# Open the Google Sheet
+sheet = client_gspread.open("Response_Log").sheet1
+
+def log_response(question, answer, source_ids, knowledge_pairs, session_id):
+    """
+    Log a question, answer, source IDs, and knowledge base question-answer pairs to the Google Sheet.
+    
+    knowledge_answer_2 = knowledge_pairs[1][1] if len(knowledge_pairs) > 1 else "N/A"
+    row = [
+        timestamp,
+        session_id,
+        question,
+        answer,
+        source_ids,
+        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")
+
+# === LangGraph Memory Setup ===
+conn = sqlite3.connect("xeno_memory.db", check_same_thread=False)
+memory = SqliteSaver(conn=conn)
 
-# Your RAG pipeline functions
-def get_context_and_answer(query, history, session_id):
-    # TODO: Replace with your real retrieval + generation logic
-    # Currently just returns a dummy response
-    return f"Echo: {query} (Session: {session_id})"
+def update_memory(config, user_message, assistant_message):
+    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_to_save = {
+        "v": 1,
+        "id": str(uuid.uuid4()),
+        "ts": datetime.now().isoformat(),
+        "channel_values": {"messages": messages},
+        "channel_versions": {},
+        "versions_seen": {},   
+    }
+    
+    memory.put(config, checkpoint_to_save, {}, {})
+    
+# === Intent Classification System ===
+class IntentClassifier:
+    def __init__(self):
+        knowledge_pairs.append((question, answer))
+    return formatted_context, source_ids, knowledge_pairs
+
+# === LLM Generation (Refactored) ===
+def generate_xeno_response(context, question, chat_history):
+    """Generates a response but does NOT handle memory."""
+    model = genai.GenerativeModel(llm_model_name)
+    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 Interface Logic (Refactored) ===
+def get_context_and_answer(message, history, session_id="default"):
+    """
+    Handles intent classification, RAG, and memory updates in one place.
+    """
+    config = {"configurable": {"thread_id": str(session_id), "checkpoint_ns": ""}}
+
+    
+    full_checkpoint = memory.get(config) or {}
+    chat_history = full_checkpoint.get("channel_values", {}).get("messages", [])
+    intent, direct_response = intent_classifier.classify_intent(message)
+
+    
+    answer = ""
+    source_ids = "N/A"
+    knowledge_pairs = []
+
+    if intent != 'query':
+        answer = direct_response
+    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?"
+        else:
+            try:
+                queried_results = retriever.invoke(message)
+                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]
+                
+                cosine_scores = util.cos_sim(torch.tensor(query_embedding).float(), torch.tensor(doc_embeddings).float())[0].tolist()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                if max(cosine_scores) < 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?"
+                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)
+
+            except Exception as e:
+                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."
 
-# Main respond function
-def respond(message, history, session_id):
-    if not session_id:
-        session_id = str(uuid.uuid4())
 
-    history = history or []
 
-    # Append user message
-    history.append({"role": "user", "content": message})
 
-    # Get assistant's reply
+
+
+
+
+
+
+
+
+    update_memory(config, message, answer)
+    log_response(message, answer, source_ids, knowledge_pairs, session_id)
+    
+    return answer
+
+# === Enhanced Gradio UI ===
+def respond(message, history, session_id):
+    """Gradio's main response function."""
+    if not session_id:
+        session_id = str(uuid.uuid4())
+    
     response = get_context_and_answer(message, history, session_id)
+    
+    config = {"configurable": {"thread_id": str(session_id), "checkpoint_ns": ""}}
+    updated_messages = (memory.get(config) or {}).get("messages", [])
 
-    # Append assistant's reply
-    history.append({"role": "assistant", "content": response})
 
-    return "", history
 
-# Build the Gradio interface
-def create_interface():
-    with gr.Blocks() 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()), interactive=True)
 
-        chatbot = gr.Chatbot(label="XENO Assistant", bubble_full_width=False, height=500, type="messages")
 
-        with gr.Row():
-            msg = gr.Textbox(
-                label="Your Message",
-                placeholder="Type your question here...",
-                scale=8
-            )
-            send_btn = gr.Button("Send", scale=1)
 
-        clear_btn = gr.Button("Clear Chat")
 
-        # Submit via Enter
-        msg.submit(respond, [msg, chatbot, session_id_box], [msg, chatbot])
-        # Submit via Send button
-        send_btn.click(respond, [msg, chatbot, session_id_box], [msg, chatbot])
-        # Clear chat
-        clear_btn.click(lambda: ("", []), None, [msg, chatbot])
 
+    
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": response})
+    
+    return "", history
+def create_interface():
+    with gr.Blocks() 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
+            *Simply type your question below to get started!*
+                    """)
+        
+        session_id_box = gr.Textbox(label="Session ID", value=str(uuid.uuid4()), interactive=True)
+        
+        chatbot = gr.Chatbot(label="XENO Assistant", bubble_full_width=False, height=500, type="messages")
+        msg = gr.Textbox(label="Your Message", placeholder="Type your question here...")
+        
+        msg.submit(respond, [msg, chatbot, session_id_box], [msg, chatbot])
     return demo
 
+
 if __name__ == "__main__":
-    app = create_interface()
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    iface = create_interface()
+    iface.launch(share=False, server_name="0.0.0.0", server_port=7860, , ssr_mode=False)