add response

Dockerfile

@@ -4,10 +4,11 @@ WORKDIR /app
 
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
-    
+
 COPY backend/ ./backend/
 COPY frontend/ ./frontend/
 
-EXPOSE 7860 7861
+EXPOSE 7860 7862
 
-CMD uvicorn backend.main:app --host 0.0.0.0 --port 7860 & python frontend/app.py
+CMD uvicorn backend.main:app --host 0.0.0.0 --port 7860 --app-dir /app & \
+    python frontend/app.py

backend/analytics.py

@@ -0,0 +1,43 @@
+from collections import defaultdict
+from datetime import datetime
+
+class AnalyticsTracker:
+    def __init__(self):
+        self.intent_counts = defaultdict(int)
+        self.total_queries = 0
+        self.recent_queries = []  # stores last 10 queries
+    
+    def log(self, text: str, intent: str, confidence: float):
+        self.intent_counts[intent] += 1
+        self.total_queries += 1
+        self.recent_queries.append({
+            "text": text,
+            "intent": intent,
+            "confidence": confidence,
+            "timestamp": datetime.now().strftime("%H:%M:%S")
+        })
+        # keep only last 10
+        if len(self.recent_queries) > 10:
+            self.recent_queries.pop(0)
+    
+    def get_top_intents(self, n=10):
+        sorted_intents = sorted(
+            self.intent_counts.items(),
+            key=lambda x: x[1],
+            reverse=True
+        )
+        return sorted_intents[:n]
+    
+    def get_summary(self):
+        return {
+            "total_queries": self.total_queries,
+            "unique_intents_seen": len(self.intent_counts),
+            "top_intents": [
+                {"intent": k, "count": v}
+                for k, v in self.get_top_intents()
+            ],
+            "recent_queries": self.recent_queries
+        }
+
+# Singleton
+tracker = AnalyticsTracker()

backend/classifier.py

@@ -32,7 +32,8 @@ LABEL_NAMES = [
     "unable_to_verify_identity", "verify_my_identity", "verify_source_of_funds",
     "verify_top_up", "virtual_card_not_working", "visa_or_mastercard",
     "why_verify_identity", "wrong_amount_of_cash_received",
-    "wrong_exchange_rate_for_cash_withdrawal"
+    "wrong_exchange_rate_for_cash_withdrawal",
+    "unknown" 
 ]
 
 class IntentClassifier:
@@ -45,7 +46,7 @@ class IntentClassifier:
         
         base_model = AutoModelForSequenceClassification.from_pretrained(
             MODEL_BASE,
-            num_labels=77,
+            num_labels=len(LABEL_NAMES),
             torch_dtype=torch.float16,
             device_map="cpu"
         )
@@ -76,10 +77,25 @@ class IntentClassifier:
                 "confidence": round(score.item() * 100, 2)
             })
 
+        top_confidence = results[0]["confidence"]
+        
+        # Confidence threshold — if model is uncertain, say so
+        THRESHOLD = 40.0
+        if results[0]["intent"] == "unknown" or results[0]["confidence"] < THRESHOLD:
+            return {
+                "top_intent": "unknown",
+                "confidence": results[0]["confidence"],
+                "top3": results,
+                "fallback": True,
+                "fallback_message": "I'm not sure I understand. Could you rephrase your banking query?"
+            }
+
         return {
             "top_intent": results[0]["intent"],
-            "confidence": results[0]["confidence"],
-            "top3": results
+            "confidence": top_confidence,
+            "top3": results,
+            "fallback": False,
+            "fallback_message": None
         }
 
 classifier = IntentClassifier()

backend/main.py

