Update app.py

app.py

@@ -3,7 +3,9 @@ import requests
 import json
 import os
 import re
+import time
 from datetime import datetime
+from functools import lru_cache
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
@@ -43,6 +45,26 @@ except ImportError:
     TAVILY_AVAILABLE = False
     print("Tavily not available: Please install tavily-python")
 
+# Rate limiter class
+class RateLimiter:
+    def __init__(self, max_calls=10, time_window=60):
+        self.max_calls = max_calls
+        self.time_window = time_window
+        self.calls = []
+    
+    def is_allowed(self):
+        now = time.time()
+        self.calls = [call for call in self.calls if now - call < self.time_window]
+        if len(self.calls) < self.max_calls:
+            self.calls.append(now)
+            return True
+        return False
+
+rate_limiter = RateLimiter(max_calls=20, time_window=60)
+
+# Feedback storage
+feedback_data = []
+
 def get_preloaded_context():
     """Get preloaded context information"""
     context = f"""{FORMATTED_DATE_TIME}
@@ -130,6 +152,15 @@ def truncate_history(messages, max_tokens=4000):
     
     return truncated
 
+def manage_conversation_memory(messages, max_turns=10):
+    """Keep conversation focused and prevent context overflow"""
+    if len(messages) > max_turns * 2:  # *2 for user/assistant pairs
+        # Keep system message + last N turns
+        system_msg = [msg for msg in messages if msg.get("role") == "system"]
+        recent_messages = messages[-(max_turns * 2):]
+        return system_msg + recent_messages if system_msg else recent_messages
+    return messages
+
 def perform_search(query):
     """Perform search using Tavily"""
     if TAVILY_AVAILABLE and tavily_client:
@@ -184,6 +215,105 @@ def validate_history(chat_history):
     
     return validated
 
+def generate_follow_up_questions(last_response):
+    """Generate 3-5 relevant follow-up questions"""
+    if not last_response:
+        return []
+    
+    # Simple heuristic-based questions
+    question_words = ["What", "How", "Why", "When", "Where", "Who"]
+    topics = ["related", "similar", "detailed", "practical"]
+    
+    # Extract key topics from response (simplified)
+    words = last_response.split()[:20]  # First 20 words
+    key_topics = [word for word in words if len(word) > 4][:3]  # Simple filtering
+    
+    questions = []
+    for word in question_words[:3]:  # Limit to 3
+        if key_topics:
+            topic = key_topics[0] if key_topics else "this"
+            questions.append(f"{word} about {topic}?")
+    
+    return questions[:3]  # Return max 3 questions
+
+def format_code_blocks(text):
+    """Detect and format code blocks with syntax highlighting"""
+    import re
+    # Simple pattern to detect code blocks
+    pattern = r'```(\w+)?\n(.*?)```'
+    # Replace with HTML formatted code (simplified)
+    formatted = re.sub(pattern, r'<pre><code class="language-\1">\2</code></pre>', text, flags=re.DOTALL)
+    return formatted
+
+def extract_and_format_citations(search_results):
+    """Extract sources and create clickable citations"""
+    # Simple citation extraction (can be enhanced)
+    citations = []
+    if "Source:" in search_results:
+        lines = search_results.split('\n')
+        for line in lines:
+            if "http" in line:
+                citations.append(line.strip())
+    return citations
+
+def track_usage(user_id, query, response_time, tokens_used):
+    """Track usage metrics for improvement"""
+    metrics = {
+        "timestamp": datetime.now().isoformat(),
+        "user_id": user_id or "anonymous",
+        "query_length": len(query),
+        "response_time": response_time,
+        "tokens_used": tokens_used
+    }
+    # In a real app, you'd store this in a database
+    print(f"Usage tracked: {metrics}")
+    return metrics
+
+def collect_feedback(feedback, query, response):
+    """Collect user feedback for model improvement"""
+    feedback_entry = {
+        "timestamp": datetime.now().isoformat(),
+        "feedback": feedback,
+        "query": query,
+        "response": response[:100] + "..." if len(response) > 100 else response
+    }
+    feedback_data.append(feedback_entry)
+    print(f"Feedback collected: {feedback_entry}")
+    return f"Thank you for your feedback: {feedback}"
+
+@lru_cache(maxsize=100)
+def cached_search(query):
+    """Cache frequent searches"""
+    return perform_search(query)
+
+def handle_api_failure(error_type, fallback_strategy="retry"):
+    """Handle different types of API failures gracefully"""
+    # Simplified error handling
+    return f"API Error: {error_type}. Strategy: {fallback_strategy}"
+
+def export_conversation(chat_history, export_format):
+    """Export conversation in various formats"""
+    if not chat_history:
+        return "No conversation to export"
+        
+    if export_format == "JSON":
+        # Filter out system messages for export
+        exportable_history = [msg for msg in chat_history if msg.get("role") != "system"]
+        return json.dumps(exportable_history, indent=2, ensure_ascii=False)
+    elif export_format == "Text":
+        lines = []
+        for msg in chat_history:
+            if msg.get("role") != "system":  # Skip system messages
+                lines.append(f"{msg.get('role', 'unknown').upper()}: {msg.get('content', '')}")
+        return "\n".join(lines)
+    return "Invalid format"
+
+def is_news_related_query(query):
+    """Check if query is related to news"""
+    news_keywords = ['news', 'headline', 'breaking', 'latest', 'today', 'current event', 'update', 'report']
+    query_lower = query.lower()
+    return any(word in query_lower for word in news_keywords)
+
 def generate_with_streaming(messages, model, max_tokens=8192, temperature=0.7, top_p=0.9):
     """Generate text with streaming"""
     headers = {
@@ -203,6 +333,7 @@ def generate_with_streaming(messages, model, max_tokens=8192, temperature=0.7, t
         "stream": True
     }
     
+    start_time = time.time()
     try:
         response = session.post(
             f"{BASE_URL}chat/completions",
@@ -235,17 +366,22 @@ def generate_with_streaming(messages, model, max_tokens=8192, temperature=0.7, t
             
     except Exception as e:
         yield f"Connection error: {str(e)}"
+    finally:
+        end_time = time.time()
+        # Track usage (simplified)
+        track_usage("user123", str(messages[-1]) if messages else "", 
+                   end_time - start_time, len(str(messages)))
 
-def is_news_related_query(query):
-    """Check if query is related to news"""
-    news_keywords = ['news', 'headline', 'breaking', 'latest', 'today', 'current event', 'update', 'report']
-    query_lower = query.lower()
-    return any(word in query_lower for word in news_keywords)
-
-def respond(message, chat_history, model_choice, max_tokens, temperature, top_p, creativity, precision, system_prompt, use_web_search):
+def respond(message, chat_history, model_choice, max_tokens, temperature, top_p, 
+           creativity, precision, system_prompt, use_web_search, theme):
     """Main response handler with conversation history"""
     if not message:
-        yield "", chat_history, ""
+        yield "", chat_history, "", gr.update(choices=[], visible=False)
+        return
+    
+    # Rate limiting check
+    if not rate_limiter.is_allowed():
+        yield "", chat_history + [{"role": "assistant", "content": "Rate limit exceeded. Please wait a moment before sending another message."}], "", ""
         return
     
     # Add custom system prompt or preloaded context
@@ -258,7 +394,7 @@ def respond(message, chat_history, model_choice, max_tokens, temperature, top_p,
         chat_history = [system_message] + chat_history
     
     # Check if the message contains search results that need analysis
-    if "SEARCH RESULTS" in message or "SEARCH RESULTS" in message:
+    if "SEARCH RESULTS" in message or "[SEARCH RESULTS" in message:
         # This is search results that need analysis
         # Extract the original query and search results
         lines = message.split('\n')
@@ -270,7 +406,7 @@ def respond(message, chat_history, model_choice, max_tokens, temperature, top_p,
             else:
                 query = message[:100]  # Fallback
         else:
-            query = "news summary"
+            query = "summary request"
         
         # Perform analysis
         analysis_prompt = analyze_search_results(query, message)
@@ -283,7 +419,9 @@ def respond(message, chat_history, model_choice, max_tokens, temperature, top_p,
         for chunk in generate_with_streaming(analysis_history, model_choice, max_tokens, temperature * creativity, top_p * precision):
             if isinstance(chunk, str):
                 full_response = chunk
-                yield "", chat_history + [{"role": "user", "content": message}, {"role": "assistant", "content": full_response}], message
+                # Generate follow-up questions
+                follow_ups = generate_follow_up_questions(full_response)
+                yield "", chat_history + [{"role": "user", "content": message}, {"role": "assistant", "content": full_response}], message, gr.update(choices=follow_ups, visible=True if follow_ups else False)
         return
     
     # Check if we should perform a search
@@ -319,12 +457,16 @@ def respond(message, chat_history, model_choice, max_tokens, temperature, top_p,
             for chunk in generate_with_streaming(analysis_history, model_choice, max_tokens, temperature * creativity, top_p * precision):
                 if isinstance(chunk, str):
                     full_response = chunk
+                    # Generate follow-up questions
+                    follow_ups = generate_follow_up_questions(full_response)
                     # Stream both the analysis and raw search results
-                    yield "", chat_history + [user_message, {"role": "assistant", "content": search_result}, {"role": "assistant", "content": full_response}], search_results_output
+                    yield "", chat_history + [user_message, {"role": "assistant", "content": search_result}, {"role": "assistant", "content": full_response}], search_results_output, gr.update(choices=follow_ups, visible=True if follow_ups else False)
             return
         else:
             # Non-news search, just return the search results
-            yield "", chat_history + [user_message, {"role": "assistant", "content": search_result}], search_result
+            # Generate follow-up questions
+            follow_ups = generate_follow_up_questions(search_result)
+            yield "", chat_history + [user_message, {"role": "assistant", "content": search_result}], search_result, gr.update(choices=follow_ups, visible=True if follow_ups else False)
             return
     
     # Normal flow - generate response
@@ -338,26 +480,50 @@ def respond(message, chat_history, model_choice, max_tokens, temperature, top_p,
             if is_looping_content(full_response):
                 # Force search instead of looping
                 search_result = perform_search(message)
-                yield "", chat_history + [user_message, {"role": "assistant", "content": f"[LOOP DETECTED - PERFORMING SEARCH]\n{search_result}"}], search_result
+                follow_ups = generate_follow_up_questions(search_result)
+                yield "", chat_history + [user_message, {"role": "assistant", "content": f"[LOOP DETECTED - PERFORMING SEARCH]\n{search_result}"}], search_result, gr.update(choices=follow_ups, visible=True if follow_ups else False)
                 return
             # Stream the response
-            yield "", chat_history + [user_message, {"role": "assistant", "content": full_response}], ""
+            follow_ups = generate_follow_up_questions(full_response)
+            yield "", chat_history + [user_message, {"role": "assistant", "content": full_response}], "", gr.update(choices=follow_ups, visible=True if follow_ups else False)
     
     # Check for tool calls after completion or break loops
     if is_looping_content(full_response):
         # Force search for looping content
         search_result = perform_search(message)
-        yield "", chat_history + [user_message, {"role": "assistant", "content": f"[LOOP DETECTED - PERFORMING SEARCH]\n{search_result}"}], search_result
+        follow_ups = generate_follow_up_questions(search_result)
+        yield "", chat_history + [user_message, {"role": "assistant", "content": f"[LOOP DETECTED - PERFORMING SEARCH]\n{search_result}"}], search_result, gr.update(choices=follow_ups, visible=True if follow_ups else False)
         return
     
     # Normal completion
-    yield "", chat_history + [user_message, {"role": "assistant", "content": full_response}], ""
+    follow_ups = generate_follow_up_questions(full_response)
+    yield "", chat_history + [user_message, {"role": "assistant", "content": full_response}], "", gr.update(choices=follow_ups, visible=True if follow_ups else False)
+
+def apply_theme(theme):
+    """Apply theme-specific CSS"""
+    if theme == "Dark":
+        return """
+        <style>
+        body { background-color: #1a1a1a; color: #ffffff; }
+        .message { background-color: #2d2d2d; }
+        </style>
+        """
+    else:
+        return """
+        <style>
+        body { background-color: #ffffff; color: #000000; }
+        .message { background-color: #f0f0f0; }
+        </style>
+        """
 
 # Gradio Interface
 with gr.Blocks(title="GPT-OSS Chat") as demo:
     gr.Markdown("# 🤖 GPT-OSS 20B Chat")
     gr.Markdown(f"Chat with automatic web search capabilities\n\n**Current Date/Time**: {FORMATTED_DATE_TIME}")
     
+    # Theme CSS
+    theme_css = gr.HTML()
+    
     with gr.Row():
         chatbot = gr.Chatbot(height=500, type="messages", label="Conversation")
     
@@ -367,6 +533,24 @@ with gr.Blocks(title="GPT-OSS Chat") as demo:
     
     with gr.Row():
         clear = gr.Button("Clear")
+        theme_toggle = gr.Radio(choices=["Light", "Dark"], value="Light", label="Theme")
+        feedback_radio = gr.Radio(
+            choices=["👍 Helpful", "👎 Not Helpful", "🔄 Needs Improvement"], 
+            label="Rate Last Response"
+        )
+    
+    with gr.Row():
+        with gr.Column():
+            follow_up_questions = gr.Radio(
+                choices=[], 
+                label="Suggested Follow-up Questions",
+                visible=False
+            )
+        with gr.Column():
+            with gr.Row():
+                export_format = gr.Radio(choices=["JSON", "Text"], value="JSON", label="Export Format")
+                export_btn = gr.Button("Export Conversation")
+                export_output = gr.File(label="Download")
     
     with gr.Accordion("Search Results", open=False):
         search_results = gr.Textbox(label="Raw Search Data", interactive=False, max_lines=10)
@@ -401,21 +585,45 @@ with gr.Blocks(title="GPT-OSS Chat") as demo:
         use_web_search = gr.Checkbox(label="Enable Web Search", value=True)
 
     # Event handling
-    submit.click(
+    submit_event = submit.click(
         respond,
-        [msg, chatbot, model_choice, max_tokens, temperature, top_p, creativity, precision, system_prompt, use_web_search],
-        [msg, chatbot, search_results],
+        [msg, chatbot, model_choice, max_tokens, temperature, top_p, creativity, precision, system_prompt, use_web_search, theme_toggle],
+        [msg, chatbot, search_results, follow_up_questions],
         queue=True
     )
     
-    msg.submit(
+    msg_event = msg.submit(
         respond,
-        [msg, chatbot, model_choice, max_tokens, temperature, top_p, creativity, precision, system_prompt, use_web_search],
-        [msg, chatbot, search_results],
+        [msg, chatbot, model_choice, max_tokens, temperature, top_p, creativity, precision, system_prompt, use_web_search, theme_toggle],
+        [msg, chatbot, search_results, follow_up_questions],
         queue=True
     )
     
     clear.click(lambda: None, None, chatbot, queue=False)
+    
+    theme_toggle.change(
+        apply_theme,
+        [theme_toggle],
+        [theme_css]
+    )
+    
+    feedback_radio.change(
+        collect_feedback,
+        [feedback_radio, msg, chatbot],
+        []
+    )
+    
+    follow_up_questions.change(
+        lambda x: x,
+        [follow_up_questions],
+        [msg]
+    )
+    
+    export_btn.click(
+        export_conversation,
+        [chatbot, export_format],
+        [export_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()