Upload 3 files

app.py

@@ -0,0 +1,538 @@
+import os
+import json
+from typing import Optional
+from datetime import datetime
+import google.generativeai as genai
+import gradio as gr
+import bcrypt
+from tinydb import TinyDB, Query
+
+GEMINI_API_KEY = "AIzaSyBSHcHdbVcvo5IvKDAq2fY1xsWDDb2-JUI"
+MODEL_NAME     = "models/gemini-2.5-flash"
+DB_PATH        = "users_db.json"
+
+# Configure the API
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Initialize TinyDB
+db = TinyDB(DB_PATH)
+User = Query()
+
+# Global state for current user session
+current_user = {"logged_in": False, "user_data": None}
+
+class UserAuthentication:
+    """Handle user authentication and database operations"""
+    
+    def __init__(self, db_path: str = DB_PATH):
+        self.db = TinyDB(db_path)
+    
+    @staticmethod
+    def hash_password(password: str) -> str:
+        """Hash password using bcrypt"""
+        return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+    
+    @staticmethod
+    def verify_password(password: str, hashed: str) -> bool:
+        """Verify password against hash"""
+        return bcrypt.checkpw(password.encode('utf-8'), hashed.encode('utf-8'))
+    
+    def user_exists(self, email: str) -> bool:
+        """Check if user already exists"""
+        return self.db.search(User.email == email) != []
+    
+    def signup(self, username: str, email: str, password: str, phone: str = "") -> tuple[bool, str]:
+        """Register a new user"""
+        try:
+            if not username or not email or not password:
+                return False, "All fields are required"
+            
+            if self.user_exists(email):
+                return False, "Email already registered"
+            
+            if len(password) < 6:
+                return False, "Password must be at least 6 characters"
+            
+            hashed_password = self.hash_password(password)
+            
+            user_data = {
+                "username": username,
+                "email": email,
+                "password": hashed_password,
+                "phone": phone,
+                "created_at": datetime.now().isoformat(),
+                "last_login": None
+            }
+            
+            self.db.insert(user_data)
+            return True, f"✓ Account created successfully! Welcome, {username}!"
+        
+        except Exception as e:
+            return False, f"Signup error: {str(e)}"
+    
+    def login(self, email: str, password: str) -> tuple[bool, str, Optional[dict]]:
+        """Authenticate user"""
+        try:
+            if not email or not password:
+                return False, "Email and password required", None
+            
+            users = self.db.search(User.email == email)
+            
+            if not users:
+                return False, "Email not found", None
+            
+            user = users[0]
+            
+            if not self.verify_password(password, user['password']):
+                return False, "Incorrect password", None
+            
+            # Update last login
+            self.db.update(
+                {'last_login': datetime.now().isoformat()},
+                User.email == email
+            )
+            
+            return True, f"✓ Login successful! Welcome, {user['username']}!", user
+        
+        except Exception as e:
+            return False, f"Login error: {str(e)}", None
+    
+    def get_user_profile(self, email: str) -> Optional[dict]:
+        """Get user profile"""
+        users = self.db.search(User.email == email)
+        if users:
+            user = users[0].copy()
+            user.pop('password', None)  # Remove password from profile
+            return user
+        return None
+
+class GeminiChatBot:
+    """Main chatbot class with context management and multiple modes"""
+    
+    def __init__(self, model_name: str = MODEL_NAME):
+        self.model = genai.GenerativeModel(model_name)
+        self.conversation_history = []
+        self.chat_session = None
+        self.system_prompt = ""
+        
+    def set_system_prompt(self, mode: str):
+        """Set system prompt based on chatbot mode"""
+        prompts = {
+            "general": """You are a helpful, accurate, and friendly AI assistant. 
+            Provide clear, concise, and informative responses. 
+            Always be honest about limitations and uncertainty.""",
+            
+            "technical": """You are an expert technical support assistant. 
+            Provide detailed technical solutions, code examples, and best practices. 
+            When unsure, ask clarifying questions. Always suggest verification steps.""",
+            
+            "creative": """You are a creative writing assistant with strong storytelling abilities. 
+            Help users with creative writing, brainstorming, and narrative development. 
+            Provide engaging and imaginative content.""",
+            
+            "educational": """You are an educational tutor. Explain concepts clearly, 
+            break down complex topics, and provide examples. 
+            Encourage learning and ask clarifying questions.""",
+            
+            "medical": """You are a medical information assistant. 
+            Provide accurate health information and general guidance. 
+            Always recommend consulting healthcare professionals for serious concerns. 
+            Do NOT provide emergency medical advice."""
+        }
+        self.system_prompt = prompts.get(mode, prompts["general"])
+    
+    def chat(self, user_message: str, mode: str = "general", temperature: float = 0.7) -> str:
+        """Generate response using Gemini with context"""
+        try:
+            self.set_system_prompt(mode)
+            
+            # Build messages with system context
+            messages = [
+                {"role": "user", "parts": [f"[SYSTEM: {self.system_prompt}]\n\n{user_message}"]}
+            ]
+            
+            # Add conversation history for context (last 5 exchanges)
+            if self.conversation_history:
+                history_context = "\n".join([
+                    f"Previous: {msg}" 
+                    for msg in self.conversation_history[-5:]
+                ])
+                full_message = f"[Conversation Context]\n{history_context}\n\n[New Message]\n{user_message}"
+            else:
+                full_message = user_message
+            
+            # Generate response
+            response = self.model.generate_content(
+                full_message,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=temperature,
+                    top_p=0.95,
+                    top_k=40
+                )
+            )
+            
+            bot_response = response.text
+            
+            # Store in history
+            self.conversation_history.append(f"User: {user_message[:100]}...")
+            self.conversation_history.append(f"Bot: {bot_response[:100]}...")
+            
+            return bot_response
+            
+        except Exception as e:
+            return f"Error: {str(e)}\n\nMake sure your API key is valid. Get it from: https://aistudio.google.com/app/apikey"
+
+# Initialize chatbot
+chatbot = GeminiChatBot()
+
+# Gradio Interface Functions
+def clear_history():
+    """Clear conversation history"""
+    chatbot.conversation_history = []
+    return [], ""
+
+def export_chat(chat_history: list) -> str:
+    """Export chat as JSON"""
+    if not chat_history:
+        return "No chat history to export"
+    
+    export_data = {
+        "timestamp": datetime.now().isoformat(),
+        "conversation": chat_history
+    }
+    return json.dumps(export_data, indent=2)
+
+# Initialize authentication system
+auth_system = UserAuthentication(DB_PATH)
+
+# Create demo account if it doesn't exist
+demo_email = "demo@example.com"
+if not auth_system.user_exists(demo_email):
+    auth_system.signup("Demo User", demo_email, "password123")
+    print("✅ Demo account created successfully!")
+    print("   Email: demo@example.com")
+    print("   Password: password123")
+
+# ===== AUTHENTICATION FUNCTIONS =====
+def signup_user(username: str, email: str, password: str, confirm_password: str) -> tuple[str, str]:
+    """Handle user signup"""
+    if not password or password != confirm_password:
+        return "❌ Passwords do not match!", ""
+    
+    success, message = auth_system.signup(username, email, password)
+    if success:
+        return "✅ " + message, ""
+    else:
+        return "❌ " + message, ""
+
+def login_user(email: str, password: str) -> tuple[str, str, bool]:
+    """Handle user login"""
+    success, message, user = auth_system.login(email, password)
+    if success:
+        current_user["logged_in"] = True
+        current_user["user_data"] = user
+        username = user['username'] if user else ""
+        return "✅ " + message, username, True
+    else:
+        return "❌ " + message, "", False
+
+def logout_user() -> None:
+    """Handle user logout"""
+    current_user["logged_in"] = False
+    current_user["user_data"] = None
+    chatbot.conversation_history = []
+
+# ===== CHAT FUNCTIONS WITH USER SESSION =====
+def respond_authenticated(message: str, chat_history: list, mode: str, temperature: float):
+    """Respond to user message (only when authenticated)"""
+    if not current_user["logged_in"]:
+        return "", chat_history
+    
+    response = chatbot.chat(message, mode=mode, temperature=temperature)
+    chat_history.append({"role": "user", "content": message})
+    chat_history.append({"role": "assistant", "content": response})
+    return "", chat_history
+
+def get_current_username() -> str:
+    """Get currently logged-in username"""
+    if current_user["logged_in"] and current_user["user_data"]:
+        return current_user["user_data"].get("username", "User")
+    return "Guest"
+
+# Create Unified Gradio Application
+with gr.Blocks(title="Nexus ChatBot", theme=gr.themes.Soft()) as demo:
+    # State to track if user is logged in
+    auth_state = gr.State(value=False)
+    
+    gr.Markdown("""
+    # 🤖 Nexus Intelligent ChatBot
+    
+    Your Intelligent AI Assistant powered by Google's Gemini AI
+    """)
+    
+    # AUTHENTICATION SECTION (shown when not logged in)
+    with gr.Group(visible=True) as auth_section:
+        gr.Markdown("### 🔐 Authentication")
+        
+        with gr.Tabs():
+            # LOGIN TAB
+            with gr.TabItem("🔐 Login"):
+                gr.Markdown("#### Sign In to Your Account")
+                
+                with gr.Column():
+                    login_email = gr.Textbox(
+                        label="Email",
+                        placeholder="Enter your email",
+                        type="text"
+                    )
+                    login_password = gr.Textbox(
+                        label="Password",
+                        placeholder="Enter your password",
+                        type="password"
+                    )
+                    login_msg = gr.Textbox(
+                        label="Status",
+                        interactive=False,
+                        visible=False
+                    )
+                    
+                    login_btn = gr.Button("🔓 Login", variant="primary", size="lg")
+                    
+                    # Success notification
+                    login_popup = gr.HTML(
+                        value="",
+                        visible=False
+                    )
+                    
+                    gr.Markdown("---")
+                    gr.Markdown("""
+                    **📌 Demo Account Available:**
+                    - Email: `demo@example.com`
+                    - Password: `password123`
+                    
+                    Or create a new account in the Sign Up tab!
+                    """)
+            
+            # SIGNUP TAB
+            with gr.TabItem("📝 Sign Up"):
+                gr.Markdown("#### Create a New Account")
+                
+                with gr.Column():
+                    signup_username = gr.Textbox(
+                        label="Username",
+                        placeholder="Choose a username",
+                        type="text"
+                    )
+                    signup_email = gr.Textbox(
+                        label="Email",
+                        placeholder="Enter your email",
+                        type="text"
+                    )
+                    signup_password = gr.Textbox(
+                        label="Password",
+                        placeholder="Create a password (min 6 chars)",
+                        type="password"
+                    )
+                    signup_confirm = gr.Textbox(
+                        label="Confirm Password",
+                        placeholder="Confirm your password",
+                        type="password"
+                    )
+                    signup_msg = gr.Textbox(
+                        label="✅ Status",
+                        interactive=False,
+                        visible=False
+                    )
+                    
+                    signup_btn = gr.Button("✍️ Sign Up", variant="primary", size="lg")
+                    
+                    # Success notification
+                    success_popup = gr.HTML(
+                        value="",
+                        visible=False
+                    )
+    
+    # CHAT SECTION (shown when logged in)
+    with gr.Group(visible=False) as chat_section:
+        # User info bar
+        with gr.Row():
+            with gr.Column(scale=4):
+                gr.Markdown("### 💬 Chat Interface")
+            with gr.Column(scale=1):
+                current_user_display = gr.Textbox(
+                    label="👤 Logged In As",
+                    value=get_current_username(),
+                    interactive=False
+                )
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                chatbot_ui = gr.Chatbot(
+                    label="💬 Chat History",
+                    height=500,
+                    show_label=True
+                )
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### ⚙️ Settings")
+                
+                mode = gr.Radio(
+                    choices=["general", "technical", "creative", "educational", "medical"],
+                    value="general",
+                    label="Chat Mode",
+                    info="Select conversation style"
+                )
+                
+                temperature = gr.Slider(
+                    minimum=0,
+                    maximum=2,
+                    value=0.7,
+                    step=0.1,
+                    label="Creativity",
+                    info="Higher = more creative, Lower = focused"
+                )
+        
+        with gr.Row():
+            msg_input = gr.Textbox(
+                placeholder="Type your message here...",
+                label="Your Message",
+                lines=2
+            )
+        
+        with gr.Row():
+            send_btn = gr.Button("✉️ Send", variant="primary", scale=2)
+            clear_btn = gr.Button("🗑️ Clear Chat", scale=1)
+            export_btn = gr.Button("📥 Export", scale=1)
+            logout_btn = gr.Button("🚪 Logout", variant="stop", scale=1)
+        
+        export_output = gr.Textbox(
+            label="📋 Exported Chat (JSON)",
+            interactive=False,
+            visible=False
+        )
+        
+        gr.Markdown("""
+        ### 📝 Chat Modes:
+        - **General**: Everyday questions and assistance
+        - **Technical**: Code help and tech support
+        - **Creative**: Storytelling and creative writing
+        - **Educational**: Learning and explanations
+        - **Medical**: Health information
+        """)
+    
+    # === EVENT HANDLERS ===
+    
+    # Login handler
+    def handle_login(email: str, password: str):
+        success, message, user = auth_system.login(email, password)
+        if success:
+            current_user["logged_in"] = True
+            current_user["user_data"] = user
+            username = user['username'] if user else ""
+            success_html = f'<div style="background-color: #ccffcc; border: 2px solid #00cc00; padding: 15px; border-radius: 5px; color: #009900; font-weight: bold; text-align: center; font-size: 18px;">✅ {message}<br><small>Redirecting to chat...</small></div>'
+            return (
+                success_html,
+                gr.update(visible=False),  # Hide auth section
+                gr.update(visible=True),   # Show chat section
+                username
+            )
+        else:
+            error_html = f'<div style="background-color: #ffcccc; border: 2px solid #ff0000; padding: 15px; border-radius: 5px; color: #cc0000; font-weight: bold;">❌ {message}</div>'
+            return error_html, gr.update(visible=True), gr.update(visible=False), ""
+    
+    # Signup handler
+    def handle_signup(username: str, email: str, password: str, confirm_password: str):
+        if not password or password != confirm_password:
+            error_html = '<div style="background-color: #ffcccc; border: 2px solid #ff0000; padding: 15px; border-radius: 5px; color: #cc0000; font-weight: bold;">❌ Passwords do not match!</div>'
+            return "❌ Passwords do not match!", error_html, gr.update(visible=True)
+        
+        success, message = auth_system.signup(username, email, password)
+        if success:
+            success_html = f'<div style="background-color: #ccffcc; border: 2px solid #00cc00; padding: 15px; border-radius: 5px; color: #009900; font-weight: bold; text-align: center; font-size: 18px;">✅ {message}<br><small>You can now login with your email and password</small></div>'
+            return message, success_html, gr.update(visible=True)
+        else:
+            error_html = f'<div style="background-color: #ffcccc; border: 2px solid #ff0000; padding: 15px; border-radius: 5px; color: #cc0000; font-weight: bold;">❌ {message}</div>'
+            return message, error_html, gr.update(visible=True)
+    
+    # Logout handler
+    def handle_logout():
+        current_user["logged_in"] = False
+        current_user["user_data"] = None
+        chatbot.conversation_history = []
+        return (
+            gr.update(visible=True),   # Show auth section
+            gr.update(visible=False),  # Hide chat section
+            "",                         # Clear message
+            [],                         # Clear chat history
+        )
+    
+    # Login click event
+    login_btn.click(
+        handle_login,
+        inputs=[login_email, login_password],
+        outputs=[login_popup, auth_section, chat_section, current_user_display]
+    )
+    
+    # Signup click event
+    signup_btn.click(
+        handle_signup,
+        inputs=[signup_username, signup_email, signup_password, signup_confirm],
+        outputs=[signup_msg, success_popup, success_popup]
+    )
+    
+    # Chat send button
+    send_btn.click(
+        respond_authenticated,
+        inputs=[msg_input, chatbot_ui, mode, temperature],
+        outputs=[msg_input, chatbot_ui]
+    )
+    
+    # Chat input submit (Enter key)
+    msg_input.submit(
+        respond_authenticated,
+        inputs=[msg_input, chatbot_ui, mode, temperature],
+        outputs=[msg_input, chatbot_ui]
+    )
+    
+    # Clear chat
+    clear_btn.click(
+        clear_history,
+        outputs=[chatbot_ui, msg_input]
+    )
+    
+    # Export chat
+    def get_and_show_export(chat_history):
+        return export_chat(chat_history), gr.update(visible=True)
+    
+    export_btn.click(
+        get_and_show_export,
+        inputs=[chatbot_ui],
+        outputs=[export_output, export_output]
+    )
+    
+    # Logout
+    logout_btn.click(
+        handle_logout,
+        outputs=[auth_section, chat_section, login_popup, chatbot_ui]
+    )
+
+# Main application logic
+if __name__ == "__main__":
+    """
+    Start the Gradio application
+    - Authentication page (Login/Sign Up) appears first
+    - After successful login, chat interface opens automatically
+    - Logout returns to authentication
+    """
+    print("🚀 Starting Nexus ChatBot Application...")
+    print("📍 Opening Authentication Page...")
+    print("\n💡 Demo Account for Testing:")
+    print("   Email: demo@example.com")
+    print("   Password: password123")
+    print("\n✨ Features:")
+    print("   • Secure login and registration")
+    print("   • Multiple chat modes (general, technical, creative, educational, medical)")
+    print("   • Export conversations")
+    print("   • Powered by Google's Gemini AI")
+    
+    demo.launch(share=False)

