Update app.py

app.py

@@ -1,10 +1,6 @@
 import streamlit as st
-import requests
-import os
-import toml
-import pathlib
-import json
-import time
+import re
+import random
 
 # Page configuration
 st.set_page_config(
@@ -13,83 +9,10 @@ st.set_page_config(
     layout="centered"
 )
 
-# Try to load secrets from .streamlit/secrets.toml
-def load_secrets():
-    try:
-        # First, try streamlit's built-in secrets
-        if hasattr(st, 'secrets'):
-            try:
-                return st.secrets.get("HF_API_TOKEN", "")
-            except:
-                pass
-                
-        # Second, try to find secrets.toml in the .streamlit directory
-        secrets_path = pathlib.Path(".streamlit/secrets.toml")
-        if secrets_path.exists():
-            secrets = toml.load(secrets_path)
-            return secrets.get("HF_API_TOKEN", "")
-        
-        # Third, check in user's home directory
-        home_secrets_path = pathlib.Path.home() / ".streamlit/secrets.toml"
-        if home_secrets_path.exists():
-            secrets = toml.load(home_secrets_path)
-            return secrets.get("HF_API_TOKEN", "")
-            
-        # Last, check environment variables
-        return os.environ.get("HF_API_TOKEN", "")
-    except Exception as e:
-        st.sidebar.error(f"Error loading secrets: {e}")
-        return ""
-
-# Model selection
-MODEL_OPTIONS = {
-    "Llama-3-8B-Instruct": "meta-llama/Meta-Llama-3-8B-Instruct",  # More up-to-date model
-    "Llama-2-7B-Chat": "meta-llama/Llama-2-7b-chat-hf",
-    "Mistral-7B-Instruct": "mistralai/Mistral-7B-Instruct-v0.2",
-    "Falcon-7B-Instruct": "tiiuae/falcon-7b-instruct",
-    "OpenAssistant": "OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
-    "Flan-T5-Large": "google/flan-t5-large",  # Open access model
-    "GPT2": "gpt2",  # Fully open model
-    "Rule-Based (No API)": "local"  # Completely local option
-}
-
-# Allow model selection and initialize with default
-if "selected_model" not in st.session_state:
-    st.session_state.selected_model = "Rule-Based (No API)"  # Default to local option for reliability
-
-# Hugging Face API setup
-def get_api_url():
-    model_id = MODEL_OPTIONS[st.session_state.selected_model]
-    return f"https://api-inference.huggingface.co/models/{model_id}"
-
-API_TOKEN = load_secrets()
-headers = {"Authorization": f"Bearer {API_TOKEN}"}
-
-# Show warning if no API token is provided
-if not API_TOKEN:
-    st.sidebar.warning("⚠️ No API token found. Using fallback responses. Add your API token in environment variables or create a .streamlit/secrets.toml file.")
-else:
-    st.sidebar.success("✅ API token loaded successfully")
-
-# Customer support context and guidelines
-SYSTEM_PROMPT = """You are an AI-powered customer support assistant integrated into a company website. 
-Your role is to assist customers by responding accurately, politely, and efficiently to their inquiries about 
-the company's products, services, policies, and general information.
-
-Rules:
-- Answer questions in a professional yet friendly tone
-- Ask for clarification if the user's question is ambiguous
-- Direct users to relevant resources when needed
-- Be available 24/7 and never mention that you're an AI unless explicitly asked
-- Avoid hallucinating facts - if you don't know something, politely let the user know and offer to connect them with a human representative
-- Keep responses concise and to the point
-
-Example questions you should be able to handle:
-- "I need help tracking my order"
-- "What is your return policy?"
-- "I'm having trouble logging into my account"
-- "Can I cancel my subscription anytime?"
-- "Do you offer support on weekends?"
+# Customer support context 
+SYSTEM_INFO = """
+This is a customer support assistant that helps with common inquiries about products, services,
+policies, and general information. It provides accurate and helpful responses to assist customers.
 """
 
 # Sample company information and policies
@@ -99,241 +22,166 @@ COMPANY_INFO = {
     "account_issues": "For account login issues, try resetting your password. If problems persist, please provide your email address so we can investigate.",
     "subscription": "Yes, you can cancel your subscription at any time through your account settings. There are no cancellation fees.",
     "support_hours": "Our customer support team is available 24/7 via this chat. For phone support, our hours are 9 AM - 8 PM Monday through Friday, and 10 AM - 6 PM on weekends.",
-    "contact": "For complex issues, you can reach our human support team at support@example.com or call 1-800-123-4567."
+    "contact": "For complex issues, you can reach our human support team at support@example.com or call 1-800-123-4567.",
+    "shipping": "Standard shipping takes 3-5 business days. Express shipping takes 1-2 business days. International shipping may take 7-14 business days.",
+    "payment": "We accept all major credit cards, PayPal, and Apple Pay. Payment information is securely processed and encrypted.",
+    "refund": "Refunds are processed within 5-7 business days of receiving your returned item. The refund will be issued to the original payment method.",
+    "warranty": "Our products come with a standard 1-year warranty that covers manufacturing defects. Extended warranties are available for purchase."
 }
 
-# Fallback responses for common queries when API is not available
-FALLBACK_RESPONSES = {
-    "greeting": "Hello! Welcome to our customer support. How can I assist you today?",
-    "return": f"Our return policy allows returns within 30 days of purchase with original receipt. Items must be unused and in original packaging.",
-    "track": "You can track your order by logging into your account or using the tracking number provided in your confirmation email.",
-    "login": "For account login issues, try resetting your password. If problems persist, please provide your email address so we can investigate.",
-    "subscription": "Yes, you can cancel your subscription at any time through your account settings. There are no cancellation fees.",
-    "hours": "Our customer support team is available 24/7 via this chat. For phone support, our hours are 9 AM - 8 PM Monday through Friday, and 10 AM - 6 PM on weekends.",
-    "contact": "For complex issues, you can reach our human support team at support@example.com or call 1-800-123-4567.",
-    "default": "Thank you for your inquiry. I'd be happy to help with that. Could you please provide more details so I can assist you better?"
+# Response templates with variations for more natural conversation
+RESPONSE_TEMPLATES = {
+    "greeting": [
+        "Hello! Welcome to our customer support. How can I assist you today?",
+        "Hi there! I'm here to help with any questions you might have. What can I do for you?",
+        "Welcome! How may I assist you with our products or services today?"
+    ],
+    "thanks": [
+        "You're welcome! Is there anything else I can help you with?",
+        "Happy to help! Do you have any other questions I can assist with?",
+        "My pleasure! Is there something else you'd like to know?"
+    ],
+    "goodbye": [
+        "Thank you for contacting our support. Have a great day!",
+        "I appreciate your time today. If you need anything else, don't hesitate to reach out!",
+        "Thanks for chatting with us. Feel free to return if you have any other questions!"
+    ],
+    "unclear": [
+        "I'm not sure I understand your question. Could you please provide more details?",
+        "I'd like to help, but I need a bit more information. Could you clarify what you're asking about?",
+        "I'm sorry, but I don't have enough information to answer that. Could you be more specific?"
+    ],
+    "human": [
+        f"I understand you'd like to speak with a human representative. {COMPANY_INFO['contact']}",
+        f"For more complex issues, our human support team is available. {COMPANY_INFO['contact']}",
+        f"I'd be happy to connect you with one of our human agents. {COMPANY_INFO['contact']}"
+    ]
 }
 
-def format_prompt(user_input, history):
-    """Format the prompt for the selected model"""
-    if st.session_state.selected_model in ["Llama-3-8B-Instruct", "Llama-2-7B-Chat"]:
-        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-        
-        # Add chat history
-        for user_msg, bot_msg in history:
-            messages.append({"role": "user", "content": user_msg})
-            messages.append({"role": "assistant", "content": bot_msg})
-        
-        # Add current user message
-        messages.append({"role": "user", "content": user_input})
-        
-        return {"inputs": messages}
-    elif st.session_state.selected_model == "Flan-T5-Large":
-        # Special format for Flan-T5
-        # Flan-T5 works better with direct questions/instructions
-        prompt = f"Answer this customer support question in a helpful way: {user_input}"
-        return {"inputs": prompt}
-    elif st.session_state.selected_model == "GPT2":
-        # Special format for GPT2
-        prompt = f"Customer: {user_input}\nSupport agent:"
-        return {"inputs": prompt}
-    else:
-        # For other models that use text completion format
-        prompt = SYSTEM_PROMPT + "\n\n"
-        for user_msg, bot_msg in history:
-            prompt += f"User: {user_msg}\nAssistant: {bot_msg}\n\n"
-        prompt += f"User: {user_input}\nAssistant:"
-        
-        return {"inputs": prompt}
+# Patterns for matching different types of queries
+PATTERNS = {
+    "greeting": r"\b(hi|hello|hey|good morning|good afternoon|good evening)\b",
+    "thanks": r"\b(thanks|thank you|appreciate it)\b",
+    "goodbye": r"\b(bye|goodbye|see you|farewell)\b",
+    "return_policy": r"\b(return|return policy|send back|give back|exchange|bring back|refund policy)\b",
+    "tracking": r"\b(track|track order|tracking|shipping status|where is|delivery status|package|when.*arrive|where.*order)\b",
+    "account": r"\b(account|log in|login|sign in|password|forgot password|reset password|username|can\'?t log in|trouble logging in)\b",
+    "subscription": r"\b(subscription|cancel|cancellation|unsubscribe|stop.*subscription|end.*subscription|pause)\b",
+    "hours": r"\b(hours|time|availability|when are you|schedule|open|closed|available|support hours|customer service hours)\b",
+    "human": r"\b(human|person|agent|representative|speak to someone|talk to someone|real person|live agent|customer service rep)\b",
+    "shipping": r"\b(shipping|delivery|ship|deliver|how long|how soon|when will it arrive|shipping time|delivery time|express shipping)\b",
+    "payment": r"\b(payment|pay|credit card|debit card|paypal|apple pay|billing|payment method|transaction|purchase|buying)\b",
+    "refund": r"\b(refund|money back|reimburse|reimbursement|get.*money back|return.*money|credit back|refund process)\b",
+    "warranty": r"\b(warranty|guarantee|broken|defective|repair|fix|not working|doesn\'?t work|stopped working|damaged|replacement)\b"
+}
 
-def query_huggingface_api(payload, user_input):
-    """Send request to Hugging Face API with retry logic"""
-    api_url = get_api_url()
-    max_retries = 3
-    retry_delay = 2
+def get_response(user_input):
+    """Generate a response based on the user's input"""
+    if not user_input or user_input.strip() == "":
+        return "Hello! How can I help you today? Feel free to ask about our return policy, shipping, account help, or any other questions."
     
-    # Try alternative TGI API endpoint if selected
-    use_tgi_api = False
-    if "use_tgi_api" in st.session_state and st.session_state.use_tgi_api:
-        use_tgi_api = True
-        # The TGI API has a different format
-        if st.session_state.selected_model in ["Llama-3-8B-Instruct", "Llama-2-7B-Chat", "Mistral-7B-Instruct"]:
-            # Extract just the messages for chat models
-            if "inputs" in payload and isinstance(payload["inputs"], list):
-                tgi_payload = {
-                    "inputs": payload["inputs"][-1]["content"],
-                    "parameters": {
-                        "max_new_tokens": 256,
-                        "temperature": 0.7,
-                        "top_p": 0.95,
-                        "do_sample": True
-                    }
-                }
-                payload = tgi_payload
-                api_url = f"https://api-inference.huggingface.co/models/{MODEL_OPTIONS[st.session_state.selected_model]}"
+    # Convert input to lowercase for easier matching
+    input_lower = user_input.lower()
     
-    original_payload = payload.copy()
-    tried_simple_string = False
+    # Check for greetings, thanks, or goodbyes first
+    if re.search(PATTERNS["greeting"], input_lower):
+        return random.choice(RESPONSE_TEMPLATES["greeting"])
     
-    for attempt in range(max_retries):
-        try:
-            response = requests.post(api_url, headers=headers, json=payload, timeout=90)
-            
-            # Check if model is still loading
-            if response.status_code == 503:
-                st.warning(f"Model is loading. Retrying in {retry_delay} seconds... (Attempt {attempt+1}/{max_retries})")
-                time.sleep(retry_delay)
-                retry_delay *= 2  # Exponential backoff
-                continue
-            
-            # Handle 422 errors specifically - try simplifying the input format
-            if response.status_code == 422 and not tried_simple_string:
-                st.warning("Model expecting different input format. Trying simpler format...")
-                # Convert to simple string input
-                if isinstance(payload["inputs"], dict) or isinstance(payload["inputs"], list):
-                    # Extract just the user's query for simplicity
-                    payload = {"inputs": user_input}
-                    tried_simple_string = True
-                    continue
-                    
-            # Handle other errors
-            if response.status_code != 200:
-                st.error(f"API error: {response.status_code} - {response.text}")
-                return {"error": f"API error: {response.status_code} - {response.text}"}
-                
-            return response.json()
-            
-        except Exception as e:
-            st.error(f"Error querying API (attempt {attempt+1}/{max_retries}): {e}")
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay)
-                retry_delay *= 2
-            else:
-                return {"error": str(e)}
-
-def extract_response(api_response):
-    """Extract the response text from different model response formats"""
-    try:
-        if "debug_mode" in st.session_state and st.session_state.debug_mode:
-            st.sidebar.subheader("Raw Response:")
-            st.sidebar.json(api_response)
-            
-        # Handle list format responses
-        if isinstance(api_response, list):
-            if len(api_response) > 0:
-                # Standard response format for some models
-                if "generated_text" in api_response[0]:
-                    return api_response[0]["generated_text"]
-                # TGI API direct text response
-                elif isinstance(api_response[0], str):
-                    return api_response[0]
-                
-        # Handle dictionary format responses
-        if isinstance(api_response, dict):
-            # For text generation models
-            if "generated_text" in api_response:
-                return api_response["generated_text"]
-            
-            # For simple string response in a dict
-            if "text" in api_response:
-                return api_response["text"]
-                
-            # For chat models that return as list array
-            if "conversation" in api_response:
-                return api_response["conversation"]["messages"][-1]["content"]
-                
-            # For Llama-3/Mistral chat format
-            if "outputs" in api_response and len(api_response["outputs"]) > 0:
-                return api_response["outputs"][0]["text"]
-                
-        # Fallback: attempt to extract any text or return the response as string
-        if isinstance(api_response, str):
-            return api_response
-            
-        return str(api_response)
-        
-    except Exception as e:
-        st.error(f"Error extracting response: {e}")
-        return None
-
-def get_fallback_response(user_input):
-    """Get a fallback response based on keywords in the user input"""
-    lower_input = user_input.lower()
+    if re.search(PATTERNS["thanks"], input_lower):
+        return random.choice(RESPONSE_TEMPLATES["thanks"])
     
