Updated app.py and gradioapp.py

Note.txt

@@ -0,0 +1,6 @@
+Download The excel Sheet done
+Remove expection Block for Download done
+
+in mock interview ask tech stack and then run tailvy search 
+
+make it conversational and save history(previous query) in output list

app.py

@@ -3,339 +3,468 @@ import os
 import re
 import pandas as pd
 import random
-import warnings
+from typing import Dict, Optional, Any
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from dotenv import load_dotenv
 from langchain_tavily import TavilySearch
 import google.generativeai as genai
-import gdown
-
-warnings.filterwarnings("ignore")
 
+# Load environment variables
 load_dotenv()
 TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
 
-user_sessions = {}
-if not GOOGLE_API_KEY:
-    raise ValueError("GOOGLE_API_KEY environment variable is required.")
-
+# Configure Google AI
 genai.configure(api_key=GOOGLE_API_KEY)
 
-# ——— Load or fallback LeetCode data ——————————————————————————
+# Load LeetCode data
 OUTPUT_FILE = "leetcode_downloaded.xlsx"
-GOOGLE_SHEET_URL = "https://docs.google.com/spreadsheets/d/1KK9Mnm15hV3ALJo-quJndftWfaujJ7K2_zHMCTo5mGE/"
-FILE_ID = GOOGLE_SHEET_URL.split("/d/")[1].split("/")[0]
-DOWNLOAD_URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
-
 try:
-    if os.path.exists(OUTPUT_FILE):
-        print(f"Loading LeetCode data from local file: {OUTPUT_FILE}")
-        LEETCODE_DATA = pd.read_excel(OUTPUT_FILE)
-    else:
-        print("Local LeetCode file not found. Attempting to download...")
-        print("Downloading LeetCode data...")
-        gdown.download(DOWNLOAD_URL, OUTPUT_FILE, quiet=False)
-        LEETCODE_DATA = pd.read_excel(OUTPUT_FILE)
-    print(f"Loaded {len(LEETCODE_DATA)} problems")
-except Exception as e:
-    print(f"Failed to load or download LeetCode data: {str(e)}")
-    print("Using fallback dataset.")
-    LEETCODE_DATA = pd.DataFrame([
-        {"problem_no": 3151, "problem_level": "Easy", "problem_statement": "special array",
-         "problem_link": "https://leetcode.com/problems/special-array-i/?envType=daily-question&envId=2025-06-01"},
-        {"problem_no": 1752, "problem_level": "Easy", "problem_statement": "check if array is sorted and rotated",
-         "problem_link": "https://leetcode.com/problems/check-if-array-is-sorted-and-rotated/?envType=daily-question&envId=2025-06-01"},
-        {"problem_no": 3105, "problem_level": "Easy", "problem_statement": "longest strictly increasing or strictly decreasing subarray",
-         "problem_link": "https://leetcode.com/problems/longest-strictly-increasing-or-strictly-decreasing-subarray/?envType=daily-question&envId=2025-06-01"},
-        {"problem_no": 1, "problem_level": "Easy", "problem_statement": "two sum",
-         "problem_link": "https://leetcode.com/problems/two-sum/"},
-        {"problem_no": 2, "problem_level": "Medium", "problem_statement": "add two numbers",
-         "problem_link": "https://leetcode.com/problems/add-two-numbers/"},
-        {"problem_no": 3, "problem_level": "Medium", "problem_statement": "longest substring without repeating characters",
-         "problem_link": "https://leetcode.com/problems/longest-substring-without-repeating-characters/"},
-        {"problem_no": 4, "problem_level": "Hard", "problem_statement": "median of two sorted arrays",
-         "problem_link": "https://leetcode.com/problems/median-of-two-sorted-arrays/"},
-        {"problem_no": 5, "problem_level": "Medium", "problem_statement": "longest palindromic substring",
-         "problem_link": "https://leetcode.com/problems/longest-palindromic-substring/"}
-    ])
-
-# ——— Helpers & Tools ——————————————————————————————————————————
-
-QUESTION_TYPE_MAPPING = {
-    "easy": "Easy", "Easy": "Easy",
-    "medium": "Medium", "Medium": "Medium",
-    "hard": "Hard", "Hard": "Hard"
-}
+    LEETCODE_DATA = pd.read_excel(OUTPUT_FILE)
+    print(f"Loaded {len(LEETCODE_DATA)} LeetCode problems from local file.")
+except FileNotFoundError:
+    print("Warning: LeetCode data file not found. Some features may not work.")
+    LEETCODE_DATA = pd.DataFrame()
 
+# User sessions for mock interviews
+user_sessions = {}
+
+# ——— Pydantic Models ——————————————————————————————————————————
+class ChatRequest(BaseModel):
+    user_id: str = "default"
+    session_id: str = "default"
+    message: str
+
+class ChatResponse(BaseModel):
+    status: str
+    response: str
+    session_id: str
+
+class HealthResponse(BaseModel):
+    status: str
+    google_api_configured: bool
+    leetcode_problems_loaded: int
+    tavily_search_available: bool
+
+# ——— Utility Functions ——————————————————————————————————————————
 def preprocess_query(query: str) -> str:
-    for k, v in QUESTION_TYPE_MAPPING.items():
-        query = re.sub(rf'\b{k}\b', v, query, flags=re.IGNORECASE)
-    query = re.sub(r'\bproblem\s*(\d+)', r'Problem_\1', query, flags=re.IGNORECASE)
-    query = re.sub(r'\bquestion\s*(\d+)', r'Problem_\1', query, flags=re.IGNORECASE)
-    query = re.sub(r'\b(find|search)\s+interview\s+questions\s+for\s+', '', query, flags=re.IGNORECASE)
-    query = re.sub(r'\binterview\s+questions\b', '', query, flags=re.IGNORECASE).strip()
-    return query
-
-def get_daily_coding_question(query: str = "") -> dict:
-    try:
-        response = "**Daily Coding Questions**\n\n"
-        
-        m = re.search(r'Problem_(\d+)', query, re.IGNORECASE)
-        if m:
-            df = LEETCODE_DATA[LEETCODE_DATA['problem_no'] == int(m.group(1))]
-            if not df.empty:
-                p = df.iloc[0]
-                response += (
-                    f"**Problem {p['problem_no']}**\n"
-                    f"Level: {p['problem_level']}\n"
-                    f"Statement: {p['problem_statement']}\n"
-                    f"Link: {p['problem_link']}\n\n"
-                )
-                return {"status": "success", "response": response}
-            else:
-                return {"status": "error", "response": "Problem not found"}
-        
-        if query.strip():
-            df = LEETCODE_DATA[LEETCODE_DATA['problem_statement'].str.contains(query, case=False, na=False)]
+    """Preprocess user query for better understanding"""
+    return query.strip()
+
+# ——— Tool 1: Get Daily Coding Question ——————————————————————————
+def get_daily_coding_question(query=""):
+    """Get 3 random coding questions (one from each difficulty level)"""
+    if LEETCODE_DATA.empty:
+        return {"status": "error", "response": "LeetCode data not available. Please check the data file."}
+    
+    response = "Here are your coding challenges for today:\n\n"
+
+    problem_match = re.search(r'problem[\s_]*(\d+)', query, re.IGNORECASE)
+    if problem_match:
+        problem_no = int(problem_match.group(1))
+        specific_problem = LEETCODE_DATA[LEETCODE_DATA['problem_no'] == problem_no]
+        if not specific_problem.empty:
+            p = specific_problem.iloc[0]
+            response = f"**Problem {p['problem_no']}: {p['problem_statement']}**\n"
+            response += f"**Difficulty**: {p['problem_level']}\n"
+            response += f"**Link**: {p['problem_link']}\n\n"
+            response += "Good luck with this problem!"
+            return {"status": "success", "response": response}
         else:
