Update app.py

app.py

@@ -1,45 +1,73 @@
 """
-Jajabor – SEBA Assamese Class 10 Tutor (Free-tier CPU-ready)
-Fixed version with Gradio compatibility fixes
+Jajabor – SEBA Assamese Class 10 Tutor (Fixed for Hugging Face Spaces)
 """
 
 import os
-import io
 import sqlite3
-import traceback
 from datetime import datetime
 
-from PyPDF2 import PdfReader
-import numpy as np
-from PIL import Image
-import gradio as gr
-import faiss
-import pytesseract
-from sentence_transformers import SentenceTransformer
-import sympy as sp
+# Import with error handling
+try:
+    from PyPDF2 import PdfReader
+    PDF_AVAILABLE = True
+except ImportError:
+    PDF_AVAILABLE = False
+    print("PyPDF2 not available")
+
+try:
+    from sentence_transformers import SentenceTransformer
+    EMBEDDING_AVAILABLE = True
+except ImportError:
+    EMBEDDING_AVAILABLE = False
+    print("sentence-transformers not available")
+
+try:
+    import faiss
+    FAISS_AVAILABLE = True
+except ImportError:
+    FAISS_AVAILABLE = False
+    print("faiss not available")
 
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+try:
+    from transformers import pipeline
+    TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    TRANSFORMERS_AVAILABLE = False
+    print("transformers not available")
+
+try:
+    import gradio as gr
+    GRADIO_AVAILABLE = True
+except ImportError:
+    GRADIO_AVAILABLE = False
+    print("gradio not available")
+
+try:
+    import pytesseract
+    from PIL import Image
+    OCR_AVAILABLE = True
+except ImportError:
+    OCR_AVAILABLE = False
+    print("OCR dependencies not available")
+
+try:
+    import sympy as sp
+    SYMPY_AVAILABLE = True
+except ImportError:
+    SYMPY_AVAILABLE = False
+    print("sympy not available")
 
 # -------------------- CONFIG --------------------
-APP_NAME = "Jajabor – SEBA Assamese Class 10 Tutor (Free CPU)"
+APP_NAME = "Jajabor – SEBA Class 10 Tutor"
 
 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
-LLM_LOCAL_NAME = "google/flan-t5-small"
-LLM_MAX_TOKENS = 128
-
-CHUNK_SIZE = 400  # Reduced for better performance
-CHUNK_OVERLAP = 80
-TOP_K = 3  # Reduced for faster retrieval
-
 # -------------------- DATABASE --------------------
-def init_db(path=DB_PATH):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    conn = sqlite3.connect(path)
+def init_db():
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
     cur = conn.cursor()
     cur.execute(
         """
@@ -79,14 +107,14 @@ def get_or_create_user(username: str):
     else:
         cur.execute(
             "INSERT INTO users (username, created_at) VALUES (?, ?)",
-            (username, datetime.utcnow().isoformat()),
+            (username, datetime.now().isoformat()),
         )
         conn.commit()
         user_id = cur.lastrowid
     conn.close()
     return user_id
 
-def log_interaction(user_id, query, answer, is_math: bool):
+def log_interaction(user_id, query, answer, is_math=False):
     conn = sqlite3.connect(DB_PATH)
     cur = conn.cursor()
     cur.execute(
@@ -94,445 +122,400 @@ def log_interaction(user_id, query, answer, is_math: bool):
         INSERT INTO interactions (user_id, timestamp, query, answer, is_math)
         VALUES (?, ?, ?, ?, ?)
         """,
-        (user_id, datetime.utcnow().isoformat(), query, answer, 1 if is_math else 0),
+        (user_id, datetime.now().isoformat(), query, answer, 1 if is_math else 0),
     )
     conn.commit()
     conn.close()
 
-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=?", (user_id,)
-    )
-    row = cur.fetchone()
-    conn.close()
-    total = row[0] or 0
-    math_count = row[1] or 0
-    return total, math_count
-
-init_db()
-
-# -------------------- PDF reading --------------------
-def extract_text_from_pdf(pdf_path: str) -> str:
-    text_pages = []
-    try:
-        reader = PdfReader(pdf_path)
-        for page in reader.pages:
+# -------------------- SIMPLE TUTOR --------------------
+class SimpleTutor:
+    def __init__(self):
+        self.llm = None
+        self.embedding_model = None
+        self.index = None
+        self.corpus_chunks = []
+        self.loaded = False
+        
+        self._load_models()
+        self.load_pdfs()
+    
+    def _load_models(self):
+        """Load models with error handling"""
+        if EMBEDDING_AVAILABLE:
             try:
-                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_pages)
-
-def load_all_pdfs(pdf_dir: str):
-    texts = []
-    metas = []
-    if not os.path.isdir(pdf_dir):
-        print("PDF_DIR not found:", pdf_dir)
-        return texts, metas
-    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)
-            if text.strip():
-                texts.append(text)
-                metas.append({"source": fname})
-    return texts, metas
-
-def split_text(text: str, chunk_size=CHUNK_SIZE, overlap=CHUNK_OVERLAP):
-    if not text:
-        return []
-    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 with content:", 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 len(corpus_chunks) > 0:
-    print("Encoding chunks...")
-    try:
-        embs = embedding_model.encode(corpus_chunks, batch_size=16, 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("Failed to encode/add to index:", e)
-        index = None
-else:
-    print("No corpus chunks found: upload PDFs to ./pdfs/class10")
-
-def rag_search(query: str, k: int = TOP_K):
-    if index is None or len(corpus_chunks) == 0:
-        return []
-    try:
-        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 or idx >= len(corpus_chunks):
-                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 CPU LLM --------------------
-print("Loading local CPU LLM:", LLM_LOCAL_NAME)
-llm_pipe = None
-try:
-    tokenizer = AutoTokenizer.from_pretrained(LLM_LOCAL_NAME)
-    model = AutoModelForSeq2SeqLM.from_pretrained(LLM_LOCAL_NAME)
-    llm_pipe = pipeline(
-        "text2text-generation", 
-        model=model, 
-        tokenizer=tokenizer, 
-        device=-1,  # CPU
-        torch_dtype="auto"
-    )
-    print("✅ Local LLM loaded successfully")
-except Exception as e:
-    print("Failed to load local LLM:", e)
-    llm_pipe = None
-
-SYSTEM_PROMPT = """You are "Jajabor", an expert SEBA Assamese tutor for Class 10.
-Answer in Assamese unless the student asks for English.
-Use the textbook context provided. If unsure, say you don't know.
-Explain simply with examples."""
-
-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"[Context {i} - {src}]\n{block['text']}\n\n"
-
-    hist = ""
-    for u, a in chat_history[-3:]:  # Last 3 exchanges
-        if u:
-            hist += f"Student: {u}\n"
-        if a:
-            hist += f"Tutor: {a}\n"
-
-    prompt = f"""{SYSTEM_PROMPT}
-
-Previous conversation:
-{hist}
-
-Student's question:
-{question}
-
-Textbook content:
-{ctx}
-
-Provide a helpful, easy-to-understand answer in Assamese:"""
-    return prompt
-
-def llm_answer_with_rag(question: str, chat_history):
-    if not question.strip():
-        return "অনুগ্ৰহ কৰি এটা প্ৰশ্ন সোধক।"
+                self.embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
+                print("✅ Embedding model loaded")
+            except Exception as e:
+                print(f"❌ Could not load embedding model: {e}")
+        
+        if TRANSFORMERS_AVAILABLE:
+            try:
+                self.llm = pipeline(
+                    "text2text-generation",
+                    model="google/flan-t5-small",
+                    device=-1,  # CPU
+                    torch_dtype="auto"
+                )
+                print("✅ LLM loaded")
+            except Exception as e:
+                print(f"❌ Could not load LLM: {e}")
+        
+        self.loaded = True
     
-    retrieved = rag_search(question, TOP_K)
-    if not retrieved:
-        return "মই এই প্ৰশ্নৰ উত্তৰ দিবলৈ প্��য়োজনীয় তথ্য বিচাৰি পোৱা নাই। দয়া কৰি নিশ্চিত কৰক যে আপোনাৰ পাঠ্যপুথিৰ PDF ফাইলসমূহ সঠিকভাৱে আপলোড কৰা হৈছে।"
+    def load_pdfs(self):
+        """Simple PDF loading"""
+        if not PDF_AVAILABLE or not os.path.exists(PDF_DIR):
+            print(f"PDF directory not found: {PDF_DIR}")
+            return
+        
+        all_texts = []
+        for fname in os.listdir(PDF_DIR):
+            if fname.lower().endswith(".pdf"):
+                path = os.path.join(PDF_DIR, fname)
+                try:
+                    reader = PdfReader(path)
+                    text = ""
+                    for page in reader.pages:
+                        text += page.extract_text() or ""
+                    if text.strip():
+                        all_texts.append(text)
+                        print(f"📖 Loaded {fname}")
+                except Exception as e:
+                    print(f"Error reading {fname}: {e}")
+        
+        # Simple text splitting
+        self.corpus_chunks = []
+        for text in all_texts:
+            chunks = self._split_text(text)
+            self.corpus_chunks.extend(chunks)
+        
+        print(f"📚 Total chunks: {len(self.corpus_chunks)}")
+        
+        # Build FAISS index if we have chunks and embedding model
+        if self.corpus_chunks and self.embedding_model and FAISS_AVAILABLE:
+            try:
+                embs = self.embedding_model.encode(self.corpus_chunks, show_progress_bar=False).astype("float32")
+                dim = embs.shape[1]
+                self.index = faiss.IndexFlatL2(dim)
+                self.index.add(embs)
+                print(f"✅ FAISS index ready; dim: {dim}")
+            except Exception as e:
+                print(f"❌ FAISS index creation failed: {e}")
+    
+    def _split_text(self, text, chunk_size=400):
+        """Simple text splitting"""
+        if not text:
+            return []
+        chunks = []
+        for i in range(0, len(text), chunk_size):
+            chunk = text[i:i+chunk_size]
+            if chunk.strip():
+                chunks.append(chunk)
+        return chunks
     
-    prompt = build_rag_prompt(retrieved, question, chat_history)
+    def answer_question(self, question):
+        """Simple question answering"""
+        if not question.strip():
+            return "অনুগ্ৰহ কৰি এটা প্ৰশ্ন সোধক।"
+        
+        # Simple math detection
+        if self._is_math_question(question):
+            return self._solve_math(question)
+        
+        # Simple RAG if available
+        context = ""
+        if self.index is not None and self.corpus_chunks:
+            relevant_chunks = self._find_relevant_chunks(question)
+            if relevant_chunks:
+                context = "\n".join(relevant_chunks[:2])
+        
+        # Generate answer
+        if self.llm:
+            try:
+                if context:
+                    prompt = f"প্ৰশ্ন: {question}\n\nসংদৰ্ভ: {context}\n\nসহায়ক উত্তৰ:"
+                else:
+                    prompt = f"প্ৰশ্ন: {question}\n\nউত্তৰ:"
+                
+                response = self.llm(
+                    prompt,
+                    max_new_tokens=150,
+                    temperature=0.3,
+                    do_sample=False
+                )
+                
+                if isinstance(response, list) and len(response) > 0:
+                    if hasattr(response[0], 'get'):
+                        answer = response[0].get('generated_text', 'উত্তৰ তৈয়াৰ কৰিব পৰা নগল।')
+                    else:
+                        answer = str(response[0])
+                else:
+                    answer = str(response)
+                    
+            except Exception as e:
+                answer = f"উত্তৰ তৈয়াৰ কৰোঁতে সমস্যা: {str(e)}"
+        else:
+            # Fallback responses
+            fallback_responses = [
+                "মই আপোনাৰ প্ৰশ্নটো বুজিলোঁ। অধ্যয়নৰ বাবে শুভেচ্ছা!",
+                "এই বিষয়টো মনোযোগেৰে পঢ়িবলৈ চেষ্টা কৰক।",
+                "আপোনাৰ পাঠ্যপুথিৰ সংশ্লিষ্ট অধ্যায়টো চাওক।",
+                "এই প্ৰশ্নটোৰ বাবে আপোনাৰ শিক্ষকৰ সহায় ল'ব পাৰে।"
+            ]
+            import random
+            answer = random.choice(fallback_responses)
+        
+        return answer
     
-    if llm_pipe is None:
-        return "AI মডেল ল'ড হোৱা নাই। দয়া কৰি পুনৰ চেষ্টা কৰক।"
+    def _is_math_question(self, text):
+        """Simple math detection"""
+        math_indicators = ['+', '-', '*', '/', '=', 'x', 'y', 'গণিত', 'সমীকৰণ', 'solve', 'calculate']
+        return any(indicator in text.lower() for indicator in math_indicators)
     
-    try:
-        out = llm_pipe(
-            prompt, 
-            max_new_tokens=LLM_MAX_TOKENS, 
-            do_sample=False,
-            temperature=0.3
-        )
-        if isinstance(out, list) and len(out) > 0:
-            if hasattr(out[0], 'get') and "generated_text" in out[0]:
-                return out[0]["generated_text"]
-            elif isinstance(out[0], str):
-                return out[0]
+    def _solve_math(self, expr):
+        """Simple math solving"""
+        if not SYMPY_AVAILABLE:
+            return "গণিত সমাধানৰ বাবে sympy পেকেজ প্ৰয়োজন।"
+        
+        try:
+            # Clean the expression
+            expr = expr.strip()
+            expr = expr.replace('^', '**')
+            
+            if '=' in expr:
+                parts = expr.split('=')
+                if len(parts) == 2:
+                    left = sp.sympify(parts[0].strip())
+                    right = sp.sympify(parts[1].strip())
+                    equation = sp.Eq(left, right)
+                    solutions = sp.solve(equation)
+                    
+                    if solutions:
+                        solution_str = f"সমীকৰণ: {equation}\n\nসমাধান: x = {solutions[0]}"
+                        if len(solutions) > 1:
+                            solution_str += f"\nবা x = {solutions[1]}"
+                        return solution_str
+                    else:
+                        return "কোনো সমাধান পোৱা নগ'ল।"
             else:
-                return str(out[0])
-        return "উত্তৰ তৈয়াৰ কৰোঁতে সমস্যা হ'ল।"
-    except Exception as e:
-        print("LLM generation error:", e)
-        return f"উত্তৰ তৈয়াৰ কৰোঁতে ত্ৰুটি: {str(e)}"
-
-# -------------------- OCR + Math helpers --------------------
-def ocr_from_image(img_path: str):
-    if not img_path:
+                # Just simplify the expression
+                expr_sym = sp.sympify(expr)
+                simplified = sp.simplify(expr_sym)
+                return f"প্ৰকাশ: {expr}\n\nসৰলীকৃত: {simplified}"
+                
+        except Exception as e:
+            return f"গণিত সমাধানত সমস্যা: {str(e)}\nদয়া কৰি স্পষ্টকৈ লিখক, যেনে: 2*x + 3 = 7"
+    
+    def _find_relevant_chunks(self, question, k=3):
+        """Find relevant chunks using FAISS or keyword matching"""
+        if not self.corpus_chunks:
+            return []
+        
+        # Try FAISS first
+        if self.index is not None and self.embedding_model:
+            try:
+                q_vec = self.embedding_model.encode([question]).astype("float32")
+                D, I = self.index.search(q_vec, k)
+                results = []
+                for idx in I[0]:
+                    if 0 <= idx < len(self.corpus_chunks):
+                        results.append(self.corpus_chunks[idx])
+                return results
+            except Exception:
+                pass  # Fall back to keyword matching
+        
+        # Keyword matching fallback
+        question_words = set(question.lower().split())
+        scored_chunks = []
+        
+        for chunk in self.corpus_chunks:
+            chunk_words = set(chunk.lower().split())
+            common_words = question_words.intersection(chunk_words)
+            score = len(common_words)
+            if score > 0:
+                scored_chunks.append((score, chunk))
+        
+        # Return top k chunks
+        scored_chunks.sort(reverse=True)
+        return [chunk for _, chunk in scored_chunks[:k]]
+
+# -------------------- OCR FUNCTION --------------------
+def extract_text_from_image(image_path):
+    """Extract text from image using OCR"""
+    if not OCR_AVAILABLE or not image_path:
         return ""
+    
     try:
-        img = Image.open(img_path)
-        img = img.convert("RGB")
-        text = pytesseract.image_to_string(img, lang="eng")
+        image = Image.open(image_path)
+        text = pytesseract.image_to_string(image)
         return text.strip()
     except Exception as e:
-        print("OCR error:", e)
+        print(f"OCR error: {e}")
         return ""
 
-def is_likely_math(text: str) -> bool:
-    if not text:
-        return False
-    math_chars = set("0123456789+-*/=^()%")
-    text_chars = set(text)
-    if math_chars.intersection(text_chars):
-        return True
-    math_kws = ["গণিত", "সমীকৰণ", "উদাহৰণ", "প্ৰশ্ন", "বীজগণিত", "solve", "equation", "math", "calculate"]
-    return any(k in text.lower() for k in math_kws)
-
-def solve_math_expression(expr: str):
-    try:
-        # Clean the expression
-        expr = expr.strip()
-        expr = expr.replace('^', '**')
-        
-        if '=' in expr:
-            parts = expr.split('=')
-            if len(parts) == 2:
-                left = sp.sympify(parts[0].strip())
-                right = sp.sympify(parts[1].strip())
-                equation = sp.Eq(left, right)
-                solutions = sp.solve(equation)
-                
-                if solutions:
-                    solution_str = f"সমীকৰণ: {equation}\n\nসমাধান: x = {solutions[0]}"
-                    if len(solutions) > 1:
-                        solution_str += f"\nবা x = {solutions[1]}"
-                    return solution_str
-                else:
-                    return "কোনো সমাধান পোৱা নগ'ল।"
-        else:
-            # Just simplify the expression
-            expr_sym = sp.sympify(expr)
-            simplified = sp.simplify(expr_sym)
-            return f"প্ৰকাশ: {expr}\n\nসৰলীকৃত: {simplified}"
-            
-    except Exception as e:
-        return f"গণিত সমাধানত সমস্যা: {str(e)}\nদয়া কৰি স্পষ্টকৈ লিখক, যেনে: 2*x + 3 = 7"
-
-# -------------------- Chat logic --------------------
-def login_user(username):
-    username = (username or "").strip()
-    if not username:
-        return {}, "⚠️ অনুগ্ৰহ কৰি প্ৰথমে লগিনৰ বাবে এটা নাম লিখক।"
+# -------------------- GRADIO APP --------------------
+def main():
+    """Main function to run the app"""
     
-    user_id = get_or_create_user(username)
-    if not user_id:
-        return {}, "⚠️ লগিন কৰোঁতে সমস্যা হ'ল।"
+    # Initialize components
+    init_db()
+    tutor = SimpleTutor()
     
-    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(text_input, image_input, chat_history, user_state):
-    if chat_history is None:
-        chat_history = []
-
-    # Check if user is logged in
-    if not user_state or not user_state.get("user_id"):
-        chat_history.append([text_input or "", "⚠️ প্ৰথমে ওপৰত আপোনাৰ নাম লিখি **Login / লগিন** টিপক।"])
-        return chat_history, user_state
-
-    user_id = user_state["user_id"]
-    final_query_parts = []
-
-    # Process image OCR
-    if image_input is not None:
-        ocr_text = ocr_from_image(image_input)
-        if ocr_text:
-            final_query_parts.append(f"[ছবিৰ পাঠ] {ocr_text}")
-
-    if text_input and text_input.strip():
-        final_query_parts.append(text_input.strip())
-
-    if not final_query_parts:
-        chat_history.append(["", "⚠️ অনুগ্ৰহ কৰি প্ৰশ্ন লিখক, কিম্বা ছবি আপলোড কৰক।"])
-        return chat_history, user_state
-
-    full_query = "\n".join(final_query_parts)
-
-    is_math = is_likely_math(full_query)
-
-    if is_math:
-        math_answer = solve_math_expression(full_query)
-        # Combine math solution with request for explanation
-        combined_question = f"{full_query}\n\nগণিত সমাধান:\n{math_answer}\n\nঅনুগ্ৰহ কৰি ইয়াক সহজ ভাষাত ব্যাখ্যা কৰক:"
-        final_answer = llm_answer_with_rag(combined_question, chat_history)
-    else:
-        final_answer = llm_answer_with_rag(full_query, chat_history)
-
-    log_interaction(user_id, full_query, final_answer, is_math)
+    # Store user state in a simple way (avoiding gr.State issues)
+    user_states = {}
     
-    display_question = text_input or "[ছবিৰ প্ৰশ্ন]"
-    chat_history.append([display_question, final_answer])
-
-    return chat_history, user_state
-
-def clear_chat():
-    return [], None
-
-# -------------------- Gradio UI --------------------
-with gr.Blocks(
-    title=APP_NAME,
-    css="""
-    .stats-box { 
-        background: #f0f8ff; 
-        padding: 15px; 
-        border-radius: 8px; 
-        border: 1px solid #d1e7ff;
-        margin-bottom: 15px;
-    }
-    .login-section {
-        background: #f8f9fa;
-        padding: 15px;
-        border-radius: 8px;
-        margin-bottom: 15px;
-    }
-    """
-) as demo:
-    gr.Markdown(f"# 🧭 {APP_NAME}")
+    def get_user_state(username):
+        """Simple user state management"""
+        if not username:
+            return None
+        if username not in user_states:
+            user_id = get_or_create_user(username)
+            if user_id:
+                user_states[username] = {"username": username, "user_id": user_id}
+            else:
+                return None
+        return user_states[username]
     
-    gr.Markdown("""
-    - SEBA Class 10 PDFs upload to `pdfs/class10` folder
-    - Text + Image (OCR) input support  
-    - Math step-by-step solutions
-    - User login + progress tracking
-    """)
-
-    # Use a simpler state management approach
-    user_state = gr.State(value={})
+    def chat_function(message, image, chat_history, username):
+        """Main chat function"""
+        # Initialize chat history if None
+        if chat_history is None:
+            chat_history = []
+        
+        # Check if user is logged in
+        user_state = get_user_state(username.strip())
+        if not user_state:
+            new_history = chat_history + [[message, "⚠️ প্ৰথমে নাম লিখি লগিন কৰক।"]]
+            return new_history, ""
+        
+        # Combine text and image input
+        full_question = message.strip()
+        if image:
+            ocr_text = extract_text_from_image(image)
+            if ocr_text:
+                full_question += f"\n[ছবিৰ পাঠ: {ocr_text}]"
+        
+        if not full_question:
+            new_history = chat_history + [["", "⚠️ প্ৰশ্ন লিখক বা ছবি আপলোড কৰক।"]]
+            return new_history, ""
+        
+        # Get answer from tutor
+        answer = tutor.answer_question(full_question)
+        
+        # Log interaction
+        log_interaction(user_state["user_id"], full_question, answer)
+        
+        # Update chat
+        display_question = message if message.strip() else "[ছবিৰ প্ৰশ্ন]"
+        new_history = chat_history + [[display_question, answer]]
+        return new_history, ""
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            with gr.Group(elem_classes="login-section"):
-                gr.Markdown("### 👤 লগিন")
-                username_inp = gr.Textbox(
-                    label="নাম / ইউজাৰ আইডি",
-                    placeholder="উদাহৰণ: abu10, student01 ...",
-                    max_lines=1
-                )
-                login_btn = gr.Button("✅ Login / লগিন", variant="primary")
-                stats_md = gr.Markdown("এতিয়ালৈকে লগিন হোৱা নাই।", elem_classes="stats-box")
-
-            gr.Markdown("""
-            ### 💡 টিপছ
-            - "ক্লাছ ১০ গণিত: উদাহৰণ ৩.১ প্ৰশ্ন ২" – এই ধৰণৰ প্ৰশ্ন ভাল
-            - ফটো আপলোড কৰিলে টেক্স্টটো OCR কৰি পঢ়িব চেষ্টা কৰা হয়
-            - সম্ভৱ হলে প্ৰশ্নটো অসমীয়াত সোধক 🙂
-            """)
-
-        with gr.Column(scale=3):
-            chatbot = gr.Chatbot(
-                label="জাজাবৰ সৈতে কথোপকথন",
-                height=500,
-                show_copy_button=True
-            )
-            
-            with gr.Row():
-                text_inp = gr.Textbox(
-                    label="আপোনাৰ প্ৰশ্ন লিখক",
-                    placeholder='উদাহৰণ: "ক্লাছ ১০ অসমীয়া: অনুচ্ছেদ পাঠ ১ ৰ মূল বিষয় কি?"',
-                    lines=2,
-                    scale=4
-                )
+    def clear_chat():
+        """Clear chat history"""
+        return [], ""
+    
+    # Create Gradio interface
+    with gr.Blocks(
+        title=APP_NAME,
+        theme=gr.themes.Soft(),
+        css="""
+        .container {
+            max-width: 1200px;
+            margin: auto;
+            padding: 20px;
+        }
+        .login-section {
+            background: #f8f9fa;
+            padding: 15px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+        }
+        """
+    ) as demo:
+        
+        with gr.Column(elem_classes="container"):
+            gr.Markdown(f"# 🧭 {APP_NAME}")
+            gr.Markdown("SEBA Class 10 AI Tutor - Ask questions in Assamese or English")
             
             with gr.Row():
-                image_inp = gr.Image(
-                    label="📷 প্ৰশ্নৰ ছবি (Optional)",
-                    type="filepath",
-                    scale=3
-                )
+                with gr.Column(scale=1):
+                    with gr.Group(elem_classes="login-section"):
+                        gr.Markdown("### 👤 লগিন")
+                        username = gr.Textbox(
+                            label="আপোনাৰ নাম",
+                            placeholder="আপোনাৰ নাম লিখক...",
+                            max_lines=1
+                        )
+                        gr.Markdown("""
+                        ### 💡 টিপছ
+                        - নাম লিখি প্ৰশ্ন সোধক
+                        - পাঠ্যপুথিৰ PDF ফাইলসমূহ `pdfs/class10` ফ'ল্ডাৰত ৰাখক
+                        - ছবি আপলোড কৰিলে OCR ৰ সহায়ত পাঠ পঢ়িব
+                        """)
                 
-            with gr.Row():
-                ask_btn = gr.Button("🤖 জাজাবৰক সোধক", variant="primary", scale=2)
-                clear_btn = gr.Button("🧹 পৰিষ্কাৰ কৰক", variant="secondary", scale=1)
-
-    # Event handlers
-    login_btn.click(
-        login_user,
-        inputs=[username_inp],
-        outputs=[user_state, stats_md]
-    )
-    
-    # Chat function - simplified
-    def process_chat(text, image, history, state):
-        return chat_logic(text, image, history, state)
-    
-    ask_btn.click(
-        process_chat,
-        inputs=[text_inp, image_inp, chatbot, user_state],
-        outputs=[chatbot, user_state]
-    ).then(
-        lambda: ("", None),
-        outputs=[text_inp, image_inp]
-    )
-    
-    text_inp.submit(
-        process_chat,
-        inputs=[text_inp, image_inp, chatbot, user_state],
-        outputs=[chatbot, user_state]
-    ).then(
-        lambda: ("", None),
-        outputs=[text_inp, image_inp]
-    )
+                with gr.Column(scale=2):
+                    chatbot = gr.Chatbot(
+                        label="জাজাবৰ সৈতে কথোপকথন",
+                        height=500,
+                        show_copy_button=True
+                    )
+                    
+                    with gr.Row():
+                        message = gr.Textbox(
+                            label="প্ৰশ্ন",
+                            placeholder="আপোনাৰ প্ৰশ্ন ইয়াত লিখক...",
+                            lines=2,
+                            scale=4
+                        )
+                    
+                    with gr.Row():
+                        image = gr.Image(
+                            label="ছবি আপলোড কৰক (ঐচ্ছিক)",
+                            type="filepath",
+                            height=150
+                        )
+                    
+                    with gr.Row():
+                        submit_btn = gr.Button("📤 প্ৰশ্ন পঠিয়াওক", variant="primary", scale=2)
+                        clear_btn = gr.Button("🧹 পৰিষ্কাৰ কৰক", variant="secondary", scale=1)
+            
+            # Event handlers
+            submit_btn.click(
+                fn=chat_function,
+                inputs=[message, image, chatbot, username],
+                outputs=[chatbot, message]
+            )
+            
+            message.submit(
+                fn=chat_function,
+                inputs=[message, image, chatbot, username],
+                outputs=[chatbot, message]
+            )
+            
+            clear_btn.click(
+                fn=clear_chat,
+                outputs=[chatbot, message]
+            )
     
-    clear_btn.click(
-        clear_chat,
-        outputs=[chatbot, image_inp]
-    )
+    return demo
 
+# -------------------- LAUNCH --------------------
 if __name__ == "__main__":
-    # For Hugging Face Spaces, don't use share=True
+    if not GRADIO_AVAILABLE:
+        print("Gradio not available. Please install gradio.")
+        exit(1)
+    
+    demo = main()
+    
+    # For Hugging Face Spaces, use share=False and don't specify server_name
     try:
         demo.launch(
-            server_name="0.0.0.0",
+            server_name="0.0.0.0" if os.getenv('SPACE_ID') else None,
             server_port=7860,
-            share=False,  # Changed to False for Hugging Face Spaces
+            share=False,  # Important: set to False for Spaces
             show_error=True
         )
     except Exception as e:
         print(f"Launch error: {e}")
-        # Fallback to simple launch
+        # Fallback launch without server_name
         demo.launch(share=False)