-    if any(word in lower_input for word in ["hi", "hello", "hey"]):
-        return FALLBACK_RESPONSES["greeting"]
-    elif "return" in lower_input:
-        return FALLBACK_RESPONSES["return"]
-    elif any(word in lower_input for word in ["track", "order", "package", "shipping"]):
-        return FALLBACK_RESPONSES["track"]
-    elif any(word in lower_input for word in ["login", "sign in", "account", "password"]):
-        return FALLBACK_RESPONSES["login"]
-    elif "subscription" in lower_input:
-        return FALLBACK_RESPONSES["subscription"]
-    elif any(word in lower_input for word in ["hours", "available", "weekend"]):
-        return FALLBACK_RESPONSES["hours"]
-    elif any(word in lower_input for word in ["human", "person", "agent", "representative"]):
-        return FALLBACK_RESPONSES["contact"]
-    else:
-        return FALLBACK_RESPONSES["default"]
-
-def get_response(user_input, history):
-    """Get response from the LLM via Hugging Face API or fall back to simple responses"""
-    # Use rule-based responses if selected or if API token is missing
-    if st.session_state.selected_model == "Rule-Based (No API)" or not API_TOKEN:
-        return get_fallback_response(user_input)
+    if re.search(PATTERNS["goodbye"], input_lower):
+        return random.choice(RESPONSE_TEMPLATES["goodbye"])
     