-            df = LEETCODE_DATA
-
-        easy_questions = df[df['problem_level'] == 'Easy'].sample(min(3, len(df[df['problem_level'] == 'Easy'])))
-        medium_questions = df[df['problem_level'] == 'Medium'].sample(min(1, len(df[df['problem_level'] == 'Medium'])))
-        hard_questions = df[df['problem_level'] == 'Hard'].sample(min(1, len(df[df['problem_level'] == 'Hard'])))
-
-        response += "**Easy Questions**\n"
-        for i, p in enumerate(easy_questions.itertuples(), 1):
-            response += (
-                f"{i}. Problem {p.problem_no}: {p.problem_statement}\n"
-                f"   Level: {p.problem_level}\n"
-                f"   Link: {p.problem_link}\n\n"
-            )
-
-        response += "**Medium Question**\n"
-        for p in medium_questions.itertuples():
-            response += (
-                f"Problem {p.problem_no}: {p.problem_statement}\n"
-                f"Level: {p.problem_level}\n"
-                f"Link: {p.problem_link}\n\n"
-            )
-
-        response += "**Hard Question**\n"
-        for p in hard_questions.itertuples():
-            response += (
-                f"Problem {p.problem_no}: {p.problem_statement}\n"
-                f"Level: {p.problem_level}\n"
-                f"Link: {p.problem_link}\n"
-            )
-
-        return {"status": "success", "response": response}
-    except Exception as e:
-        return {"status": "error", "response": f"Error: {e}"}
+            return {"status": "error", "response": "Problem not found. Try a different number!"}
 
-def fetch_interview_questions(query: str) -> dict:
+    easy = LEETCODE_DATA[LEETCODE_DATA['problem_level'] == 'Easy']
+    medium = LEETCODE_DATA[LEETCODE_DATA['problem_level'] == 'Medium']
+    hard = LEETCODE_DATA[LEETCODE_DATA['problem_level'] == 'Hard']
+
+    for label, df in [("🟢 Easy", easy), ("🟡 Medium", medium), ("🔴 Hard", hard)]:
+        if not df.empty:
+            q = df.sample(1).iloc[0]
+            response += f"**{label} Challenge**\n"
+            response += f"Problem {q['problem_no']}: {q['problem_statement']}\n"
+            response += f"Link: {q['problem_link']}\n\n"
+
+    response += "Choose one that matches your skill level and start coding!"
+    return {"status": "success", "response": response}
+
+# ——— Tool 2: Fetch Interview Questions ——————————————————————————
+def fetch_interview_questions(query):
     if not TAVILY_API_KEY:
-        return {"status": "error", "response": "Tavily API key not configured"}
+        return {"status": "error", "response": "Tavily API key not configured."}
+
+    try:
+        tavily = TavilySearch(api_key=TAVILY_API_KEY, max_results=3)
+        search_response = tavily.invoke(f"{query} interview questions")
+
+        # Extract the results list from the response dictionary
+        results = search_response.get("results", []) if isinstance(search_response, dict) else search_response
+
+        if not results:
+            return {"status": "success", "response": f"No results found for '{query}' interview questions."}
+
+        search_results = f"Here are the top 3 resources for {query} interview questions:\n\n"
+        for i, res in enumerate(results[:3], 1):
+            t = res.get('title', 'No title')
+            u = res.get('url', 'No URL')
+            c = res.get('content', '')
+            snippet = c[:200] + '...' if len(c) > 200 else c
+            search_results += f"**{i}. {t}**\nURL: {u}\nPreview: {snippet}\n\n"
+
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        guidance = model.generate_content(f"""
+            Based on the topic '{query}', provide practical advice on how to prepare for and tackle interview questions in this area.
+            Include:
+            1. Key concepts to focus on
+            2. Common question types
+            3. How to structure answers
+            4. Tips for success
+
+            Keep it concise and actionable.
+        """).text
+
+        final = search_results + "\n**💡 How to Tackle These Interviews:**\n\n" + guidance
+        return {"status": "success", "response": final}
     
-    if not query.strip() or query.lower() in ["a", "interview", "question", "questions"]:
-        return {"status": "error", "response": "Please provide a specific topic for interview questions (e.g., 'Python', 'data structures', 'system design')."}
+    except Exception as e:
+        return {"status": "error", "response": f"Error fetching interview questions: {str(e)}"}
+
+# ——— Tool 3: Simulate Mock Interview ——————————————————————————
+def simulate_mock_interview(query, user_id="default", session_id="default"):
+    session_key = f"mock_{user_id}_{session_id}"
+    if session_key not in user_sessions:
+        user_sessions[session_key] = {
+            "stage": "tech_stack",
+            "tech_stack": "",
+            "questions_asked": [],
+            "answers_given": [],
+            "current_question": "",
+            "question_count": 0,
+            "difficulty": "medium",
+            "feedback_history": []
+        }
+    session = user_sessions[session_key]
     
     try:
-        tavily = TavilySearch(api_key=TAVILY_API_KEY, max_results=5)
-        search_query = f"{query} interview questions -inurl:(signup | login)"
-        print(f"Executing Tavily search for: {search_query}")
-        
-        results = tavily.invoke(search_query)
-        print(f"Raw Tavily results: {results}")
-        
-        if not results or not isinstance(results, list) or len(results) == 0:
-            return {"status": "success", "response": "No relevant interview questions found. Try a more specific topic or different keywords."}
-        
-        resp = "**Interview Questions Search Results for '{}':**\n\n".format(query)
-        for i, r in enumerate(results, 1):
-            if isinstance(r, dict):
-                title = r.get('title', 'No title')
-                url = r.get('url', 'No URL')
-                content = r.get('content', '')
-                content = content[:200] + '…' if len(content) > 200 else content or "No preview available"
-                resp += f"{i}. **{title}**\n   URL: {url}\n   Preview: {content}\n\n"
-            else:
-                resp += f"{i}. {str(r)[:200]}{'…' if len(str(r)) > 200 else ''}\n\n"
-        
-        return {"status": "success", "response": resp}
+        model = genai.GenerativeModel('gemini-1.5-flash')
+
+        # Tech stack collection stage
+        if session["stage"] == "tech_stack":
+            session["stage"] = "waiting_tech_stack"
+            return {"status": "success", "response": (
+                "Welcome to your mock interview! 🎯\n\n"
+                "Please tell me about your tech stack (e.g., Python, React, multi-agent systems) "
+                "or the role you're preparing for (e.g., software engineer, ML engineer)."
+            )}
+
+        elif session["stage"] == "waiting_tech_stack":
+            session["tech_stack"] = query
+            session["stage"] = "interviewing"
+            difficulty_options = " (easy/medium/hard)"
+            q = model.generate_content(f"""
+                Generate a relevant interview question for tech stack: {query}
+                Ensure it tests technical knowledge and problem-solving.
+                Keep it concise and return only the question.
+            """).text.strip()
+            
+            session.update({
+                "current_question": q,
+                "questions_asked": [q],
+                "question_count": 1
+            })
+            
+            return {"status": "success", "response": (
+                f"Great! Based on your tech stack ({query}), let's start your mock interview.\n\n"
+                f"**Question 1:** {q}\n"
+                f"Set difficulty level{difficulty_options} or proceed. Type 'quit' to end and get your summary."
+            )}
+
+        elif session["stage"] == "interviewing":
+            if query.lower().strip() in ["easy", "medium", "hard"]:
+                session["difficulty"] = query.lower().strip()
+                return {"status": "success", "response": (
+                    f"Difficulty set to {session['difficulty']}. Let's continue!\n\n"
+                    f"**Question {session['question_count']}:** {session['current_question']}\n\n"
+                    "Take your time to answer. Type 'quit' to end and get your summary."
+                )}
+
+            if query.lower().strip() == "quit":
+                return end_mock_interview(session_key)
+
+            # Store answer and provide feedback
+            session["answers_given"].append(query)
+            feedback = model.generate_content(f"""
+                Question: {session['current_question']}
+                Answer: {query}
+                Tech Stack: {session['tech_stack']}
+                Difficulty: {session['difficulty']}
+
+                Provide concise, constructive feedback:
+                - What went well
+                - Areas to improve
+                - Missing points or better approach
+                - Suggested follow-up topic
+            """).text.strip()
+            session["feedback_history"].append(feedback)
+
+            # Generate next question with context
+            next_q = model.generate_content(f"""
+                Tech stack: {session['tech_stack']}
+                Difficulty: {session['difficulty']}
+                Previous questions: {session['questions_asked']}
+                Follow-up topic suggestion: {feedback.split('\n')[-1] if feedback else ''}
+
+                Generate a new, relevant interview question unseen before.
+                Ensure it aligns with the tech stack and difficulty.
+                Return only the question.
+            """).text.strip()
+
+            session["questions_asked"].append(next_q)
+            session["current_question"] = next_q
+            session["question_count"] += 1
+
+            return {"status": "success", "response": (
+                f"**Feedback on your previous answer:**\n{feedback}\n\n"
+                f"**Question {session['question_count']}:** {next_q}\n\n"
+                "Type 'quit' to end the interview and get your summary, or set a new difficulty (easy/medium/hard)."
+            )}
     
     except Exception as e:
-        print(f"Tavily search failed: {str(e)}")
-        return {"status": "error", "response": f"Search failed: {str(e)}"}
+        return {"status": "error", "response": f"Error in mock interview: {str(e)}"}
 
-def simulate_mock_interview(query: str, user_id: str = "default") -> dict:
-    qtype = "mixed"
-    if re.search(r'HR|Behavioral|hr|behavioral', query, re.IGNORECASE): qtype = "HR"
-    if re.search(r'Technical|System Design|technical|coding', query, re.IGNORECASE): qtype = "Technical"
-    
-    if "interview question" in query.lower() and qtype == "mixed":
-        qtype = "HR"
+def end_mock_interview(session_key):
+    session = user_sessions[session_key]
     
-    if qtype == "HR":
-        hr_questions = [
-            "Tell me about yourself.",
-            "What is your greatest weakness?",
-            "Describe a challenge you overcame.",
-            "Why do you want to work here?",
-            "Where do you see yourself in 5 years?",
-            "Why are you leaving your current job?",
-            "Describe a time when you had to work with a difficult team member.",
-            "What are your salary expectations?",
-            "Tell me about a time you failed.",
-            "What motivates you?",
-            "How do you handle stress and pressure?",
-            "Describe your leadership style."
-        ]
-        q = random.choice(hr_questions)
-        return {"status": "success", "response": (
-            f"**Mock Interview (HR/Behavioral)**\n\n**Question:** {q}\n\n💡 **Tips:**\n"
-            f"- Use the STAR method (Situation, Task, Action, Result)\n"
-            f"- Provide specific examples from your experience\n"
-            f"- Keep your answer concise but detailed\n\n**Your turn to answer!**"
-        )}
-    else:
-        p = LEETCODE_DATA.sample(1).iloc[0]
+    try:
+        model = genai.GenerativeModel('gemini-1.5-flash')
+
+        summary = model.generate_content(f"""
+            Mock Interview Summary:
+            Tech Stack: {session['tech_stack']}
+            Difficulty: {session['difficulty']}
+            Questions Asked: {session['questions_asked']}
+            Answers Given: {session['answers_given']}
+            Feedback History: {session['feedback_history']}
+
+            Provide a concise overall assessment:
+            - Strengths
+            - Areas for improvement
+            - Key recommendations
+            - Common mistakes to avoid
+        """).text.strip()
+
+        # Store session data before deletion for response
+        tech_stack = session['tech_stack']
+        difficulty = session['difficulty']
+        questions_count = len(session['questions_asked'])
+        
+        del user_sessions[session_key]
+
         return {"status": "success", "response": (
-            f"**Mock Interview (Technical)**\n\n**Problem:** {p['problem_statement'].title()}\n"
-            f"**Difficulty:** {p['problem_level']}\n**Link:** {p['problem_link']}\n\n💡 **Tips:**\n"
-            f"- Think out loud as you solve\n"
-            f"- Ask clarifying questions\n"
-            f"- Discuss time/space complexity\n\n**Explain your approach!**"
+            "🎯 **Mock Interview Complete!**\n\n"
+            f"**Interview Summary:**\n"
+            f"- Tech Stack: {tech_stack}\n"
+            f"- Difficulty: {difficulty}\n"
+            f"- Questions Asked: {questions_count}\n\n"
+            "**Overall Assessment:**\n" + summary + "\n\n"
+            "Great job—use this feedback to level up! 💪"
         )}
+    
+    except Exception as e:
+        return {"status": "error", "response": f"Error generating interview summary: {str(e)}"}
 
-# ——— The Enhanced InterviewPrepAgent ——————————————————————————————
-
+# ——— Main Agent Class ——————————————————————————————————————————
 class InterviewPrepAgent:
     def __init__(self):
-        self.model = genai.GenerativeModel('gemini-1.5-flash')
+        if GOOGLE_API_KEY:
+            self.model = genai.GenerativeModel('gemini-1.5-flash')
+        else:
+            self.model = None
         self.tools = {
             "get_daily_coding_question": get_daily_coding_question,
             "fetch_interview_questions": fetch_interview_questions,
             "simulate_mock_interview": simulate_mock_interview
         }
