Update app.py

app.py

@@ -2,13 +2,14 @@ import os
 import re
 import asyncio
 import gradio as gr
+from datetime import datetime
+import langdetect
 import RAG_Domain_know_doc
 from web_search import search_autism
 from RAG import rag_autism
-from openai import OpenAI  # Corrected import
+from openai import OpenAI
 from dotenv import load_dotenv
-import Old_Document 
-from datetime import datetime
+import Old_Document
 import User_Specific_Documents
 from prompt_template import (
     Prompt_template_translation,
@@ -22,25 +23,18 @@ from prompt_template import (
     Prompt_template_User_document_prompt
 )
 
-GEMINI_API_KEY="AIzaSyCUCivstFpC9pq_jMHMYdlPrmh9Bx97dFo"
-TAVILY_API_KEY="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"
-OPENAI_API_KEY="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"
-QDRANT_API_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIiwiZXhwIjoxNzUxMDUxNzg4fQ.I9J-K7OM0BtcNKgj2d4uVM8QYAHYfFCVAyP4rlZkK2E"
-QDRANT_URL="https://6a3aade6-e8ad-4a6c-a579-21f5af90b7e8.us-east4-0.gcp.cloud.qdrant.io"
-OPENAI_API_KEY="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"
-WEAVIATE_URL="https://xbvlj5rpqyiswspww0tthq.c0.us-west3.gcp.weaviate.cloud"
-WEAVIATE_API_KEY="RU9acU1CYnNRTjY1S1ZFc18zNS9tQktaWlcwTzFEUjlscEVCUGF4YU5xRWx2MDhmTUtIdUhnOWdOTGVZPV92MjAw"
-DEEPINFRA_API_KEY="285LUJulGIprqT6hcPhiXtcrphU04FG4"
-DEEPINFRA_BASE_URL="https://api.deepinfra.com/v1/openai"
+# API Keys and Constants
+DEEPINFRA_API_KEY = "285LUJulGIprqT6hcPhiXtcrphU04FG4"
+
 # Initialize OpenAI client
-env = os.getenv("ENVIRONMENT", "production")
 openai = OpenAI(
     api_key=DEEPINFRA_API_KEY,
     base_url="https://api.deepinfra.com/v1/openai",
 )
-timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
-# Rest of your code remains unchanged
-# Helper to call chat completion synchronously
+
+SESSION_ID = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+# Chat Completion Helper
 def call_llm(model: str, messages: list[dict], temperature: float = 0.0, **kwargs) -> str:
     resp = openai.chat.completions.create(
         model=model,
@@ -50,127 +44,108 @@ def call_llm(model: str, messages: list[dict], temperature: float = 0.0, **kwarg
     )
     return resp.choices[0].message.content.strip()
 
-# Basic greeting detection
+# Greeting Detection
 def is_greeting(text: str) -> bool:
     return bool(re.search(r"\b(hi|hello|hey|good (morning|afternoon|evening))\b", text, re.I))
 
+# Logging
+def _save_process_log(log_lines, filename=None):
+    logs_dir = os.path.join(os.path.dirname(__file__), "logs")
+    os.makedirs(logs_dir, exist_ok=True)
+    log_filename = filename or os.path.join(logs_dir, f"chat_session_{SESSION_ID}.txt")
+    try:
+        with open(log_filename, "a", encoding="utf-8") as f:
+            f.write("=" * 50 + "\n")
+            for line in log_lines:
+                f.write(str(line) + "\n\n")
+    except Exception as e:
+        print("Logging error:", e)
 
+# Main Process Function
 def process_query(query: str, first_turn: bool = False):
     intro = ""
     process_log = []
 
     if first_turn and (not query or query.strip() == ""):
         intro = "Hello! I’m Wisal, an AI assistant developed by Compumacy AI, specializing in Autism Spectrum Disorders. How can I help you today?"
-        process_log.append(intro)
+        process_log.append("User: [empty or first turn]")
+        process_log.append(f"Wisal: {intro}")
         _save_process_log(process_log)
         return intro
-    # 0: Handle simple greetings
+
+    process_log.append(f"User: {query}")
+
     if is_greeting(query):
         greeting = intro + "Hello! I’m Wisal, your AI assistant developed by Compumacy AI. How can I help you today?"
-        process_log.append(f"Greeting detected.\n{greeting}")
+        process_log.append(f"Wisal: {greeting}")
         _save_process_log(process_log)
         return greeting
 
-    # 1: Translation & Rephrasing
     corrected_query = call_llm(
         model="Qwen/Qwen3-32B",
-        messages=[{"role": "user", "content": Prompt_template_translation.format(query=query)}],
-        reasoning_effort="none"
+        messages=[{"role": "user", "content": Prompt_template_translation.format(query=query)}]
     )
     process_log.append(f"Corrected Query: {corrected_query}")
-    
 
-    # 2: Relevance Check
     relevance = call_llm(
         model="Qwen/Qwen3-32B",
-        messages=[{"role": "user", "content": Prompt_template_relevance.format(corrected_query=corrected_query)}],
-        reasoning_effort="none"
+        messages=[{"role": "user", "content": Prompt_template_relevance.format(corrected_query=corrected_query)}]
     )
     process_log.append(f"Relevance: {relevance}")
     if relevance != "RELATED":
-        process_log.append(f"Query not related. Returning: {relevance}")
+        process_log.append(f"Wisal: {relevance}")
         _save_process_log(process_log)
-        return intro + relevance
+        return relevance
 
-    # Step 3: Web Search
     web_search_resp = asyncio.run(search_autism(corrected_query))
     web_answer = web_search_resp.get("answer", "")
     process_log.append(f"Web Search Answer: {web_answer}")
 
-    # Step 4: LLM Generation
-    gen_prompt = Prompt_template_LLM_Generation.format(new_query=corrected_query)
     generated = call_llm(
         model="Qwen/Qwen3-32B",
-        messages=[{"role": "user", "content": gen_prompt}],
-        reasoning_effort="none"
+        messages=[{"role": "user", "content": Prompt_template_LLM_Generation.format(new_query=corrected_query)}]
     )
     process_log.append(f"LLM Generated: {generated}")
 
-    # Step 5: RAG
     rag_resp = asyncio.run(rag_autism(corrected_query, top_k=3))
     rag_contexts = rag_resp.get("answer", [])
     process_log.append(f"RAG Contexts: {rag_contexts}")
 
-    # 6) Reranking (now across 3 candidates)
     rag_text = "\n".join(f"[{i+1}] {c}" for i, c in enumerate(rag_contexts))
     answers_list = f"[1] {generated}\n[2] {web_answer}\n{rag_text}"
-    rerank_prompt = Prompt_template_Reranker.format(
-        new_query=corrected_query,
-        answers_list=answers_list
-    )
     reranked = call_llm(
         model="Qwen/Qwen3-32B",
-        messages=[{"role":"user","content":rerank_prompt}],
-        reasoning_effort="none"
+        messages=[{"role": "user", "content": Prompt_template_Reranker.format(new_query=corrected_query, answers_list=answers_list)}]
     )
     process_log.append(f"Reranked: {reranked}")
 
-    # 7) Wisal final‐answer generation
-    wisal_prompt = Prompt_template_Wisal.format(
-        new_query=corrected_query,
-        document=reranked  # use reranked output here
-    )
     wisal = call_llm(
         model="Qwen/Qwen3-32B",
-        messages=[{"role":"user","content":wisal_prompt}],
-        reasoning_effort="none"
+        messages=[{"role": "user", "content": Prompt_template_Wisal.format(new_query=corrected_query, document=reranked)}]
     )
     process_log.append(f"Wisal Final Answer: {wisal}")
 
-    # 8) Hallucination Check
-    halluc_prompt = Prompt_template_Halluciations.format(
-        new_query=corrected_query,
-        answer=wisal,
-        document=generated
-    )
     halluc = call_llm(
         model="Qwen/Qwen3-32B",
-        messages=[{"role": "user", "content": halluc_prompt}],
-        reasoning_effort="none"
+        messages=[{"role": "user", "content": Prompt_template_Halluciations.format(new_query=corrected_query, answer=wisal, document=generated)}]
     )
     process_log.append(f"Hallucination Check: {halluc}")
     score = int(halluc.split("Score: ")[1]) if "Score: " in halluc else 3
 
-    # 9) Paraphrase if needed
     if score in (2, 3):
         paraphrase = call_llm(
             model="Qwen/Qwen3-32B",
-            messages=[{"role": "user", "content": Prompt_template_paraphrasing.format(document=generated)}],
-            reasoning_effort="none"
+            messages=[{"role": "user", "content": Prompt_template_paraphrasing.format(document=generated)}]
         )
         process_log.append(f"Paraphrased: {paraphrase}")
-        context_prompt = Prompt_template_Wisal.format(new_query=corrected_query, document=paraphrase)
         final_doc = call_llm(
             model="Qwen/Qwen3-32B",
-            messages=[{"role": "user", "content": context_prompt}],
-            reasoning_effort="none"
+            messages=[{"role": "user", "content": Prompt_template_Wisal.format(new_query=corrected_query, document=paraphrase)}]
         )
         process_log.append(f"Wisal with Paraphrase: {final_doc}")
     else:
         final_doc = wisal
 
-    # 10) Translate back if needed (improved: only if input is not English)
-    import langdetect
     try:
         detected_lang = langdetect.detect(query)
     except Exception:
@@ -178,45 +153,24 @@ def process_query(query: str, first_turn: bool = False):
     if detected_lang != "en":
         result = call_llm(
             model="Qwen/Qwen3-32B",
-            messages=[{"role": "user", "content": Prompt_template_Translate_to_original.format(query=query, document=final_doc)}],
-            reasoning_effort="none"
+            messages=[{"role": "user", "content": Prompt_template_Translate_to_original.format(query=query, document=final_doc)}]
         )
         process_log.append(f"Translated Back: {result}")
     else:
         result = final_doc
         process_log.append(f"Final Result: {result}")
 
+    process_log.append(f"Wisal: {result}")
     _save_process_log(process_log)
     return intro + result
 
+# Gradio Interface
 def main_pipeline_with_doc_and_history(query, doc_file, doc_type, history):
     response = main_pipeline_with_doc(query, doc_file, doc_type)
     updated_history = history + f"\nUser: {query}\nWisal: {response}\n"
     return response, updated_history
 
-# Utility to save process log to a txt file
-def _save_process_log(log_lines, filename="process_output.txt"):
-    # Ensure logs directory exists
-    logs_dir = os.path.join(os.path.dirname(__file__), "logs")
-    os.makedirs(logs_dir, exist_ok=True)
-    # Unique filename per question (timestamped)
-    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
-    log_filename = os.path.join(logs_dir, f"log_{timestamp}.txt")
-    try:
-        with open(log_filename, "w", encoding="utf-8") as f:
-            for line in log_lines:
-                f.write(str(line) + "\n\n")
-    except Exception as e:
-        pass
-
-
-# Gradio UI for main pipeline, RAG_Domain_know_doc, and User_Specific_Documents , Old_Document
-def main_pipeline_interface(query):
-    return process_query(query, first_turn=True)
-
-
 def main_pipeline_with_doc(query, doc_file, doc_type):
-    # If no document, use main pipeline
     if doc_file is None or doc_type == "None":
         return process_query(query, first_turn=True)
 
@@ -226,21 +180,15 @@ def main_pipeline_with_doc(query, doc_file, doc_type):
 
     save_path = os.path.join(upload_dir, safe_filename)
 
-    # 💡 Check if doc_file is file-like (has `.read()`) or path-like (str or NamedString)
     if hasattr(doc_file, 'read'):
-        # File-like object
         file_bytes = doc_file.read()
     else:
-        # It's a path (NamedString), read from file path
         with open(str(doc_file), 'rb') as f:
             file_bytes = f.read()
 
-    # Save the file content
     with open(save_path, "wb") as f:
         f.write(file_bytes)
 
-
-    # Route to correct document handler
     if doc_type == "Knowledge Document":
         status = RAG_Domain_know_doc.ingest_file(save_path)
         answer = RAG_Domain_know_doc.answer_question(query)
@@ -290,4 +238,6 @@ with gr.Blocks(title="Wisal Main Pipeline & RAG") as demo:
 
 if __name__ == "__main__":
     demo.launch(debug=True)
-
+    
+    
+