-    # Format the messages for the API based on selected model
-    payload = format_prompt(user_input, history)
+    # Store all matching responses and pick the most relevant
+    matched_responses = []
     
-    # Query the API
-    api_response = query_huggingface_api(payload, user_input)
+    # Check for specific product/policy queries
+    if re.search(PATTERNS["return_policy"], input_lower):
+        matched_responses.append(f"Here's our return policy: {COMPANY_INFO['return_policy']}")
     
-    # Debug mode: show raw API response
-    if "debug_mode" in st.session_state and st.session_state.debug_mode:
-        st.sidebar.json(api_response)
+    if re.search(PATTERNS["tracking"], input_lower):
+        matched_responses.append(f"To track your order: {COMPANY_INFO['tracking_order']}")
     
-    # Extract the assistant's response
-    if api_response and "error" not in api_response:
-        assistant_response = extract_response(api_response)
-        if assistant_response:
-            return assistant_response
+    if re.search(PATTERNS["account"], input_lower):
+        matched_responses.append(f"For account-related issues: {COMPANY_INFO['account_issues']}")
     
-    # Fall back to keyword-based responses if API fails
-    return get_fallback_response(user_input)
-
-def enhance_response(user_input, base_response):
-    """Enhance response with specific company information"""
-    lower_input = user_input.lower()
+    if re.search(PATTERNS["subscription"], input_lower):
+        matched_responses.append(f"Regarding subscriptions: {COMPANY_INFO['subscription']}")
+    
+    if re.search(PATTERNS["hours"], input_lower):
+        matched_responses.append(f"Our support hours are: {COMPANY_INFO['support_hours']}")
     