-        self.instruction_text = """
-You are an interview preparation assistant. Analyze the user's query and determine which tool to use.
-
-Available tools:
-1. get_daily_coding_question - For coding practice, LeetCode problems, daily questions
-2. fetch_interview_questions - For searching interview questions on specific topics
-3. simulate_mock_interview - For mock interview practice (HR/behavioral or technical)
-
-Instructions:
-- If user asks for coding questions, daily questions, LeetCode problems, practice problems -> use get_daily_coding_question
-- If user asks for interview questions on specific topics (e.g., Python, data structures) without "mock" or "simulate" -> use fetch_interview_questions
-- If user asks for mock interview, interview simulation, practice interview, or HR/behavioral questions -> use simulate_mock_interview
-- If user explicitly mentions "HR" or "behavioral" -> use simulate_mock_interview with HR focus
-
-Respond ONLY with valid JSON in this exact format:
-{"tool": "tool_name", "args": {"param1": "value1", "param2": "value2"}}
 
-User Query: {query}
-"""
-
-    def _classify_intent(self, query: str) -> tuple[str, dict]:
-        query_lower = query.lower()
-        
-        # Prioritize HR/behavioral for explicit mentions
-        if any(keyword in query_lower for keyword in ["hr", "behavioral", "give hr questions", "give behavioral questions"]):
-            return "simulate_mock_interview", {"query": query, "user_id": "default"}
-        
-        # Handle mock interview or simulation requests
-        if any(keyword in query_lower for keyword in ["mock interview", "practice interview", "interview simulation", "simulate_mock_interview"]):
-            return "simulate_mock_interview", {"query": query, "user_id": "default"}
-        
-        # Handle coding-related queries
-        if any(keyword in query_lower for keyword in ["daily", "coding question", "leetcode", "practice problem", "coding practice"]):
-            problem_match = re.search(r'problem\s*(\d+)', query_lower)
-            if problem_match:
-                return "get_daily_coding_question", {"query": f"Problem_{problem_match.group(1)}"}
-            
-            if "easy" in query_lower:
-                return "get_daily_coding_question", {"query": "Easy"}
-            elif "medium" in query_lower:
-                return "get_daily_coding_question", {"query": "Medium"}
-            elif "hard" in query_lower:
-                return "get_daily_coding_question", {"query": "Hard"}
-            
-            return "get_daily_coding_question", {"query": ""}
-        
-        # Handle topic-specific interview questions
-        if any(keyword in query_lower for keyword in ["search interview questions", "find interview questions", "interview prep resources"]) or \
-           "interview" in query_lower:
-            return "fetch_interview_questions", {"query": query}
+    def classify_query(self, query):
+        if not self.model:
+            # Fallback classification without AI
+            query_lower = query.lower()
+            if any(keyword in query_lower for keyword in ['mock', 'interview', 'simulate', 'practice']):
+                return "simulate_mock_interview", {"query": query}
+            elif any(keyword in query_lower for keyword in ['coding', 'leetcode', 'daily', 'problem']):
+                return "get_daily_coding_question", {"query": query}
+            else:
+                return "fetch_interview_questions", {"query": query}
         
-        # Fallback to LLM classification
         try:
-            prompt = self.instruction_text.format(query=query)
-            response = self.model.generate_content(prompt)
-            result = json.loads(response.text.strip())
-            tool_name = result.get("tool")
-            args = result.get("args", {})
-            return tool_name, args
+            prompt = f"""
+            Analyze this user query and determine which tool to use:
+
+            Query: "{query}"
+
+            Tools:
+            1. get_daily_coding_question – for coding problems, leetcode, daily challenges
+            2. fetch_interview_questions – for topic-specific interview question resources
+            3. simulate_mock_interview – for mock interview practice or behavioral interviews
+
+            Rules:
+            - If query mentions 'mock', 'interview', 'simulate', or 'practice', choose simulate_mock_interview
+            - If query mentions 'coding', 'leetcode', 'daily', 'problem', choose get_daily_coding_question
+            - If query asks for interview questions on a specific technology (like 'Python interview questions'), choose fetch_interview_questions
+            - If unclear, default to simulate_mock_interview
+
+            Respond with JSON: {{"tool": "tool_name", "args": {{"query": "query_text"}}}}
+            """
+            resp = self.model.generate_content(prompt).text.strip()
+            if resp.startswith("```json"):
+                resp = resp.replace("```json", "").replace("```", "").strip()
+            j = json.loads(resp)
+            return j.get("tool"), j.get("args", {})
         except Exception as e:
-            print(f"LLM classification failed: {e}")
-            return "get_daily_coding_question", {"query": ""}
+            # Fallback to simple classification
+            return "simulate_mock_interview", {"query": query}
 
-    def process_query(self, query: str, user_id: str, session_id: str) -> str:
-        if not GOOGLE_API_KEY:
-            return "Error: Google API not configured."
-        
-        session_key = f"{user_id}_{session_id}"
-        user_sessions.setdefault(session_key, {"history": []})
+    def process_query(self, query, user_id="default", session_id="default"):
+        tool, args = self.classify_query(query)
+        if tool not in self.tools:
+            return {"status": "error", "response": "Sorry, I didn't get that. Ask for coding practice, interview questions, or mock interview!"}
 
-        tool_name, args = self._classify_intent(query)
-        print(f"Selected tool: {tool_name}, args: {args}")  # Debug log
-        
-        if tool_name not in self.tools:
-            return f"I couldn't understand your request. Please try asking for:\n- Daily coding question\n- Mock interview\n- Interview questions for a specific topic"
-
-        result = self.tools[tool_name](**args)
-        
-        user_sessions[session_key]["history"].append({
-            "query": query, 
-            "response": result["response"]
-        })
+        if tool == "simulate_mock_interview":
+            result = self.tools[tool](args.get("query", query), user_id, session_id)
+        else:
+            result = self.tools[tool](args.get("query", query))
         
-        return result["response"]
+        return result.get("response", "Something went wrong, try again.")
 
-# ——— FastAPI Setup ——————————————————————————————————————————
+# ——— FastAPI Application ——————————————————————————————————————
+app = FastAPI(title="Interview Prep API", version="2.0.0", description="AI-powered interview practice companion")
 
-app = FastAPI(title="Interview Prep API", version="2.0.0")
+# Initialize the agent
 agent = InterviewPrepAgent()
 
-class ChatRequest(BaseModel):
-    user_id: str
-    session_id: str
-    question: str
-
-class ChatResponse(BaseModel):
-    session_id: str
-    answer: str
-
 @app.post("/chat", response_model=ChatResponse)
-async def chat(req: ChatRequest):
-    q = preprocess_query(req.question)
-    print(f"Preprocessed query: {q}")  # Debug log
-    ans = agent.process_query(q, req.user_id, req.session_id)
-    return ChatResponse(session_id=req.session_id, answer=ans)
-
-@app.get("/healthz")
-def health():
-    status = {"status": "ok", "google_api": bool(GOOGLE_API_KEY),
-              "leetcode_count": len(LEETCODE_DATA),
-              "tavily": bool(TAVILY_API_KEY)}
-    return status
+async def chat(request: ChatRequest):
+    """
+    Process a chat message and return a response
+    """
+    try:
+        query = preprocess_query(request.message)
+        response = agent.process_query(query, request.user_id, request.session_id)
+        
+        return ChatResponse(
+            status="success",
+            response=response,
+            session_id=request.session_id
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing chat: {str(e)}")
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """
+    Health check endpoint
+    """
+    return HealthResponse(
+        status="healthy",
+        google_api_configured=bool(GOOGLE_API_KEY),
+        leetcode_problems_loaded=len(LEETCODE_DATA),
+        tavily_search_available=bool(TAVILY_API_KEY)
+    )
 
 @app.get("/")
-def root():
-    return {"message": "Interview Prep API v2", "endpoints": ["/chat", "/healthz"]}
+async def root():
+    """
+    Root endpoint with API information
+    """
+    return {
+        "message": "Interview Prep API v2.0.0",
+        "description": "AI-powered interview practice companion",
+        "endpoints": {
+            "/chat": "POST - Send chat messages",
+            "/health": "GET - Health check",
+            "/docs": "GET - API documentation",
+            "/examples": "GET - Example requests"
+        }
+    }
+
+@app.get("/examples")
+async def get_examples():
+    """
+    Get example requests for the API
+    """
+    return {
+        "examples": [
+            {
+                "description": "Get daily coding questions",
+                "request": {
+                    "user_id": "user123",
+                    "session_id": "session456",
+                    "message": "Give me daily coding questions"
+                }
+            },
+            {
+                "description": "Start a mock interview",
+                "request": {
+                    "user_id": "user123",
+                    "session_id": "session456",
+                    "message": "Start a mock interview"
+                }
+            },
+            {
+                "description": "Get Python interview questions",
+                "request": {
+                    "user_id": "user123",
+                    "session_id": "session456",
+                    "message": "Python interview questions"
+                }
+            },
+            {
+                "description": "Get specific LeetCode problem",
+                "request": {
+                    "user_id": "user123",
+                    "session_id": "session456",
+                    "message": "Show me problem 1"
+                }
+            }
+        ]
+    }
+
+@app.delete("/session/{user_id}/{session_id}")
+async def clear_session(user_id: str, session_id: str):
+    """
+    Clear a specific user session
+    """
+    session_key = f"mock_{user_id}_{session_id}"
+    if session_key in user_sessions:
+        del user_sessions[session_key]
+        return {"message": f"Session {session_id} for user {user_id} cleared successfully"}
+    else:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+@app.get("/sessions/{user_id}")
+async def get_user_sessions(user_id: str):
+    """
+    Get all sessions for a specific user
+    """
+    user_session_keys = [key for key in user_sessions.keys() if key.startswith(f"mock_{user_id}_")]
+    sessions = []
+    for key in user_session_keys:
+        session_id = key.split("_")[-1]
+        session_data = user_sessions[key]
+        sessions.append({
+            "session_id": session_id,
+            "stage": session_data.get("stage"),
+            "tech_stack": session_data.get("tech_stack"),
+            "question_count": session_data.get("question_count", 0),
+            "difficulty": session_data.get("difficulty")
+        })
+    return {"user_id": user_id, "sessions": sessions}
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    print("Starting Interview Prep FastAPI server...")
+    print(f"Google API configured: {bool(GOOGLE_API_KEY)}")
+    print(f"LeetCode problems loaded: {len(LEETCODE_DATA)}")
+    print(f"Tavily search available: {bool(TAVILY_API_KEY)}")
+    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)

