Update app.py

app.py

@@ -1,15 +1,24 @@
 # app.py
 """
-Jajabor – SEBA Assamese Class 10 Tutor (Free-tier CPU version using pypdf2)
+Jajabor – SEBA Assamese Class 10 Tutor (Free-tier CPU-ready)
+- PDF reading: PyPDF2
+- CPU LLM: google/flan-t5-small (transformers pipeline)
+- Embeddings: sentence-transformers/all-MiniLM-L6-v2
+- FAISS for retrieval
+- OCR via pytesseract
+- SymPy for math solving
+- Gradio UI (gr.Image uses type="filepath")
+Notes:
+- requirements.txt must include: PyPDF2 (capitalized), gradio==4.44.0, gradio-client==0.4.3, sentence-transformers, faiss-cpu, transformers, torch, pytesseract, pillow, sympy
 """
 
 import os
 import io
 import sqlite3
-from datetime import datetime
 import traceback
+from datetime import datetime
 
-from pypdf2 import PdfReader   # <-- FIXED
+from PyPDF2 import PdfReader
 import numpy as np
 from PIL import Image
 import gradio as gr
@@ -20,16 +29,15 @@ import sympy as sp
 
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
 
-# ----------------- CONFIG -----------------
-APP_NAME = "Jajabor – SEBA Assamese Class 10 Tutor (Free, pypdf2)"
+# -------------------- CONFIG --------------------
+APP_NAME = "Jajabor – SEBA Assamese Class 10 Tutor (Free CPU)"
 
 BASE_DIR = os.path.abspath(os.path.dirname(__file__))
 PDF_DIR = os.path.join(BASE_DIR, "pdfs", "class10")
 DB_PATH = os.path.join(BASE_DIR, "jajabor_users.db")
 
 EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-USE_HF_INFERENCE = False
-
+USE_HF_INFERENCE = False  # Free plan: use local small model
 LLM_LOCAL_NAME = "google/flan-t5-small"
 LLM_MAX_TOKENS = 128
 
@@ -37,19 +45,22 @@ CHUNK_SIZE = 600
 CHUNK_OVERLAP = 120
 TOP_K = 5
 
-# ----------------- DB -----------------
+# -------------------- DATABASE --------------------
 def init_db(path=DB_PATH):
     os.makedirs(os.path.dirname(path), exist_ok=True)
     conn = sqlite3.connect(path)
     cur = conn.cursor()
-    cur.execute("""
+    cur.execute(
+        """
         CREATE TABLE IF NOT EXISTS users (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             username TEXT UNIQUE,
             created_at TEXT
         )
-    """)
-    cur.execute("""
+        """
+    )
+    cur.execute(
+        """
         CREATE TABLE IF NOT EXISTS interactions (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             user_id INTEGER,
@@ -59,291 +70,472 @@ def init_db(path=DB_PATH):
             is_math INTEGER,
             FOREIGN KEY(user_id) REFERENCES users(id)
         )
-    """)
+        """
+    )
     conn.commit()
     conn.close()
 
-init_db()
-
-def get_or_create_user(username):
+def get_or_create_user(username: str):
+    username = username.strip()
+    if not username:
+        return None
     conn = sqlite3.connect(DB_PATH)
     cur = conn.cursor()
     cur.execute("SELECT id FROM users WHERE username=?", (username,))
     row = cur.fetchone()
     if row:
-        uid = row[0]
+        user_id = row[0]
     else:
         cur.execute(
             "INSERT INTO users (username, created_at) VALUES (?, ?)",
-            (username, datetime.utcnow().isoformat())
+            (username, datetime.utcnow().isoformat()),
         )
         conn.commit()
-        uid = cur.lastrowid
+        user_id = cur.lastrowid
     conn.close()
-    return uid
+    return user_id
 
-def log_interaction(uid, q, a, is_math):
+def log_interaction(user_id, query, answer, is_math: bool):
     conn = sqlite3.connect(DB_PATH)
     cur = conn.cursor()