-    if "return policy" in lower_input:
-        base_response += f"\n\nHere's our specific return policy: {COMPANY_INFO['return_policy']}"
-    elif "track" in lower_input and ("order" in lower_input or "package" in lower_input):
-        base_response += f"\n\n{COMPANY_INFO['tracking_order']}"
-    elif ("login" in lower_input or "logging in" in lower_input or "account" in lower_input) and ("trouble" in lower_input or "problem" in lower_input or "can't" in lower_input):
-        base_response += f"\n\n{COMPANY_INFO['account_issues']}"
-    elif "cancel" in lower_input and "subscription" in lower_input:
-        base_response += f"\n\n{COMPANY_INFO['subscription']}"
-    elif "weekend" in lower_input and "support" in lower_input:
-        base_response += f"\n\n{COMPANY_INFO['support_hours']}"
-    elif "human" in lower_input or "representative" in lower_input or "agent" in lower_input or "person" in lower_input:
-        base_response += f"\n\n{COMPANY_INFO['contact']}"
+    if re.search(PATTERNS["shipping"], input_lower):
+        matched_responses.append(f"Shipping information: {COMPANY_INFO['shipping']}")
     
-    return base_response
+    if re.search(PATTERNS["payment"], input_lower):
+        matched_responses.append(f"Payment methods: {COMPANY_INFO['payment']}")
+    
+    if re.search(PATTERNS["refund"], input_lower):
+        matched_responses.append(f"Our refund process: {COMPANY_INFO['refund']}")
+    
+    if re.search(PATTERNS["warranty"], input_lower):
+        matched_responses.append(f"Warranty information: {COMPANY_INFO['warranty']}")
+    
+    if re.search(PATTERNS["human"], input_lower):
+        matched_responses.append(random.choice(RESPONSE_TEMPLATES["human"]))
+    
+    # Return a matched response if any were found
+    if matched_responses:
+        return matched_responses[0]
+    
+    # Try broader keyword matching if no specific pattern matched
+    for key, info in COMPANY_INFO.items():
+        keywords = key.replace("_", " ").split()
+        for word in keywords:
+            if word in input_lower and len(word) > 3:  # Only match significant words
+                return f"Regarding {key.replace('_', ' ')}: {info}"
+    
+    # Check if asking a general question
+    if any(q in input_lower for q in ["what", "how", "when", "where", "why", "who", "can", "do", "is", "are"]):
+        general_response = "Based on your question, you might be interested in one of these topics:\n"
+        general_response += "• Return policy\n• Order tracking\n• Account issues\n• Subscriptions\n"
+        general_response += "• Support hours\n• Shipping information\n• Payment methods\n• Refunds\n• Warranty"
+        return general_response
+    
+    # If no specific pattern is matched, respond with a general answer or ask for clarification
+    return random.choice(RESPONSE_TEMPLATES["unclear"])
 
 # App title and intro
 st.title("Customer Support Assistant")
 st.markdown("Welcome to our customer support chat! How can I help you today?")
 