requirements.txt

@@ -0,0 +1,5 @@
+gradio==4.36.0
+google-generativeai==0.3.0
+requests==2.31.0
+tinydb==4.8.0
+bcrypt==4.1.1

users_db.json

@@ -0,0 +1 @@
+{"_default": {"1": {"username": "Demo User", "email": "demo@example.com", "password": "$2b$12$Al4KJljFpNXQtUsUmrNZpewDir/UOZvRav4xvpateTTGNrBqS7eFC", "phone": "", "created_at": "2026-02-12T22:17:46.607542", "last_login": null}, "2": {"username": "vamshi.namani", "email": "vamshi.namani@gmail.com", "password": "$2b$12$..QroxmItC2dFZLtGnK4IegNmsj5Q1W.UP2Hqq9tc2lM3VxJoJKhi", "phone": "", "created_at": "2026-02-12T22:18:17.378345", "last_login": "2026-02-12T22:18:50.741228"}, "3": {"username": "vamshi.namani1@gmail.com", "email": "vamshi.namani1@gmail.com", "password": "$2b$12$xfUJOu0lXG2T6wGt8qqDC.x4B6ygdfDXWcLncwDIJEoDMUtQfr1Mu", "phone": "", "created_at": "2026-02-12T22:22:01.302731", "last_login": "2026-02-12T22:23:01.029272"}}}