@@ -1,6 +1,12 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from classifier import classifier
+from analytics import tracker
+from responder import responder
 
 app = FastAPI(
     title="Banking Intent Classifier API",
@@ -20,6 +26,15 @@ class ClassifyResponse(BaseModel):
     top_intent: str
     confidence: float
     top3: list[IntentResult]
+    fallback: bool
+    fallback_message: str | None
+
+class RespondRequest(BaseModel):
+    text: str
+    intent: str
+
+class RespondResponse(BaseModel):
+    response: str
 
 # Routes
 @app.get("/")
@@ -36,4 +51,27 @@ def classify(request: ClassifyRequest):
         raise HTTPException(status_code=400, detail="Text cannot be empty")
     
     result = classifier.classify(request.text)
-    return result
+    
+    # log to analytics
+    tracker.log(
+        text=request.text,
+        intent=result["top_intent"],
+        confidence=result["confidence"]
+    )
+    
+    return result
+
+@app.post("/respond", response_model=RespondResponse)
+def respond(request: RespondRequest):
+    if request.intent == "unknown":
+        return {"response": "I'm not sure I understood your query. Could you please rephrase it or describe your banking issue in more detail?"}
+    
+    response = responder.generate(
+        customer_message=request.text,
+        intent=request.intent
+    )
+    return {"response": response}
+
+@app.get("/analytics")
+def analytics():
+    return tracker.get_summary()

backend/responder.py

@@ -0,0 +1,61 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+
+INSTRUCT_MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
+
+SYSTEM_PROMPT = """You are a helpful, empathetic customer service agent for a digital banking app.
+You help customers with payment issues, card problems, account management, and transfer queries.
+Keep responses concise (2-3 sentences), friendly, and actionable.
+If you need more information, ask one specific question.
+Never make up specific account details or transaction information."""
+
+class ResponseGenerator:
+    def __init__(self):
+        print("Loading response generator...")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(INSTRUCT_MODEL)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            INSTRUCT_MODEL,
+            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+            device_map="cpu"
+        )
+        self.model.eval()
+        print("Response generator loaded!")
+
+    def generate(self, customer_message: str, intent: str) -> str:
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": f"""Customer message: "{customer_message}"
+Detected intent: {intent.replace("_", " ")}
+
+Please write a helpful response to this customer."""}
+        ]
+
+        text = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+
+        inputs = self.tokenizer(
+            text,
+            return_tensors="pt"
+        ).to(self.device)
+
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_new_tokens=150,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+
+        new_tokens = outputs[0][inputs['input_ids'].shape[1]:]
+        response = self.tokenizer.decode(new_tokens, skip_special_tokens=True)
+        
+        return response.strip()
+
+# Singleton
+responder = ResponseGenerator()

frontend/app.py

@@ -1,76 +1,179 @@
 import gradio as gr
 import requests
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.use('Agg')  # non-interactive backend for servers
 
 BACKEND_URL = "http://localhost:7860"
 
 def classify_intent(text):
     if not text.strip():
-        return "Please enter a message", ""
+        return "Please enter a message", "", ""
     
     try:
-        response = requests.post(
+        # Step 1 - classify
+        classify_response = requests.post(
             f"{BACKEND_URL}/classify",
             json={"text": text}
         )
-        result = response.json()
+        result = classify_response.json()
         
-        # Format top intent
-        top_intent = result["top_intent"].replace("_", " ").title()
-        confidence = result["confidence"]
-        
-        # Format top 3
+        # Step 2 - format top 3
         top3_text = ""
         for i, item in enumerate(result["top3"], 1):
             intent = item["intent"].replace("_", " ").title()
             conf = item["confidence"]
             top3_text += f"{i}. {intent} — {conf}%\n"
         
-        return f"**{top_intent}** ({confidence}%)", top3_text
+        # Step 3 - handle fallback
+        if result.get("fallback"):
+            return (
+                f"⚠️ **Unknown Query** ({result['confidence']}%)",
+                top3_text,
+                result["fallback_message"]
+            )
+        
+        top_intent = result["top_intent"].replace("_", " ").title()
+        confidence = result["confidence"]
+        
+        # Step 4 - generate response
+        respond_response = requests.post(
+            f"{BACKEND_URL}/respond",
+            json={
+                "text": text,
+                "intent": result["top_intent"]
+            }
+        )
+        generated = respond_response.json()["response"]
+        
+        return (
+            f"**{top_intent}** ({confidence}%)",
+            top3_text,
+            generated
+        )
+    
+    except Exception as e:
+        return f"Error: {str(e)}", "", ""
+
+def get_analytics():
+    try:
+        response = requests.get(f"{BACKEND_URL}/analytics")
+        data = response.json()
+        
+        total = data["total_queries"]
+        unique = data["unique_intents_seen"]
+        top_intents = data["top_intents"]
+        recent = data["recent_queries"]
+        
+        # Build bar chart
+        if top_intents:
+            labels = [x["intent"].replace("_", " ").title() for x in top_intents]
+            counts = [x["count"] for x in top_intents]
+            
+            fig, ax = plt.subplots(figsize=(10, 5))
+            bars = ax.barh(labels[::-1], counts[::-1], color="#4F86C6")
+            ax.set_xlabel("Number of Queries")
+            ax.set_title("Top Intents by Frequency")
+            
+            # Add count labels on bars
+            for bar, count in zip(bars, counts[::-1]):
+                ax.text(
+                    bar.get_width() + 0.1,
+                    bar.get_y() + bar.get_height()/2,
+                    str(count),
+                    va='center'
+                )
+            
+            plt.tight_layout()
+        else:
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, "No queries yet", ha='center', va='center')
+
+        # Build recent queries table
+        recent_text = ""
+        if recent:
+            recent_text = "Time     | Intent | Confidence\n"
+            recent_text += "-" * 50 + "\n"
+            for q in reversed(recent):
+                intent = q["intent"].replace("_", " ").title()
+                recent_text += f"{q['timestamp']} | {intent} | {q['confidence']}%\n"
+        else:
+            recent_text = "No queries yet"
+        
+        summary = f"Total Queries: {total} | Unique Intents Seen: {unique}"
+        
+        return fig, recent_text, summary
     
     except Exception as e:
-        return f"Error: {str(e)}", ""
+        fig, ax = plt.subplots()
+        ax.text(0.5, 0.5, f"Error: {str(e)}", ha='center', va='center')
+        return fig, "", "Error fetching analytics"
 
-# Build UI
 with gr.Blocks(title="Banking Intent Classifier") as demo:
-    gr.Markdown("""
-    # 🏦 Banking Intent Classifier
-    Powered by fine-tuned Qwen2.5 + LoRA | Trained on BANKING77
-    """)
+    gr.Markdown("# 🏦 Banking Intent Classifier")
+    gr.Markdown("Powered by fine-tuned Qwen2.5 + LoRA | Trained on BANKING77")
     
-    with gr.Row():
-        with gr.Column():
-            text_input = gr.Textbox(
-                label="Customer Message",
-                placeholder="e.g. my card hasn't arrived yet...",
-                lines=3
-            )
-            submit_btn = gr.Button("Classify", variant="primary")
-        
-        with gr.Column():
-            intent_output = gr.Markdown(label="Detected Intent")
-            top3_output = gr.Textbox(
-                label="Top 3 Predictions",
+    with gr.Tabs():
+        with gr.Tab("🔍 Classify"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Customer Message",
+                        placeholder="e.g. my card hasn't arrived yet...",
+                        lines=3
+                    )
+                    submit_btn = gr.Button("Classify", variant="primary")
+                
+                with gr.Column():
+                    intent_output = gr.Markdown(label="Detected Intent")
+                    top3_output = gr.Textbox(
+                        label="Top 3 Predictions",
+                        lines=4,
+                        interactive=False
+                    )
+            
+            # Response below the two columns
+            response_output = gr.Textbox(
+                label="💬 Suggested Customer Service Response",
                 lines=4,
                 interactive=False
             )
-    
-    # Example queries
-    gr.Examples(
-        examples=[
-            ["My card hasn't arrived yet"],
-            ["I can't remember my PIN"],
-            ["My transfer failed"],
-            ["I think my card was stolen"],
-            ["Why is my balance wrong?"],
-        ],
-        inputs=text_input
-    )
-    
-    submit_btn.click(
-        fn=classify_intent,
-        inputs=text_input,
-        outputs=[intent_output, top3_output]
-    )
+            
+            gr.Examples(
+                examples=[
+                    ["My card hasn't arrived yet"],
+                    ["I can't remember my PIN"],
+                    ["My transfer failed"],
+                    ["I think my card was stolen"],
+                    ["Why is my balance wrong?"],
+                    ["hi"],           # ← tests unknown class
+                    ["what is life"], # ← tests unknown class
+                ],
+                inputs=text_input
+            )
+            
+            submit_btn.click(
+                fn=classify_intent,
+                inputs=text_input,
+                outputs=[intent_output, top3_output, response_output]  # ← added response_output
+            )
+        
+        with gr.Tab("📊 Analytics"):
+            refresh_btn = gr.Button("Refresh Dashboard", variant="primary")
+            summary_output = gr.Markdown()
+            
+            with gr.Row():
+                chart_output = gr.Plot(label="Intent Frequency")
+                recent_output = gr.Textbox(
+                    label="Recent Queries",
+                    lines=12,
+                    interactive=False
+                )
+            
+            refresh_btn.click(
+                fn=get_analytics,
+                outputs=[chart_output, recent_output, summary_output]
+            )
 
 if __name__ == "__main__":
-    demo.launch(server_port=7861)
+    demo.launch(server_port=7862)

requirements.txt

@@ -3,6 +3,7 @@ fastapi
 uvicorn
 
 # ML
+matplotlib
 torch
 transformers
 peft