-# Initialize session state for chat history and API token
+# Initialize session state for chat history
 if "chat_history" not in st.session_state:
     st.session_state.chat_history = []
+
+# Sidebar with information and options
+with st.sidebar:
+    st.title("Customer Support")
     
-if "api_token" not in st.session_state:
-    st.session_state.api_token = API_TOKEN
+    st.markdown("### About")
+    st.info(SYSTEM_INFO)
+    
+    if st.button("Clear Conversation"):
+        st.session_state.chat_history = []
+        st.rerun()
     
-if "debug_mode" not in st.session_state:
-    st.session_state.debug_mode = False
+    # Company info quick links
+    st.markdown("---")
+    st.markdown("### Quick Information")
+    
+    if st.button("Return Policy"):
+        st.info(COMPANY_INFO["return_policy"])
+    
+    if st.button("Shipping Info"):
+        st.info(COMPANY_INFO["shipping"])
+    
+    if st.button("Support Hours"):
+        st.info(COMPANY_INFO["support_hours"])
+    
+    if st.button("Contact Information"):
+        st.info(COMPANY_INFO["contact"])
 
 # Display chat history
 for user_msg, bot_msg in st.session_state.chat_history:
@@ -350,103 +198,11 @@ if user_input:
     with st.chat_message("user"):
         st.write(user_input)
     