-    cur.execute("""
+    cur.execute(
+        """
         INSERT INTO interactions (user_id, timestamp, query, answer, is_math)
         VALUES (?, ?, ?, ?, ?)
-    """, (uid, datetime.utcnow().isoformat(), q, a, 1 if is_math else 0))
+        """,
+        (user_id, datetime.utcnow().isoformat(), query, answer, 1 if is_math else 0),
+    )
     conn.commit()
     conn.close()
 
-def get_stats(uid):
+def get_user_stats(user_id):
     conn = sqlite3.connect(DB_PATH)
     cur = conn.cursor()
-    cur.execute("SELECT COUNT(*), SUM(is_math) FROM interactions WHERE user_id=?", (uid,))
+    cur.execute(
+        "SELECT COUNT(*), SUM(is_math) FROM interactions WHERE user_id=?", (user_id,)
+    )
     row = cur.fetchone()
     conn.close()
-    return row[0] or 0, row[1] or 0
+    total = row[0] or 0
+    math_count = row[1] or 0
+    return total, math_count
+
+init_db()
 
-# ----------------- PDF LOADING (pypdf2) -----------------
-def extract_text_from_pdf(pdf_path):
-    text = []
+# -------------------- PDF reading (PyPDF2) --------------------
+def extract_text_from_pdf(pdf_path: str) -> str:
+    text_pages = []
     try:
         reader = PdfReader(pdf_path)
         for page in reader.pages:
             try:
-                t = page.extract_text() or ""
-                text.append(t)
-            except:
+                txt = page.extract_text() or ""
+                text_pages.append(txt)
+            except Exception:
                 continue
     except Exception as e:
         print("PDF read error:", e)
-    return "\n".join(text)
+    return "\n".join(text_pages)
 
-def load_all_pdfs(pdf_dir):
+def load_all_pdfs(pdf_dir: str):
     texts = []
     metas = []
     if not os.path.isdir(pdf_dir):
-        print("PDF folder missing", pdf_dir)
+        print("PDF_DIR not found:", pdf_dir)
         return texts, metas
-
-    for fn in sorted(os.listdir(pdf_dir)):
-        if fn.lower().endswith(".pdf"):
-            p = os.path.join(pdf_dir, fn)
-            print("Reading:", p)
-            t = extract_text_from_pdf(p)
-            texts.append(t)
-            metas.append({"source": fn})
+    for fname in sorted(os.listdir(pdf_dir)):
+        if fname.lower().endswith(".pdf"):
+            path = os.path.join(pdf_dir, fname)
+            print("Reading:", path)
+            text = extract_text_from_pdf(path)
+            texts.append(text)
+            metas.append({"source": fname})
     return texts, metas
 
-def split_text(txt, size, overlap):
-    if not txt:
+def split_text(text: str, chunk_size=CHUNK_SIZE, overlap=CHUNK_OVERLAP):
+    if not text:
         return []
-    out = []
-    step = size - overlap
-    i = 0
-    while i < len(txt):
-        ch = txt[i:i+size]
-        if ch.strip():
-            out.append(ch)
-        i += step
-    return out
-
-# ----------------- Embeddings -----------------
-print("Loading embeddings...")
-embedder = SentenceTransformer(EMBEDDING_MODEL_NAME)
-
-texts, metas = load_all_pdfs(PDF_DIR)
-
-chunks = []
-chunk_meta = []
-for t, m in zip(texts, metas):
-    c = split_text(t, CHUNK_SIZE, CHUNK_OVERLAP)
-    chunks.extend(c)
-    chunk_meta.extend([m] * len(c))
-
-print("Total chunks:", len(chunks))
-
+    chunks = []
+    step = max(chunk_size - overlap, 1)
+    start = 0
+    L = len(text)
+    while start < L:
+        end = min(start + chunk_size, L)
+        chunk = text[start:end]
+        if chunk.strip():
+            chunks.append(chunk)
+        start += step
+    return chunks
+
+# -------------------- Embeddings + FAISS --------------------
+print("Loading embedding model:", EMBEDDING_MODEL_NAME)
+embedding_model = SentenceTransformer(EMBEDDING_MODEL_NAME)
+
+print("Loading PDFs from", PDF_DIR)
+all_texts, all_metas = load_all_pdfs(PDF_DIR)
+print("Number of PDFs:", len(all_texts))
+
+corpus_chunks = []
+corpus_metas = []
+for text, meta in zip(all_texts, all_metas):
+    chs = split_text(text, CHUNK_SIZE, CHUNK_OVERLAP)
+    corpus_chunks.extend(chs)
+    corpus_metas.extend([meta] * len(chs))
+
+print("Total chunks:", len(corpus_chunks))
 index = None