gradioapp.py

@@ -3,207 +3,228 @@ import os
 import re
 import pandas as pd
 import random
-import warnings
 from dotenv import load_dotenv
 from langchain_tavily import TavilySearch
 import google.generativeai as genai
-import gdown
 import gradio as gr
 
-warnings.filterwarnings("ignore")
-
 load_dotenv()
 TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
 
-user_sessions = {}
-if not GOOGLE_API_KEY:
-    raise ValueError("GOOGLE_API_KEY environment variable is required.")
+# User sessions for mock interviews
+# user_sessions = {}
 
 genai.configure(api_key=GOOGLE_API_KEY)
 
-# ——— Load or fallback LeetCode data ——————————————————————————
-GOOGLE_SHEET_URL = "https://docs.google.com/spreadsheets/d/1KK9Mnm15hV3ALJo-quJndftWfaujJ7K2_zHMCTo5mGE/"
-FILE_ID = GOOGLE_SHEET_URL.split("/d/")[1].split("/")[0]
-DOWNLOAD_URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
-OUTPUT_FILE = "leetcode_downloaded.xlsx"
-
-try:
-    print("Downloading LeetCode data...")
-    gdown.download(DOWNLOAD_URL, OUTPUT_FILE, quiet=False)
-    LEETCODE_DATA = pd.read_excel(OUTPUT_FILE)
-    print(f"Loaded {len(LEETCODE_DATA)} problems")
-except Exception:
-    print("Failed to download/read. Using fallback.")
-    LEETCODE_DATA = pd.DataFrame([
-        {"problem_no": 3151, "problem_level": "Easy", "problem_statement": "special array",
-         "problem_link": "https://leetcode.com/problems/special-array-i/?envType=daily-question&envId=2025-06-01"},
-        {"problem_no": 1752, "problem_level": "Easy", "problem_statement": "check if array is sorted and rotated",
-         "problem_link": "https://leetcode.com/problems/check-if-array-is-sorted-and-rotated/?envType=daily-question&envId=2025-06-01"},
-        {"problem_no": 3105, "problem_level": "Easy", "problem_statement": "longest strictly increasing or strictly decreasing subarray",
-         "problem_link": "https://leetcode.com/problems/longest-strictly-increasing-or-strictly-decreasing-subarray/?envType=daily-question&envId=2025-06-01"},
-        {"problem_no": 1, "problem_level": "Easy", "problem_statement": "two sum",
-         "problem_link": "https://leetcode.com/problems/two-sum/"},
-        {"problem_no": 2, "problem_level": "Medium", "problem_statement": "add two numbers",
-         "problem_link": "https://leetcode.com/problems/add-two-numbers/"},
-        {"problem_no": 3, "problem_level": "Medium", "problem_statement": "longest substring without repeating characters",
-         "problem_link": "https://leetcode.com/problems/longest-substring-without-repeating-characters/"},
-        {"problem_no": 4, "problem_level": "Hard", "problem_statement": "median of two sorted arrays",
-         "problem_link": "https://leetcode.com/problems/median-of-two-sorted-arrays/"},
-        {"problem_no": 5, "problem_level": "Medium", "problem_statement": "longest palindromic substring",
-         "problem_link": "https://leetcode.com/problems/longest-palindromic-substring/"}
-    ])
-
-# ——— Helpers & Tools ——————————————————————————————————————————
-
-QUESTION_TYPE_MAPPING = {
-    "easy": "Easy", "Easy": "Easy",
-    "medium": "Medium", "Medium": "Medium",
-    "hard": "Hard", "Hard": "Hard"
-}
-
-def preprocess_query(query: str) -> str:
-    for k, v in QUESTION_TYPE_MAPPING.items():
-        query = re.sub(rf'\b{k}\b', v, query, flags=re.IGNORECASE)
-    query = re.sub(r'\bproblem\s*(\d+)', r'Problem_\1', query, flags=re.IGNORECASE)
-    query = re.sub(r'\bquestion\s*(\d+)', r'Problem_\1', query, flags=re.IGNORECASE)
-    query = re.sub(r'\b(find|search)\s+interview\s+questions\s+for\s+', '', query, flags=re.IGNORECASE)
-    query = re.sub(r'\binterview\s+questions\b', '', query, flags=re.IGNORECASE).strip()
-    return query
-
-def get_daily_coding_question(query: str = "") -> dict:
-    try:
-        response = "**Daily Coding Questions**\n\n"
-        
-        m = re.search(r'Problem_(\d+)', query, re.IGNORECASE)
-        if m:
-            df = LEETCODE_DATA[LEETCODE_DATA['problem_no'] == int(m.group(1))]
-            if not df.empty:
-                p = df.iloc[0]
-                response += (
-                    f"**Problem {p['problem_no']}**\n"
-                    f"Level: {p['problem_level']}\n"
-                    f"Statement: {p['problem_statement']}\n"
-                    f"Link: {p['problem_link']}\n\n"
-                )
-                return {"status": "success", "response": response}
-            else:
-                return {"status": "error", "response": "Problem not found"}
-        
-        if query.strip():
-            df = LEETCODE_DATA[LEETCODE_DATA['problem_statement'].str.contains(query, case=False, na=False)]
+# Load LeetCode data
+OUTPUT_FILE = "Interview-QA-Practice-Bot/leetcode_downloaded.xlsx"
+LEETCODE_DATA = pd.read_excel(OUTPUT_FILE)
+print(f"Loaded {len(LEETCODE_DATA)} LeetCode problems from local file.")
+
+# ——— Tool 1: Get Daily Coding Question ————��—————————————————————
+def get_daily_coding_question(query=""):
+    """Get 3 random coding questions (one from each difficulty level)"""
+    response = "Here are your coding challenges for today:\n\n"
+
+    problem_match = re.search(r'problem[\s_]*(\d+)', query, re.IGNORECASE)
+    if problem_match:
+        problem_no = int(problem_match.group(1))
+        specific_problem = LEETCODE_DATA[LEETCODE_DATA['problem_no'] == problem_no]
+        if not specific_problem.empty:
+            p = specific_problem.iloc[0]
+            response = f"**Problem {p['problem_no']}: {p['problem_statement']}**\n"
+            response += f"**Difficulty**: {p['problem_level']}\n"
+            response += f"**Link**: {p['problem_link']}\n\n"
+            response += "Good luck with this problem!"
+            return {"status": "success", "response": response}
         else:
-            df = LEETCODE_DATA
-
-        easy_questions = df[df['problem_level'] == 'Easy'].sample(min(3, len(df[df['problem_level'] == 'Easy'])))
-        medium_questions = df[df['problem_level'] == 'Medium'].sample(min(1, len(df[df['problem_level'] == 'Medium'])))
-        hard_questions = df[df['problem_level'] == 'Hard'].sample(min(1, len(df[df['problem_level'] == 'Hard'])))
-
-        response += "**Easy Questions**\n"
-        for i, p in enumerate(easy_questions.itertuples(), 1):
-            response += (
-                f"{i}. Problem {p.problem_no}: {p.problem_statement}\n"
-                f"   Level: {p.problem_level}\n"
-                f"   Link: {p.problem_link}\n\n"
-            )
-
-        response += "**Medium Question**\n"
-        for p in medium_questions.itertuples():
-            response += (
-                f"Problem {p.problem_no}: {p.problem_statement}\n"
-                f"Level: {p.problem_level}\n"
-                f"Link: {p.problem_link}\n\n"
-            )
-
-        response += "**Hard Question**\n"
-        for p in hard_questions.itertuples():
-            response += (
-                f"Problem {p.problem_no}: {p.problem_statement}\n"
-                f"Level: {p.problem_level}\n"
-                f"Link: {p.problem_link}\n"
-            )
-
-        return {"status": "success", "response": response}
-    except Exception as e:
-        return {"status": "error", "response": f"Error: {e}"}
-
-def fetch_interview_questions(query: str) -> dict:
+            return {"status": "error", "response": "Problem not found. Try a different number!"}
+
+    easy = LEETCODE_DATA[LEETCODE_DATA['problem_level'] == 'Easy']
+    medium = LEETCODE_DATA[LEETCODE_DATA['problem_level'] == 'Medium']
+    hard = LEETCODE_DATA[LEETCODE_DATA['problem_level'] == 'Hard']
+
+    for label, df in [("🟢 Easy", easy), ("🟡 Medium", medium), ("🔴 Hard", hard)]:
+        if not df.empty:
+            q = df.sample(1).iloc[0]
+            response += f"**{label} Challenge**\n"
+            response += f"Problem {q['problem_no']}: {q['problem_statement']}\n"
+            response += f"Link: {q['problem_link']}\n\n"
+
+    response += "Choose one that matches your skill level and start coding!"
+    return {"status": "success", "response": response}
+
+# ——— Tool 2: Fetch Interview Questions ——————————————————————————
+def fetch_interview_questions(query):
     if not TAVILY_API_KEY:
-        return {"status": "error", "response": "Tavily API key not configured"}
-    
-    if not query.strip() or query.lower() in ["a", "interview", "question", "questions"]:
-        return {"status": "error", "response": "Please provide a specific topic for interview questions (e.g., 'Python', 'data structures', 'system design')."}
-    
-    try:
-        tavily = TavilySearch(api_key=TAVILY_API_KEY, max_results=5)
-        search_query = f"{query} interview questions -inurl:(signup | login)"
-        print(f"Executing Tavily search for: {search_query}")
-        
-        results = tavily.invoke(search_query)
-        print(f"Raw Tavily results: {results}")
-        
-        if not results or not isinstance(results, list) or len(results) == 0:
-            return {"status": "success", "response": "No relevant interview questions found. Try a more specific topic or different keywords."}
+        return {"status": "error", "response": "Tavily API key not configured."}
+
+    tavily = TavilySearch(api_key=TAVILY_API_KEY, max_results=3)
+    search_response = tavily.invoke(f"{query} interview questions")
+
+    # Extract the results list from the response dictionary
+    results = search_response.get("results", []) if isinstance(search_response, dict) else search_response
+
+    if not results:
+        return {"status": "success", "response": f"No results found for '{query}' interview questions."}
+
+    search_results = f"Here are the top 3 resources for {query} interview questions:\n\n"
+    for i, res in enumerate(results[:3], 1):
+        t = res.get('title', 'No title')
+        u = res.get('url', 'No URL')
+        c = res.get('content', '')
+        snippet = c[:200] + '...' if len(c) > 200 else c
+        search_results += f"**{i}. {t}**\nURL: {u}\nPreview: {snippet}\n\n"
+
+    model = genai.GenerativeModel('gemini-1.5-flash')
+    guidance = model.generate_content(f"""
+        Based on the topic '{query}', provide practical advice on how to prepare for and tackle interview questions in this area.
+        Include:
+        1. Key concepts to focus on
+        2. Common question types
+        3. How to structure answers
+        4. Tips for success
+
+        Keep it concise and actionable.
+    """).text
+
+    final = search_results + "\n**💡 How to Tackle These Interviews:**\n\n" + guidance
+    return {"status": "success", "response": final}
+
+# ——— Tool 3: Simulate Mock Interview ——————————————————————————
+# Enhanced user session management
+user_sessions = {}
+
+def simulate_mock_interview(query, user_id="default"):
+    session_key = f"mock_{user_id}"
+    if session_key not in user_sessions:
+        user_sessions[session_key] = {
+            "stage": "tech_stack",
+            "tech_stack": "",
+            "questions_asked": [],
+            "answers_given": [],
+            "current_question": "",
+            "question_count": 0,
+            "difficulty": "medium",  # Added difficulty level
+            "feedback_history": []   # Added feedback tracking
+        }
+    session = user_sessions[session_key]
+    model = genai.GenerativeModel('gemini-1.5-flash')
+
+    # Tech stack collection stage
+    if session["stage"] == "tech_stack":
+        session["stage"] = "waiting_tech_stack"
+        return {"status": "success", "response": (
+            "Welcome to your mock interview! 🎯\n\n"
+            "Please tell me about your tech stack (e.g., Python, React, multi-agent systems) "
+            "or the role you're preparing for (e.g., software engineer, ML engineer)."
+        )}
+
+    elif session["stage"] == "waiting_tech_stack":
+        session["tech_stack"] = query
+        session["stage"] = "interviewing"
+        difficulty_options = " (easy/medium/hard)"
+        q = model.generate_content(f"""
+            Generate a relevant interview question for tech stack: {query}
+            Ensure it tests technical knowledge and problem-solving.
+            Keep it concise and return only the question.
+        """).text.strip()
         
-        resp = "**Interview Questions Search Results for '{}':**\n\n".format(query)
-        for i, r in enumerate(results, 1):
-            if isinstance(r, dict):
-                title = r.get('title', 'No title')
-                url = r.get('url', 'No URL')
-                content = r.get('content', '')
-                content = content[:200] + '…' if len(content) > 200 else content or "No preview available"
-                resp += f"{i}. **{title}**\n   URL: {url}\n   Preview: {content}\n\n"
-            else:
-                resp += f"{i}. {str(r)[:200]}{'…' if len(str(r)) > 200 else ''}\n\n"
+        session.update({
+            "current_question": q,
+            "questions_asked": [q],
+            "question_count": 1
+        })
         
