updated

app.py

@@ -1,17 +1,39 @@
-import gradio as gr
+# app.py — Updated version for Hugging Face token & CPU
+
+import os
+import tempfile
+import textwrap
 from datetime import datetime
-from pathlib import Path
-from src.model_loader import load_local_model
+from typing import List, Dict, Any, Optional
+
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
 from src.conversation import ConversationMemory
 from src.chatbot import LocalChatbot
 
-# ----------------------------
-# Model & Memory
-# ----------------------------
-MODEL_PATH = "togethercomputer/Gemini-2-2B"  # public HF model
-llm = load_local_model(MODEL_PATH, device=-1)  # CPU
+# ----------------------
+# HUGGING FACE SETTINGS
+# ----------------------
+HF_TOKEN = os.getenv("HF_TOKEN")  # your Hugging Face token stored as secret variable
+MODEL_PATH = "RedHatAI/gemma-2-2b-it-quantized.w4a16"  # public or private model
+
+# ----------------------
+# LOAD MODEL + TOKENIZER
+# ----------------------
+tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, use_fast=True, use_auth_token=HF_TOKEN)
+llm = AutoModelForCausalLM.from_pretrained(
+    MODEL_PATH,
+    device_map="cpu",        # CPU for multiple users
+    torch_dtype="auto",
+    use_auth_token=HF_TOKEN
+)
+
+# ----------------------
+# MEMORY + CHATBOT
+# ----------------------
 memory = ConversationMemory(max_len=60)
-bot = LocalChatbot(llm, memory)
+bot = LocalChatbot(llm, memory, tokenizer=tokenizer)
 
 INTENT_TEMPLATES = {
     "math": "You are a math solver. Solve step-by-step only.",
@@ -20,19 +42,20 @@ INTENT_TEMPLATES = {
     "exam": "Prepare concise exam-focused notes and important questions."
 }
 
+# ----------------------
+# HELPER FUNCTIONS
+# ----------------------
 def now_ts():
     return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
-# ----------------------------
-# Chat Function
-# ----------------------------
-def generate_reply(user_msg, history=None):
+def generate_reply(user_msg: str, history: Optional[List[Dict[str, Any]]]):
     if history is None:
         history = []
 
     if not user_msg.strip():
         return history
 
+    # Detect intent
     intent = None
     low = user_msg.lower()
     for key in INTENT_TEMPLATES:
@@ -42,8 +65,12 @@ def generate_reply(user_msg, history=None):
             break
 
     system_prefix = INTENT_TEMPLATES.get(intent, None)
-    prompt = f"{system_prefix}\nUser: {user_msg}" if system_prefix else f"User: {user_msg}"
+    if system_prefix:
+        prompt = f"{system_prefix}\nUser: {user_msg}"
+    else:
+        prompt = f"User: {user_msg}"
 
+    # Generate reply using LocalChatbot
     bot_reply = bot.ask(prompt)
     ts = now_ts()
     bot_reply_ts = f"{bot_reply}\n\n🕒 {ts}"
@@ -58,24 +85,82 @@ def generate_reply(user_msg, history=None):
 
     return history
 
-# ----------------------------
-# Gradio UI
-# ----------------------------
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("## ⚡ Smart Learning Assistant - Tayyab")
+# ----------------------
+# EXPORT TXT/PDF
+# ----------------------
+def export_chat_files(history: List[Dict[str, Any]]) -> Dict[str, Optional[str]]:
+    tmpdir = tempfile.gettempdir()
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    txt_path = os.path.join(tmpdir, f"chat_history_{timestamp}.txt")
+
+    with open(txt_path, "w", encoding="utf-8") as f:
+        for msg in history:
+            content = msg.get("content", "")
+            lines = content.splitlines()
+            lines = [l.replace("USER:", "").replace("ASSISTANT:", "").strip() for l in lines]
+            f.write("\n".join(lines).strip() + "\n")
+            f.write("-" * 60 + "\n")
+
+    pdf_path = None
+    try:
+        from reportlab.lib.pagesizes import A4
+        from reportlab.pdfgen import canvas
+        pdf_path = os.path.join(tmpdir, f"chat_history_{timestamp}.pdf")
+        c = canvas.Canvas(pdf_path, pagesize=A4)
+        width, height = A4
+        margin = 40
+        textobject = c.beginText(margin, height - margin)
+        textobject.setFont("Helvetica", 10)
+        with open(txt_path, "r", encoding="utf-8") as fh:
+            for line in fh:
+                for wrapped in textwrap.wrap(line.rstrip(), 100):
+                    textobject.textLine(wrapped)
+        c.drawText(textobject)
+        c.showPage()
+        c.save()
+    except:
+        pdf_path = None
+
+    return {"txt": txt_path, "pdf": pdf_path}
+
+# ----------------------
+# UI
+# ----------------------
+with gr.Blocks(title="Tayyab — Chatbot (API)") as demo:
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=220):
+            gr.Markdown("### ⚡ Tools & Export")
+            new_chat_btn = gr.Button("➕ New Chat")
+            export_btn = gr.Button("📥 Export TXT/PDF")
+
+        with gr.Column(scale=3):
+            gr.Markdown("<h3>Smart Learning Assistant - Tayyab</h3>")
+            chatbot = gr.Chatbot(height=480, type="messages")
+            msg = gr.Textbox(placeholder="Type a message", show_label=False, lines=3)
+            send_btn = gr.Button("Send")
 