-if chunks:
-    print("Encoding...")
+if len(corpus_chunks) > 0:
+    print("Encoding chunks (this may take some seconds)...")
     try:
-        emb = embedder.encode(chunks, batch_size=32, show_progress_bar=False)
-        emb = emb.astype("float32")
-        index = faiss.IndexFlatL2(emb.shape[1])
-        index.add(emb)
-        print("FAISS Ready")
+        embs = embedding_model.encode(corpus_chunks, batch_size=32, show_progress_bar=False).astype("float32")
+        dim = embs.shape[1]
+        index = faiss.IndexFlatL2(dim)
+        index.add(embs)
+        print("✅ FAISS index ready; dim:", dim)
     except Exception as e:
-        print("FAISS error:", e)
+        print("Failed to encode/add to index:", e)
+        index = None
+else:
+    print("No corpus chunks found: upload PDFs to ./pdfs/class10")
 
-def rag_search(q):
+def rag_search(query: str, k: int = TOP_K):
     if index is None:
         return []
     try:
-        qv = embedder.encode([q]).astype("float32")
-        D, I = index.search(qv, TOP_K)
-        res = []
-        for d, idx in zip(D[0], I[0]):
-            if idx != -1:
-                res.append({"score": float(d), "text": chunks[idx], "meta": chunk_meta[idx]})
-        return res
-    except:
+        q_vec = embedding_model.encode([query]).astype("float32")
+        D, I = index.search(q_vec, k)
+        results = []
+        for dist, idx in zip(D[0], I[0]):
+            if idx == -1:
+                continue
+            results.append(
+                {
+                    "score": float(dist),
+                    "text": corpus_chunks[idx],
+                    "meta": corpus_metas[idx],
+                }
+            )
+        return results
+    except Exception as e:
+        print("RAG search error:", e)
         return []
 
-# ----------------- Local LLM -----------------
-print("Loading CPU LLM:", LLM_LOCAL_NAME)
+# -------------------- Local CPU LLM (flan-t5-small) --------------------
+print("Loading local CPU LLM:", LLM_LOCAL_NAME)
+llm_pipe = None
 try:
-    tok = AutoTokenizer.from_pretrained(LLM_LOCAL_NAME)
-    mdl = AutoModelForSeq2SeqLM.from_pretrained(LLM_LOCAL_NAME)
-    llm = pipeline("text2text-generation", model=mdl, tokenizer=tok)
-except:
-    llm = None
+    tokenizer = AutoTokenizer.from_pretrained(LLM_LOCAL_NAME)
+    model = AutoModelForSeq2SeqLM.from_pretrained(LLM_LOCAL_NAME)
+    llm_pipe = pipeline("text2text-generation", model=model, tokenizer=tokenizer, device_map=None)
+    print("Local LLM loaded.")
+except Exception as e:
+    print("Failed to load local LLM (will return notice):", e)
+    llm_pipe = None
 
 SYSTEM_PROMPT = """
-You are Jajabor, a SEBA Assamese tutor.
-Answer in Assamese. Use textbook context.
+You are "Jajabor", an expert SEBA Assamese tutor for Class 10.
+Always prefer to answer in Assamese. If the student clearly asks for English, you may reply in English.
+
+Rules:
+- Use ONLY the given textbook context.
+- If you are not sure, say: "এই প্ৰশ্নটো পাঠ্যপুথিৰ অংশত স্পষ্টকৈ নাই, সেয়েহে মই নিশ্চিত নহয়।"
+- বোঝাপৰা সহজ ভাষাত ব্যাখ্যা কৰা, উদাহৰণ দিয়ক।
+- If it is a maths question, explain step-by-step clearly.
 """
 