-        return {"status": "success", "response": resp}
-    
-    except Exception as e:
-        print(f"Tavily search failed: {str(e)}")
-        return {"status": "error", "response": f"Search failed: {str(e)}"}
-
-def simulate_mock_interview(query: str, user_id: str = "default") -> dict:
-    qtype = "mixed"
-    if re.search(r'HR|Behavioral|hr|behavioral', query, re.IGNORECASE): qtype = "HR"
-    if re.search(r'Technical|System Design|technical|coding', query, re.IGNORECASE): qtype = "Technical"
-    
-    if "interview question" in query.lower() and qtype == "mixed":
-        qtype = "HR"
-    
-    if qtype == "HR":
-        hr_questions = [
-            "Tell me about yourself.",
-            "What is your greatest weakness?",
-            "Describe a challenge you overcame.",
-            "Why do you want to work here?",
-            "Where do you see yourself in 5 years?",
-            "Why are you leaving your current job?",
-            "Describe a time when you had to work with a difficult team member.",
-            "What are your salary expectations?",
-            "Tell me about a time you failed.",
-            "What motivates you?",
-            "How do you handle stress and pressure?",
-            "Describe your leadership style."
-        ]
-        q = random.choice(hr_questions)
         return {"status": "success", "response": (
-            f"**Mock Interview (HR/Behavioral)**\n\n**Question:** {q}\n\n💡 **Tips:**\n"
-            f"- Use the STAR method (Situation, Task, Action, Result)\n"
-            f"- Provide specific examples from your experience\n"
-            f"- Keep your answer concise but detailed\n\n**Your turn to answer!**"
+            f"Great! Based on your tech stack ({query}), let's start your mock interview.\n\n"
+            f"**Question 1:** {q}\n"
+            f"Set difficulty level{difficulty_options} or proceed. Type 'quit' to end and get your summary."
         )}
-    else:
-        p = LEETCODE_DATA.sample(1).iloc[0]
+
+    elif session["stage"] == "interviewing":
+        if query.lower().strip() in ["easy", "medium", "hard"]:
+            session["difficulty"] = query.lower().strip()
+            return {"status": "success", "response": (
+                f"Difficulty set to {session['difficulty']}. Let's continue!\n\n"
+                f"**Question {session['question_count']}:** {session['current_question']}\n\n"
+                "Take your time to answer. Type 'quit' to end and get your summary."
+            )}
+
+        if query.lower().strip() == "quit":
+            return end_mock_interview(session_key)
+
+        # Store answer and provide feedback
+        session["answers_given"].append(query)
+        feedback = model.generate_content(f"""
+            Question: {session['current_question']}
+            Answer: {query}
+            Tech Stack: {session['tech_stack']}
+            Difficulty: {session['difficulty']}
+
+            Provide concise, constructive feedback:
+            - What went well
+            - Areas to improve
+            - Missing points or better approach
+            - Suggested follow-up topic
+        """).text.strip()
+        session["feedback_history"].append(feedback)
+
+        # Generate next question with context
+        next_q = model.generate_content(f"""
+            Tech stack: {session['tech_stack']}
+            Difficulty: {session['difficulty']}
+            Previous questions: {session['questions_asked']}
+            Follow-up topic suggestion: {feedback.split('\n')[-1] if feedback else ''}
+
+            Generate a new, relevant interview question unseen before.
+            Ensure it aligns with the tech stack and difficulty.
+            Return only the question.
+        """).text.strip()
+
+        session["questions_asked"].append(next_q)
+        session["current_question"] = next_q
+        session["question_count"] += 1
+
         return {"status": "success", "response": (
-            f"**Mock Interview (Technical)**\n\n**Problem:** {p['problem_statement'].title()}\n"
-            f"**Difficulty:** {p['problem_level']}\n**Link:** {p['problem_link']}\n\n💡 **Tips:**\n"
-            f"- Think out loud as you solve\n"
-            f"- Ask clarifying questions\n"
-            f"- Discuss time/space complexity\n\n**Explain your approach!**"
+            f"**Feedback on your previous answer:**\n{feedback}\n\n"
+            f"**Question {session['question_count']}:** {next_q}\n\n"
+            "Type 'quit' to end the interview and get your summary, or set a new difficulty (easy/medium/hard)."
         )}
 
-# ——— The Enhanced InterviewPrepAgent ——————————————————————————————
-
+def end_mock_interview(session_key):
+    session = user_sessions[session_key]
+    model = genai.GenerativeModel('gemini-1.5-flash')
+
+    summary = model.generate_content(f"""
+        Mock Interview Summary:
+        Tech Stack: {session['tech_stack']}
+        Difficulty: {session['difficulty']}
+        Questions Asked: {session['questions_asked']}
+        Answers Given: {session['answers_given']}
+        Feedback History: {session['feedback_history']}
+
+        Provide a concise overall assessment:
+        - Strengths
+        - Areas for improvement
+        - Key recommendations
+        - Common mistakes to avoid
+    """).text.strip()
+
+    del user_sessions[session_key]
+
+    return {"status": "success", "response": (
+        "🎯 **Mock Interview Complete!**\n\n"
+        f"**Interview Summary:**\n"
+        f"- Tech Stack: {session['tech_stack']}\n"
+        f"- Difficulty: {session['difficulty']}\n"
+        f"- Questions Asked: {len(session['questions_asked'])}\n\n"
+        "**Overall Assessment:**\n" + summary + "\n\n"
+        "Great job—use this feedback to level up! 💪"
+    )}
+
+# ——— Main Agent Class ——————————————————————————————————————————
 class InterviewPrepAgent:
     def __init__(self):
         self.model = genai.GenerativeModel('gemini-1.5-flash')
@@ -212,190 +233,69 @@ class InterviewPrepAgent:
             "fetch_interview_questions": fetch_interview_questions,
             "simulate_mock_interview": simulate_mock_interview
         }
-        self.instruction_text = """
-You are an interview preparation assistant. Analyze the user's query and determine which tool to use.
 
-Available tools:
-1. get_daily_coding_question - For coding practice, LeetCode problems, daily questions
-2. fetch_interview_questions - For searching interview questions on specific topics
-3. simulate_mock_interview - For mock interview practice (HR/behavioral or technical)
+    def classify_query(self, query):
+        prompt = f"""
+        Analyze this user query and determine which tool to use:
 
-Instructions:
-- If user asks for coding questions, daily questions, LeetCode problems, practice problems -> use get_daily_coding_question
-- If user asks for interview questions on specific topics (e.g., Python, data structures) without "mock" or "simulate" -> use fetch_interview_questions
-- If user asks for mock interview, interview simulation, practice interview, or HR/behavioral questions -> use simulate_mock_interview
-- If user explicitly mentions "HR" or "behavioral" -> use simulate_mock_interview with HR focus
+        Query: "{query}"
 