-    # Get bot response with a spinner
+    # Get bot response
     with st.chat_message("assistant", avatar="🧑‍💼"):
-        with st.spinner(f"Thinking using {st.session_state.selected_model}..."):
-            try:
-                base_response = get_response(user_input, st.session_state.chat_history)
-                bot_response = enhance_response(user_input, base_response)
-                st.write(bot_response)
-                # Add to chat history
-                st.session_state.chat_history.append((user_input, bot_response))
-            except Exception as e:
-                st.error(f"Sorry, I encountered an error processing your request: {str(e)}")
-
-# Sidebar options
-with st.sidebar:
-    st.title("Options")
-    
-    # Model selection
-    st.markdown("---")
-    st.markdown("### Model Settings")
-    selected_model = st.selectbox(
-        "Select AI Model",
-        list(MODEL_OPTIONS.keys()),
-        index=list(MODEL_OPTIONS.keys()).index(st.session_state.selected_model)
-    )
-    
-    if selected_model != st.session_state.selected_model:
-        st.session_state.selected_model = selected_model
-        st.success(f"Model changed to {selected_model}")
-    
-    # API mode toggle
-    st.checkbox("Use TGI API (try if regular API fails)", key="use_tgi_api", 
-                help="Use Text Generation Inference API format which works better for some models")
-    
-    # API token input
-    st.markdown("---")
-    st.markdown("### API Settings")
-    manually_entered_token = st.text_input("Enter Hugging Face API Token", type="password", help="Your API token will not be stored permanently")
-    if manually_entered_token:
-        st.session_state.api_token = manually_entered_token
-        API_TOKEN = manually_entered_token
-        headers = {"Authorization": f"Bearer {API_TOKEN}"}
-        st.success("✅ API Token set for this session")
-
-    # Test API button
-    if st.button("Test API Connection"):
-        with st.spinner("Testing API connection..."):
-            test_model = "gpt2"  # Use a simple model that everyone has access to
-            test_url = f"https://api-inference.huggingface.co/models/{test_model}"
-            test_payload = {"inputs": "Hello, I'm testing the API connection."}
-            try:
-                response = requests.post(test_url, headers=headers, json=test_payload, timeout=10)
-                if response.status_code == 200:
-                    st.success("✅ API connection successful! Your token is working correctly.")
-                    # Update the API token in session
-                    if not API_TOKEN:
-                        st.session_state.api_token = manually_entered_token
-                        API_TOKEN = manually_entered_token
-                        headers = {"Authorization": f"Bearer {API_TOKEN}"}
-                else:
-                    st.error(f"❌ API Error: {response.status_code} - {response.text}")
-                    st.info("Please check your API token and try again. Make sure you're using a valid Hugging Face API token.")
-            except Exception as e:
-                st.error(f"❌ Connection Error: {str(e)}")
-                st.info("Please check your internet connection and try again.")
-    
-    # Debug toggle
-    st.checkbox("Debug Mode", key="debug_mode", help="Show raw API responses in the sidebar")
-    
-    if st.button("Clear Conversation"):
-        st.session_state.chat_history = []
-        st.experimental_rerun()
-    
-    # API status indicator
-    st.markdown("---")
-    if API_TOKEN:
-        st.success("✅ API Connected")
-        st.info(f"Using model: {st.session_state.selected_model}")
-    else:
-        st.error("❌ API Not Connected")
-        st.info("Add your Hugging Face API token in the field above, in environment variables, or create a .streamlit/secrets.toml file")
-    
-    st.markdown("---")
-    st.markdown("### About")
-    st.markdown("This customer support chatbot is powered by AI and provides assistance for common customer inquiries.")
-    
-    # Company info in sidebar
-    st.markdown("---")
-    st.markdown("### Company Info Quick Links")
+        with st.spinner("Thinking..."):
+            bot_response = get_response(user_input)
+            st.write(bot_response)
     
-    if st.button("Return Policy"):
-        st.info(COMPANY_INFO["return_policy"])
-    
-    if st.button("Order Tracking"):
-        st.info(COMPANY_INFO["tracking_order"])
-    
-    if st.button("Support Hours"):
-        st.info(COMPANY_INFO["support_hours"])
-    
-    if st.button("Contact Information"):
-        st.info(COMPANY_INFO["contact"]) 
+    # Add to chat history
+    st.session_state.chat_history.append((user_input, bot_response))