-def build_prompt(ctx, q, hist):
-    C = ""
-    for i, b in enumerate(ctx, 1):
-        C += f"\n[Context {i} – {b['meta'].get('source')}]\n{b['text']}\n"
-    H = ""
-    for r, m in hist:
-        H += f"{r}: {m}\n"
-    return f"""{SYSTEM_PROMPT}
-
-আগৰ কথোপকথন:
-{H}
+def build_rag_prompt(context_blocks, question, chat_history):
+    ctx = ""
+    for i, block in enumerate(context_blocks, start=1):
+        src = block["meta"].get("source", "textbook")
+        ctx += f"\n[Context {i} – {src}]\n{block['text']}\n"
 
-প্ৰশ্ন:
-{q}
+    hist = ""
+    for role, msg in chat_history:
+        hist += f"{role}: {msg}\n"
 
-সম্পৰ্কিত পাঠ্য:
-{C}
+    prompt = f"""{SYSTEM_PROMPT}
 
-সহজ ভাষাত উত্তৰ দিয়া।
-"""
+পূৰ্বৰ বাৰ্তাসমূহ:
+{hist}
 
-def answer_with_rag(q, hist):
-    ctx = rag_search(q)
-    prompt = build_prompt(ctx, q, hist)
+সদস্যৰ প্ৰশ্ন:
+{question}
 
-    if llm is None:
-        return "LLM not available."
+সম্পৰ্কিত পাঠ্যপুথিৰ অংশ:
+{ctx}
 
-    try:
-        out = llm(prompt, max_new_tokens=LLM_MAX_TOKENS, do_sample=False)
-        return out[0]["generated_text"]
-    except Exception as e:
-        return f"LLM error: {e}"
+এতিয়া একেদম সহায়ক আৰু বুজিবলৈ সহজ উত্তৰ দিয়া।
+"""
+    return prompt
 
-# ----------------- OCR + Math -----------------
-def ocr_image(img):
+def llm_answer_with_rag(question: str, chat_history):
+    retrieved = rag_search(question, TOP_K)
+    prompt = build_rag_prompt(retrieved, question, chat_history)
+    if USE_HF_INFERENCE:
+        return "HF inference disabled in free plan."
+    else:
+        if llm_pipe is None:
+            return "Local LLM not loaded. Ensure model weights are available on first run."
+        try:
+            out = llm_pipe(prompt, max_new_tokens=LLM_MAX_TOKENS, do_sample=False)
+            if isinstance(out, list) and len(out) > 0 and "generated_text" in out[0]:
+                return out[0]["generated_text"]
+            if isinstance(out, list) and len(out) > 0 and isinstance(out[0], str):
+                return out[0]
+            if isinstance(out, dict) and "generated_text" in out:
+                return out["generated_text"]
+            return str(out)
+        except Exception as e:
+            traceback.print_exc()
+            return f"LLM generation failed: {e}"
+
+# -------------------- OCR + Math helpers --------------------
+def ocr_from_image(img: Image.Image):
+    if img is None:
+        return ""
     try:
         img = img.convert("RGB")
-        return pytesseract.image_to_string(img, lang="asm+eng").strip()
-    except:
-        return ""
-
-def is_math_query(q):
-    if any(c in q for c in "0123456789+-*/=^()%"):
+    except Exception:
+        pass
+    try:
+        text = pytesseract.image_to_string(img, lang="asm+eng")
+    except Exception:
+        try:
+            text = pytesseract.image_to_string(img)
+        except Exception:
+            text = ""
+    return text.strip()
+
+def is_likely_math(text: str) -> bool:
+    if not text:
+        return False
+    math_chars = set("0123456789+-*/=^()%")
+    if any(ch in text for ch in math_chars):
         return True
-    return any(k in q.lower() for k in ["গণিত", "math", "সমীকৰণ"])
+    kws = ["গণিত", "সমীকৰণ", "উদাহৰণ", "প্ৰশ্ন", "বীজগণিত", "solve", "equation"]
+    return any(k in text for k in kws)
 