-    chatbot = gr.Chatbot(height=480)
-    msg = gr.Textbox(placeholder="Type your message...", lines=3)
-    send_btn = gr.Button("Send")
-    new_chat_btn = gr.Button("➕ New Chat")
+    file_txt = gr.File(visible=False)
+    file_pdf = gr.File(visible=False)
 
+    # Chat actions
     send_btn.click(generate_reply, inputs=[msg, chatbot], outputs=[chatbot])
     msg.submit(generate_reply, inputs=[msg, chatbot], outputs=[chatbot])
 
     def new_chat():
         memory.clear()
         return []
+
     new_chat_btn.click(new_chat, outputs=[chatbot])
 
+    def export_handler(history):
+        files = export_chat_files(history or [])
+        return (
+            gr.update(value=files.get("txt"), visible=True),
+            gr.update(value=files.get("pdf"), visible=bool(files.get("pdf")))
+        )
+
+    export_btn.click(export_handler, inputs=[chatbot], outputs=[file_txt, file_pdf])
+
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -1,9 +1,10 @@
 gradio==3.42
-torch
-transformers
-numpy
-pillow
-pdfplumber
-python-dotenv
-requests
-reportlab
+transformers==4.43.0
+torch==2.2.0
+numpy==1.25.2
+reportlab==3.5.67
+python-dotenv==1.0.0
+pillow==10.0.0
+pdfplumber==0.9.0
+opencv-python==4.8.1.78
+requests==2.31.0

src/chatbot.py

@@ -1,31 +1,26 @@
-# src/chatbot.py
 from typing import Dict, Any, Optional
 from src.intent import detect_intent
 from src.templates import TEMPLATES
-import time
 
-# Default generation args (tweakable)
 DEFAULT_GEN_ARGS = {
     "max_tokens": 300,
     "temperature": 0.7,
-    "top_p": 0.95,
-    # "stop": ["User:", "Assistant:"]  # enable if your llama binding supports stop tokens
+    "top_p": 0.95
 }
 
 MSG_SEPARATOR = "\n"
 
 class LocalChatbot:
-    def __init__(self, llm, memory, default_template: Optional[str] = "general"):
+    def __init__(self, llm, memory, tokenizer=None, default_template: Optional[str] = "general"):
         self.llm = llm
         self.memory = memory
+        self.tokenizer = tokenizer
         self.default_template = default_template
 
     def _build_system_prompt(self, intent: str) -> str:
-        # get template for intent
         return TEMPLATES.get(intent, TEMPLATES.get(self.default_template, TEMPLATES["general"]))
 
     def _build_prompt(self, user_message: str, intent: str, max_pairs: int = 12) -> str:
-        # Trim memory to recent pairs before building prompt
         try:
             self.memory.trim_to_recent_pairs(max_pairs)
         except Exception:
@@ -40,50 +35,36 @@ class LocalChatbot:
             f"User: {user_message}",
             "Assistant:"
         ]
-        # join non-empty parts
-        return MSG_SEPARATOR.join([p for p in parts if p is not None and p != ""])
+        return MSG_SEPARATOR.join([p for p in parts if p])
 
     def ask(self, user_message: str, gen_args: Optional[Dict[str, Any]] = None) -> str:
-        if not user_message or not user_message.strip():
+        if not user_message.strip():
             return "Please enter a message."
 
-        # Detect intent
         intent = detect_intent(user_message)
+        prompt = self._build_prompt(user_message, intent)
 
-        # Build prompt
-        prompt = self._build_prompt(user_message, intent, max_pairs=12)
-
-        # Merge generation args
         gen = DEFAULT_GEN_ARGS.copy()
         if gen_args:
             gen.update(gen_args)
 
-        # Attempt to call the LLM (defensive: handle different API variants)
-        try:
-            output = self.llm(prompt, **gen)
-        except TypeError:
-            # fallback mapping: map max_tokens -> max_new_tokens
-            alt_gen = gen.copy()
-            if "max_tokens" in alt_gen:
-                alt_gen["max_new_tokens"] = alt_gen.pop("max_tokens")
-            output = self.llm(prompt, **alt_gen)
-
-        # Parse the output robustly
-        bot_reply = ""
         try:
-            if isinstance(output, dict) and "choices" in output:
-                bot_reply = output["choices"][0].get("text", "").strip()
-            elif isinstance(output, str):
-                bot_reply = output.strip()
+            if self.tokenizer:
+                # Transformers-style generation
+                inputs = self.tokenizer(prompt, return_tensors="pt")
+                outputs = self.llm.generate(**inputs, max_new_tokens=gen.get("max_tokens", 300))
+                bot_reply = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
             else:
-                bot_reply = str(output).strip()
+                # Fallback: callable LLM
+                bot_reply = self.llm(prompt, **gen)
+                if isinstance(bot_reply, dict) and "choices" in bot_reply:
+                    bot_reply = bot_reply["choices"][0].get("text", "").strip()
         except Exception:
-            bot_reply = ""
+            bot_reply = "Sorry — I couldn't generate a response. Please try again."
 
         if not bot_reply:
             bot_reply = "Sorry — I couldn't generate a response. Please try again."
 
-        # Add to memory
         try:
             self.memory.add(user_message, bot_reply)
         except Exception:

src/model_loader.py

@@ -1,17 +1,35 @@
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
+import torch
 
-def load_local_model(model_path: str, device: int = -1):
+def load_local_model(model_path: str, device: int = -1, token: str = None):
     """
-    Loads a Hugging Face model on CPU/GPU.
-    device=-1 → CPU, device=0 → first GPU
+    Load a Hugging Face model (CPU by default) with optional token for private repos.
+
+    Args:
+        model_path (str): Hugging Face repo ID or local path.
+        device (int): -1 for CPU, >=0 for GPU index.
+        token (str): HF token for private models.
+
+    Returns:
+        model, tokenizer
     """
-    tokenizer = AutoTokenizer.from_pretrained(model_path)
-    model = AutoModelForCausalLM.from_pretrained(model_path)
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_path, use_auth_token=token)
+    except Exception as e:
+        raise RuntimeError(f"Failed to load tokenizer: {e}")
+
+    try:
+        config = AutoConfig.from_pretrained(model_path, use_auth_token=token)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_path, config=config, use_auth_token=token
+        )
+
+        # Device mapping
+        if device >= 0 and torch.cuda.is_available():
+            model.to(f"cuda:{device}")
+        else:
+            model.to("cpu")
+    except Exception as e:
+        raise RuntimeError(f"Failed to load model: {e}")
 
-    generator = pipeline(
-        "text-generation",
-        model=model,
-        tokenizer=tokenizer,
-        device=device  # -1=CPU
-    )
-    return generator
+    return model, tokenizer