-Respond ONLY with valid JSON in this exact format:
-{"tool": "tool_name", "args": {"param1": "value1", "param2": "value2"}}
-
-User Query: {query}
-"""
-
-    def _classify_intent(self, query: str) -> tuple[str, dict]:
-        query_lower = query.lower()
-        
-        # Prioritize HR/behavioral for explicit mentions
-        if any(keyword in query_lower for keyword in ["hr", "behavioral", "give hr questions", "give behavioral questions"]):
-            return "simulate_mock_interview", {"query": query, "user_id": "default"}
-        
-        # Handle mock interview or simulation requests
-        if any(keyword in query_lower for keyword in ["mock interview", "practice interview", "interview simulation", "simulate_mock_interview"]):
-            return "simulate_mock_interview", {"query": query, "user_id": "default"}
-        
-        # Handle coding-related queries
-        if any(keyword in query_lower for keyword in ["daily", "coding question", "leetcode", "practice problem", "coding practice"]):
-            problem_match = re.search(r'problem\s*(\d+)', query_lower)
-            if problem_match:
-                return "get_daily_coding_question", {"query": f"Problem_{problem_match.group(1)}"}
-            
-            if "easy" in query_lower:
-                return "get_daily_coding_question", {"query": "Easy"}
-            elif "medium" in query_lower:
-                return "get_daily_coding_question", {"query": "Medium"}
-            elif "hard" in query_lower:
-                return "get_daily_coding_question", {"query": "Hard"}
-            
-            return "get_daily_coding_question", {"query": ""}
-        
-        # Handle topic-specific interview questions
-        if any(keyword in query_lower for keyword in ["search interview questions", "find interview questions", "interview prep resources"]) or \
-           "interview" in query_lower:
-            return "fetch_interview_questions", {"query": query}
-        
-        # Fallback to LLM classification
-        try:
-            prompt = self.instruction_text.format(query=query)
-            response = self.model.generate_content(prompt)
-            result = json.loads(response.text.strip())
-            tool_name = result.get("tool")
-            args = result.get("args", {})
-            return tool_name, args
-        except Exception as e:
-            print(f"LLM classification failed: {e}")
-            return "get_daily_coding_question", {"query": ""}
-
-    def process_query(self, query: str, user_id: str = "default", session_id: str = "default") -> str:
-        if not GOOGLE_API_KEY:
-            return "Error: Google API not configured."
-        
-        session_key = f"{user_id}_{session_id}"
-        user_sessions.setdefault(session_key, {"history": []})
+        Tools:
+        1. get_daily_coding_question – for coding problems, leetcode, daily challenges
+        2. fetch_interview_questions – for topic-specific interview question resources
+        3. simulate_mock_interview – for mock interview practice or behavioral interviews
 
-        tool_name, args = self._classify_intent(query)
-        
-        if tool_name not in self.tools:
-            return f"I couldn't understand your request. Please try asking for:\n- Daily coding question\n- Mock interview\n- Interview questions for a specific topic"
+        Rules:
+        - If query mentions 'mock', 'interview', 'simulate', or 'practice', choose simulate_mock_interview
+        - If query mentions 'coding', 'leetcode', 'daily', 'problem', choose get_daily_coding_question
+        - If query asks for interview questions on a specific technology (like 'Python interview questions'), choose fetch_interview_questions
+        - If unclear, default to simulate_mock_interview
 
-        result = self.tools[tool_name](**args)
-        
-        user_sessions[session_key]["history"].append({
-            "query": query, 
-            "response": result["response"]
-        })
-        
-        return result["response"]
+        Respond with JSON
+        """
+        resp = self.model.generate_content(prompt).text.strip()
+        if resp.startswith("```json"):
+            resp = resp.replace("```json", "").replace("```", "").strip()
+        j = json.loads(resp)
+        return j.get("tool"), j.get("args", {})
+
+    def process_query(self, query, user_id="default"):
+        tool, args = self.classify_query(query)
+        if tool not in self.tools:
+            return {"text": "Sorry, I didn't get that. Ask for coding practice, interview questions, or mock interview!"}
+
+        if tool == "simulate_mock_interview":
+            result = self.tools[tool](args.get("query", query), user_id)
+        else:
+            result = self.tools[tool](args.get("query", query))
+        return {"text": result["response"]}
 
 # ——— Gradio Interface ——————————————————————————————————————————
-
 agent = InterviewPrepAgent()
 
 def chat_interface(message, history):
-    """Handle chat messages and return response"""
-    try:
-        # Preprocess the query
-        processed_query = preprocess_query(message)
-        
-        # Get response from agent
-        response = agent.process_query(processed_query, user_id="gradio_user", session_id="session_1")
-        
-        return response
-    except Exception as e:
-        return f"Sorry, I encountered an error: {str(e)}"
+    resp = agent.process_query(message, user_id="gradio_user")
+    return resp.get("text", "Something went wrong, try again.")
 
 def create_examples():
-    """Create example messages for the interface"""
     return [
-        ["Give me a daily coding question"],
-        ["I want to practice mock interview"],
-        ["Find interview questions for Python"],
-        ["Give me HR interview questions"],
-        ["Technical mock interview"],
-        ["Search interview questions for data structures"],
+        ["Give me daily coding questions"],
+        ["Start a mock interview"],
+        ["Python interview questions"],
+        ["React interview questions"],
+        ["Show me problem 1"],
+        ["Data structures interview questions"],
     ]
 
-# Create the Gradio interface
-with gr.Blocks(
-    title="Interview Prep Assistant",
-    theme=gr.themes.Soft(),
-    css="""
-    .gradio-container {
-        max-width: 900px !important;
-    }
-    .chat-message {
-        font-size: 14px !important;
-    }
-    """
-) as interface:
-    
-    gr.Markdown(
-        """
-        # 🎯 Interview Prep Assistant
-        
-        Your AI-powered interview preparation companion! I can help you with:
-        
-        - **Daily Coding Questions** - Get LeetCode problems for practice
-        - **Mock Interviews** - Practice HR/behavioral or technical interviews
-        - **Interview Questions** - Search for specific topic-based interview questions
-        
-        Just type your request below and I'll help you prepare for your next interview!
-        """
-    )
-    
-    # Create the chat interface
+with gr.Blocks(title="Interview Prep Assistant", theme=gr.themes.Soft()) as interface:
+    gr.Markdown("# 🎯 Interview Prep Assistant\nYour AI-powered interview practice companion!")
     chatbot = gr.ChatInterface(
         fn=chat_interface,
-        title="Chat with Interview Prep Assistant",
-        description="Ask me for coding questions, mock interviews, or interview preparation resources!",
         examples=create_examples(),
-        textbox=gr.Textbox(
-            placeholder="Type your message here... (e.g., 'Give me a daily coding question')",
-            container=False,
-            scale=7
-        ),
-        chatbot=gr.Chatbot(
-            height=500,
-            show_label=False,
-            container=True
-        )
-    )
-    
-    # Add footer with information
-    gr.Markdown(
-        """
-        ---
-        ### 💡 Tips for using the Interview Prep Assistant:
-        
-        - **For coding practice**: "daily coding question", "easy coding problem", "leetcode problem 1"
-        - **For mock interviews**: "mock interview", "HR interview", "technical interview"
-        - **For topic research**: "Python interview questions", "system design interview questions"
-        
-        ### 📊 System Status:
-        - Google API: ✅ Configured
-        - LeetCode Problems: {} loaded
-        - Tavily Search: {} Available
-        """.format(
-            len(LEETCODE_DATA),
-            "✅" if TAVILY_API_KEY else "❌"
-        )
+        chatbot=gr.Chatbot(height=500, show_label=False, container=True, type="messages"),
+        textbox=gr.Textbox(placeholder="Type your message here...")
     )
+    gr.Markdown(f"\n---\n**System Status:**\n- ✅ Google API Configured\n- ✅ {len(LEETCODE_DATA)} LeetCode Problems Loaded\n- {'✅' if TAVILY_API_KEY else '❌'} Tavily Search Available")
 
-# Launch the interface
 if __name__ == "__main__":
-    interface.launch(
-        # server_name="0.0.0.0",
-        server_port=8000,
-        share=False,
-        show_error=True,
-        quiet=False
-    )
+    interface.launch(server_port=8000, share=True, show_error=True, quiet=False)