-def math_solve(expr):
+def solve_math_expression(expr: str):
     try:
         expr = expr.replace("^", "**")
         if "=" in expr:
-            L, R = expr.split("=", 1)
-            eq = sp.Eq(sp.sympify(L), sp.sympify(R))
+            left, right = expr.split("=", 1)
+            left_s = sp.sympify(left)
+            right_s = sp.sympify(right)
+            eq = sp.Eq(left_s, right_s)
             sol = sp.solve(eq)
-            return f"সমাধান: {sol}"
+            steps = [
+                "প্ৰথমে সমীকৰণ লওঁ:",
+                f"{sp.pretty(eq)}",
+                "Sympy ৰ সহায়ত সমাধান পোৱা যায়:",
+                str(sol),
+            ]
+            explanation = "ধাপ-ধাপে সমাধান (সংক্ষেপে):\n" + "\n".join(f"- {s}" for s in steps)
+            explanation += f"\n\nসেয়ে সমাধান: {sol}"
         else:
-            s = sp.simplify(sp.sympify(expr))
-            return f"উত্তৰ: {s}"
-    except:
-        return "সমীকৰণ বুজিবলৈ অসুবিধা।"
-
-# ----------------- CHAT -----------------
-def login(username, state):
-    username = (username or "").strip()
-    if not username:
-        return state, "⚠️ লগিনৰ নাম দিয়ক।"
-    uid = get_or_create_user(username)
-    state = {"username": username, "user_id": uid}
-    t, m = get_stats(uid)
-    return state, f"ব্যৱহাৰকাৰী: {username}\nমোট প্ৰশ্ন: {t}\nগণিত: {m}"
-
-def chat_logic(username, text, img, aud, hist, state):
-    if hist is None:
-        hist = []
+            expr_s = sp.sympify(expr)
+            simp = sp.simplify(expr_s)
+            explanation = (
+                "প্ৰদত্ত গণিতীয় অভিব্যক্তি:\n"
+                f"{expr}\n\nসরলীকৰণ কৰাৰ পিছত পোৱা যায়:\n{simp}"
+            )
+        return explanation
+    except Exception:
+        return (
+            "মই সঠিকভাৱে গণিতীয় অভিব্যক্তি চিনাক্ত কৰিব নোৱাৰিলোঁ। "
+            "দয়া কৰি সমীকৰণটো অলপ বেছি স্পষ্ট কৰি লিখক: উদাহৰণ – 2*x + 3 = 7"
+        )
 
-    if not state or "user_id" not in state:
-        return hist + [[text or "", "⚠️ লগিন কৰক।"]], state, ""
+def speech_to_text(audio):
+    return ""
 
-    q_parts = []
-    if text:
-        q_parts.append(text)
+def text_to_speech(text: str):
+    # stub: return empty string to avoid None in Gradio outputs
+    return ""
 
-    if img:
+# -------------------- Chat logic --------------------
+def login_user(username, user_state):
+    username = (username or "").strip()
+    if not username:
+        return user_state, "⚠️ অনুগ্ৰহ কৰি প্ৰথমে লগিনৰ বাবে এটা নাম লিখক।"
+    user_id = get_or_create_user(username)
+    user_state = {"username": username, "user_id": user_id}
+    total, math_count = get_user_stats(user_id)
+    stats = (
+        f"👤 ব্যৱহাৰকাৰী: **{username}**\n\n"
+        f"📊 মোট প্ৰশ্ন: **{total}**\n"
+        f"🧮 গণিত প্ৰশ্ন: **{math_count}**"
+    )
+    return user_state, stats
+
+def chat_logic(
+    username,
+    text_input,
+    image_input,
+    audio_input,
+    chat_history,
+    user_state,
+):
+    if chat_history is None:
+        chat_history = []
+
+    if not user_state or not user_state.get("user_id"):
+        sys_msg = "⚠️ প্ৰথমে ওপৰত আপোনাৰ নাম লিখি **Login / লগিন** টিপক।"
+        chat_history = chat_history + [[text_input or "", sys_msg]]
+        return chat_history, user_state, ""
+
+    user_id = user_state["user_id"]
+    final_query_parts = []
+
+    voice_text = speech_to_text(audio_input)
+    if voice_text:
+        final_query_parts.append(voice_text)
+
+    ocr_text = ""
+    if image_input is not None and image_input != "":
+        img = None
         try:
-            im = Image.open(img)
-            o = ocr_image(im)
-            if o:
-                q_parts.append(o)
-        except:
-            pass
+            if isinstance(image_input, str):
+                img = Image.open(image_input)
+            else:
+                read_method = getattr(image_input, "read", None)
+                if callable(read_method):
+                    raw = image_input.read()
+                    img = Image.open(io.BytesIO(raw))
+                if img is None and isinstance(image_input, Image.Image):
+                    img = image_input
+        except Exception:
+            img = None
+
+        if img is not None:
+            try:
+                ocr_text = ocr_from_image(img)
+                if ocr_text:
+                    final_query_parts.append(ocr_text)
+            except Exception:
+                pass
+
+    if text_input:
+        final_query_parts.append(text_input)
 
-    if not q_parts:
-        return hist + [["", "⚠️ প্ৰশ্ন লিখক।"]], state, ""
+    if not final_query_parts:
+        sys_msg = "⚠️ অনুগ্ৰহ কৰি প্ৰশ্ন লিখক, কিম্বা ছবি আপলোড কৰক।"
+        chat_history = chat_history + [["", sys_msg]]
+        return chat_history, user_state, ""
 
-    full_q = "\n".join(q_parts)
+    full_query = "\n".join(final_query_parts)
 
     conv = []
-    for u, a in hist:
+    for u, b in chat_history:
         if u:
             conv.append(("Student", u))
-        if a:
-            conv.append(("Tutor", a))
-
-    if is_math_query(full_q):
-        sol = math_solve(full_q)
-        final_q = f"{full_q}\n\nMath result:\n{sol}\n\nExplain in simple Assamese."
+        if b:
+            conv.append(("Tutor", b))
+
+    is_math = is_likely_math(full_query)
+
+    if is_math:
+        math_answer = solve_math_expression(full_query)
+        combined_question = (
+            full_query
+            + "\n\nগণিত প্ৰোগ্ৰামে এই ফলাফল দিছে:\n"
+            + math_answer
+            + "\n\nঅনুগ্ৰহ কৰি শ্রেণী ১০ ৰ শিক্ষাৰ্থীৰ বাবে সহজ ভাষাত ব্যাখ্যা কৰক।"
+        )
+        final_answer = llm_answer_with_rag(combined_question, conv)
     else:
-        final_q = full_q
+        final_answer = llm_answer_with_rag(full_query, conv)
 
-    ans = answer_with_rag(final_q, conv)
-    log_interaction(state["user_id"], full_q, ans, is_math_query(full_q))
+    if final_answer is None:
+        final_answer = "মাফ কৰক — মই ইয়াৰ উত্তর দিব পৰা নাই।"
 
-    return hist + [[full_q, ans]], state, ""
+    log_interaction(user_id, full_query, final_answer, is_math)
+    audio_out = text_to_speech(final_answer) or ""
+    display_question = text_input or voice_text or ocr_text or "(empty)"
+    chat_history = chat_history + [[display_question, final_answer]]
 
-# ----------------- UI -----------------
-with gr.Blocks(title=APP_NAME) as demo:
-    gr.Markdown("# 🧭 Jajabor – SEBA Assamese Class 10 Tutor (Free, pypdf2)")
+    return chat_history, user_state, audio_out
 
-    state = gr.State({})
+# -------------------- Gradio UI --------------------
+with gr.Blocks(title=APP_NAME, css=None) as demo:
+    gr.Markdown(
+        """
+        # 🧭 জাজাবৰ – SEBA অসমীয়া ক্লাছ ১০ AI Tutor (Free CPU)
+
+        - Upload your SEBA Class 10 PDFs to `pdfs/class10` in this repo (or when running locally, ensure folder exists)
+        - Text + Image (OCR) input
+        - Math step-by-step solutions
+        - User login + progress
+        """
+    )
+
+    user_state = gr.State({})
 
     with gr.Row():
         with gr.Column(scale=1):
