Update GHAPA UI and README: multilingual detection, backend error handling, and full project description

README.md

@@ -7,17 +7,39 @@ sdk: "gradio"
 app_file: "app.py"
 pinned: false
 secrets:
-- MODAL_BACKEND_URL
+  - MODAL_BACKEND_URL
 ---
 
-# 🧠 GHAPA: Intelligent Health AI Assistant (Powered by Modal ⚡)
-This is the user interface for the GHAPA multi-agent system. It provides a simple, responsive UI that communicates with a powerful, GPU-accelerated backend hosted on Modal Labs.
+# 🧠 GHAPA: Global Health AI Prompt Assistant (Powered by Modal ⚡)
 
-This decoupled architecture ensures that the user interface remains lightweight and fast, while all computationally intensive AI tasks are handled by a scalable, on-demand backend.
+**GHAPA** is a multilingual biomedical assistant that provides trusted, citable health information across global languages. It combines real-time hybrid search with domain-specific LLM reasoning in a modular Retrieval-Augmented Generation (RAG) pipeline.
 
-### How to Use
-Ask your health question in **English, Spanish, Hindi, or French**. The system will:
-1.  Auto-detect your language.
-2.  Send the query to the Modal backend.
-3.  Receive a trusted answer generated from PubMed articles.
-4.  Display the result, usually within seconds.
+## 🌍 Key Features
+
+- 🌐 **Multilingual Q&A**: Accepts questions in **English**, **Hindi**, **Spanish**, and **French**, with automatic language detection and translation.
+- 🔍 **Hybrid Search**: Retrieves biomedical data from **PubMed** and general health insights via **DuckDuckGo**, ensuring broader yet reliable context.
+- 📚 **Citable Results**: Every answer includes a direct **source link** and **context snippet**.
+- 🧠 **Biomedical Reasoning**: Uses **PMC-LLaMA**, a large language model fine-tuned on medical literature, for precise and grounded answers.
+- ⚙️ **Serverless Backend**: All heavy processing runs on scalable GPU backends via [Modal](https://modal.com), decoupled from the lightweight Gradio UI.
+- 💡 **Minimal UI**: Clean, responsive interface built using [Gradio](https://www.gradio.app), hosted on [Hugging Face Spaces](https://huggingface.co/spaces).
+
+---
+
+## 🛠 Architecture Overview
+
+```plaintext
+         User Input (any language)
+                 ↓
+     Language Detection & Translation
+                 ↓
+     Hybrid Search (PubMed + DuckDuckGo)
+                 ↓
+   Unified Ranking (SentenceTransformer)
+                 ↓
+   Prompt Construction with Top Contexts
+                 ↓
+   PMC-LLaMA Generative Reasoning Engine
+                 ↓
+     Back-Translation & Markdown Output
+                 ↓
+        Final Answer + Cited Sources

app.py

@@ -5,58 +5,84 @@ import requests
 import os
 
 # --- Configuration ---
-# This securely retrieves the backend URL from the Hugging Face Space secret.
 MODAL_BACKEND_URL = os.getenv("MODAL_BACKEND_URL")
 
-# A critical check to ensure the secret is set. The app will not start without it.
-if not MODAL_BACKEND_URL:
-    raise ValueError("The MODAL_BACKEND_URL secret is not set in your Hugging Face Space! Please add it in the Settings tab.")
+# --- Backend Communication ---
+def call_modal_backend(user_input):
+    if not MODAL_BACKEND_URL:
+        return {
+            "final_markdown": "### ❗ Configuration Error\n**Reason**: `MODAL_BACKEND_URL` is not set. Please configure the secret in your Hugging Face Space settings.",
+            "detected_lang": "Unknown"
+        }
 
-# This function is the bridge between your Gradio UI and your Modal backend.
-def call_modal_backend(user_input: str):
-    """
-    Takes the user's input, sends it to the Modal backend via an HTTP POST
-    request, and returns the final markdown response.
-    """
-    if not user_input or not user_input.strip():
-        return "Please enter a question to get started."
-
-    # Prepare the request headers and payload
     headers = {"Content-Type": "application/json"}
-    payload = {"user_input": user_input}
+    data = {"user_input": user_input}
 
     try:
-        # Make the POST request to the Modal serverless function
-        response = requests.post(MODAL_BACKEND_URL, headers=headers, json=payload, timeout=300)
-        
-        # Raise an exception for bad HTTP status codes (like 404 or 500)
+        response = requests.post(MODAL_BACKEND_URL, headers=headers, json=data, timeout=300)
         response.raise_for_status()
-        
-        # Parse the JSON response from the backend
-        result = response.json()
-        
-        # Safely get the final markdown. If the key is missing, return an error.
-        return result.get("final_markdown", "### ❗ Error\nReceived an unexpected response format from the backend.")
-
-    except requests.exceptions.Timeout:
-        return "### ❗ Error: The request timed out. The AI backend may be busy or starting up. Please try again in a moment."
+        return response.json()
     except requests.exceptions.RequestException as e:
-        # Handle any other network errors (e.g., connection failed)
-        return f"### ❗ Error: Could not connect to the AI backend.\n**Details**: {e}"
+        return {
+            "final_markdown": f"### ❗ Network Error\n**Reason**: Could not connect to the backend API.\n**Details**: {str(e)}",
+            "detected_lang": "Error"
+        }
 
-# --- Gradio User Interface ---
-with gr.Blocks(theme=gr.themes.Soft(), css="footer {display: none !important}") as demo:
-    gr.Markdown("""# 🧠 GHAPA: Intelligent Health AI Assistant (Powered by Modal ⚡)
-Ask your health question in **English, Spanish, Hindi, or French**. The system fetches trusted PubMed answers at high speed.""")
+# --- Gradio UI Definition ---
+with gr.Blocks(theme=gr.themes.Soft(), css="footer {display: none !important;}") as demo:
+    gr.Markdown("""
+    # 🧠 GHAPA: Global Health AI Prompt Assistant
+    _Ask trusted health questions in **English**, **Hindi**, **Spanish**, or **French**._
+    """)
 
     with gr.Row():
-        inp = gr.Textbox(label="Enter your question", placeholder="e.g., 'What are the symptoms of dengue?'", scale=4)
-        btn = gr.Button("Submit", variant="primary", scale=1)
-    
-    o5 = gr.Markdown(label="Answer & Explanation")
+        inp = gr.Textbox(
+            label="❓ Enter your health question",
+            placeholder="e.g., What are the symptoms of dengue?",
+            scale=4
+        )
+        btn = gr.Button("🔍 Submit", variant="primary", scale=1)
+
+    lang_detected = gr.Markdown("🌐 Language detected: _waiting..._", visible=False)
+    output = gr.Markdown(label="✅ Answer & Explanation")
+    backend_result = gr.State()
+
+    def start_processing(user_input):
+        if not user_input.strip():
+            return {
+                inp: gr.update(),
+                btn: gr.update(),
+                output: "Please enter a question before submitting.",
+                lang_detected: gr.update(visible=False),
+            }
+        return {
+            inp: gr.update(interactive=False),
+            btn: gr.update(interactive=False, value="⏳ Processing..."),
+            output: "",
+            lang_detected: gr.update(visible=True, value="🌐 Detecting language and processing..."),
+        }
+
+    def finish_processing(response_json):
+        return {
+            inp: gr.update(interactive=True),
+            btn: gr.update(interactive=True, value="🔍 Submit"),
+            output: response_json.get("final_markdown", "Error: No response from backend."),
+            lang_detected: gr.update(visible=True, value=f"🌐 Language detected: **{response_json.get('detected_lang', 'Unknown')}**"),
+        }
 
-    # The click function is now simple and calls our backend function.
-    btn.click(fn=call_modal_backend, inputs=[inp], outputs=[o5])
+    btn.click(
+        fn=start_processing,
+        inputs=[inp],
+        outputs=[inp, btn, output, lang_detected]
+    ).then(
+        fn=call_modal_backend,
+        inputs=[inp],
+        outputs=[backend_result]
+    ).then(
+        fn=finish_processing,
+        inputs=[backend_result],
+        outputs=[inp, btn, output, lang_detected]
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()