-            user = gr.Textbox(label="নাম")
-            login_btn = gr.Button("Login")
-            stats = gr.Markdown()
+            gr.Markdown("### 👤 লগিন")
+            username_inp = gr.Textbox(
+                label="নাম / ইউজাৰ আইডি",
+                placeholder="উদাহৰণ: abu10, student01 ..."
+            )
+            login_btn = gr.Button("✅ Login / লগিন")
+            stats_md = gr.Markdown("এতিয়ালৈকে লগিন হোৱা নাই।", elem_classes="stats-box")
+
+            gr.Markdown(
+                """
+                ### 💡 টিপছ
+                - "ক্লাছ ১০ গণিত: উদাহৰণ ৩.১ প্ৰশ্ন ২" – এই ধৰণৰ প্ৰশ্ন ভাল
+                - ফটো আপলোড কৰিলে টেক্স্টটো OCR কৰি পঢ়িব চেষ্টা কৰা হয়
+                - সম্ভৱ হলে প্ৰশ্নটো অসমীয়াত সোধক 🙂
+                """
+            )
+
         with gr.Column(scale=3):
-            chat = gr.Chatbot(height=500)
-            txt = gr.Textbox(label="প্ৰশ্ন", lines=2)
-            img = gr.Image(type="filepath", label="📷 ছবি")
-            aud = gr.Audio(type="filepath", label="🎙️")
-            ask = gr.Button("সোধক")
-
-    login_btn.click(login, inputs=[user, state], outputs=[state, stats])
-
-    ask.click(
-        chat_logic,
-        inputs=[user, txt, img, aud, chat, state],
-        outputs=[chat, state, None]
+            chat = gr.Chatbot(label="জাজাবৰ সৈতে কথোপকথন", height=500)
+            text_inp = gr.Textbox(
+                label="আপোনাৰ প্ৰশ্ন লিখক",
+                placeholder='উদাহৰণ: "ক্লাছ ১০ অসমীয়া: অনুচ্ছেদ পাঠ ১ ৰ মূল বিষয় কি?"',
+                lines=2,
+            )
+
+            with gr.Row():
+                image_inp = gr.Image(label="📷 প্ৰশ্নৰ ছবি (Optional)", type="filepath")
+                audio_inp = gr.Audio(label="🎙️ কণ্ঠস্বৰ প্ৰশ্ন (Stub — not used now)", type="numpy")
+
+            with gr.Row():
+                ask_btn = gr.Button("🤖 জাজাবৰক সোধক")
+                audio_out = gr.Audio(
+                    label="🔊 উত্তৰৰ অডিঅ’ (TTS – future upgrade)",
+                    interactive=False,
+                    type="filepath"
+                )
+
+    login_btn.click(
+        login_user,
+        inputs=[username_inp, user_state],
+        outputs=[user_state, stats_md],
+    )
+
+    def wrapped_chat(text, image, audio, history, user_state_inner, username_inner):
+        if user_state_inner is None:
+            user_state_inner = {}
+        if username_inner and not user_state_inner.get("username"):
+            user_state_inner["username"] = username_inner
+        return chat_logic(username_inner, text, image, audio, history, user_state_inner)
+
+    ask_btn.click(
+        wrapped_chat,
+        inputs=[text_inp, image_inp, audio_inp, chat, user_state, username_inp],
+        outputs=[chat, user_state, audio_out],
     )
 
-    txt.submit(
-        chat_logic,
-        inputs=[user, txt, img, aud, chat, state],
-        outputs=[chat, state, None]
+    text_inp.submit(
+        wrapped_chat,
+        inputs=[text_inp, image_inp, audio_inp, chat, user_state, username_inp],
+        outputs=[chat, user_state, audio_out],
     )
 
+# -------------------- Launch --------------------
 if __name__ == "__main__":
+    # bind to 0.0.0.0 and allow share link for hosted environments where localhost may be blocked
     demo.launch(server_name="0.0.0.0", server_port=7860, share=True)