Back to Version 3

app.py

@@ -1,173 +1,320 @@
 import gradio as gr
 import os
 import requests
-import time
+import json
 from typing import List, Tuple
+import time
 
-# --- GROQ API Setup ---
+# Load GROQ API key from environment (set it in Hugging Face secrets)
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
 
+# ✅ UPDATED: Correct GROQ model names (as of Dec 2024)
 MODELS = {
-    "Llama 3.2 (3B) - Fast & Free": "llama-3.2-3b-preview",
-    "Mixtral (8x7B) - Balanced": "mixtral-8x7b-32768"
+    "Llama 3.2 (3B) - Fast": "llama-3.2-3b-preview",
+    "Llama 3.2 (1B) - Light": "llama-3.2-1b-preview",
+    "Llama 3.2 (90B Text) - Powerful": "llama-3.2-90b-text-preview",
+    "Llama 3.2 (11B Text) - Balanced": "llama-3.2-11b-text-preview",
+    "Mixtral (8x7B)": "mixtral-8x7b-32768",
+    "Gemma 2 (9B)": "gemma2-9b-it"
 }
 
-SYSTEM_PROMPT = """You are CodeMentor, a helpful programming tutor. 
-Keep responses concise (3-5 sentences max) with clear code examples.
-Format code in markdown code blocks."""
+# 🎯 Customize this system prompt based on your bot's role
+SYSTEM_PROMPT = """You are CodeMentor, a friendly and knowledgeable programming tutor. 
+Your role is to help users learn programming concepts, debug code, and understand different programming languages.
 
-# --- GROQ API Class ---
-class GroqAPI:
-    def __init__(self):
-        self.api_key = GROQ_API_KEY
-        self.timeout = 15
-        self.max_retries = 2
+Key personality traits:
+1. Patient and encouraging - never make users feel bad for not knowing something
+2. Explain concepts clearly with simple analogies first
+3. Provide practical code examples
+4. When debugging, guide users to discover the solution rather than just giving the answer
+5. Adapt explanations to the user's skill level
+6. Include best practices and common pitfalls
+7. Be enthusiastic about programming!
 
-    def query(self, message: str, chat_history: List[Tuple[str, str]], model: str, temperature: float, max_tokens: int) -> str:
-        if not self.api_key:
-            return "❌ **API Key Missing**: Please set GROQ_API_KEY in Hugging Face Secrets"
-        
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
-        
-        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-        for user_msg, bot_msg in chat_history[-3:]:
-            messages.append({"role": "user", "content": user_msg})
-            messages.append({"role": "assistant", "content": bot_msg})
-        messages.append({"role": "user", "content": message})
-        
-        actual_model = MODELS.get(model, "llama-3.2-3b-preview")
-        payload = {
-            "model": actual_model,
-            "messages": messages,
-            "temperature": min(temperature, 0.7),
-            "max_tokens": min(max_tokens, 300),
-            "top_p": 0.9,
-            "stream": False
-        }
+Always format code examples with proper syntax highlighting using markdown code blocks.
+If a user asks about something non-programming related, gently steer the conversation back to programming topics."""
+
+def query_groq_api(message: str, chat_history: List[Tuple[str, str]], model: str, temperature: float, max_tokens: int) -> str:
+    """Send request to GROQ API and get response"""
+    
+    if not GROQ_API_KEY:
+        return "⚠️ API Key not configured. Please set GROQ_API_KEY in environment variables."
+    
+    headers = {
+        "Authorization": f"Bearer {GROQ_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    # Build messages list
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    
+    # Add chat history
+    for user_msg, bot_msg in chat_history:
+        messages.append({"role": "user", "content": user_msg})
+        messages.append({"role": "assistant", "content": bot_msg})
+    
+    # Add current message
+    messages.append({"role": "user", "content": message})
+    
+    # ✅ Get the actual model name from the dictionary
+    actual_model = MODELS.get(model, "llama-3.2-3b-preview")
+    
+    # Prepare payload
+    payload = {
+        "model": actual_model,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "top_p": 0.9,
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(GROQ_API_URL, headers=headers, json=payload, timeout=30)
         
-        for attempt in range(self.max_retries):
-            try:
-                response = requests.post(GROQ_API_URL, headers=headers, json=payload, timeout=self.timeout)
-                if response.status_code == 200:
-                    data = response.json()
-                    return data["choices"][0]["message"]["content"]
-                elif response.status_code == 429:
-                    wait_time = (attempt + 1) * 5
-                    if attempt < self.max_retries - 1:
-                        time.sleep(wait_time)
-                        continue
-                    return "⏰ **Rate Limited**: Free tier limits requests. Try again in 1 minute."
-                elif response.status_code == 404:
-                    return f"❌ **Model Not Found**: '{actual_model}' not available."
-                else:
-                    return f"❌ **Error {response.status_code}**: {response.text[:100]}"
-            except requests.exceptions.Timeout:
-                return "⏱️ **Timeout**: Request took too long."
-            except requests.exceptions.RequestException as e:
-                return f"🌐 **Connection Error**: {str(e)}"
-            except Exception as e:
-                return f"⚠️ **Unexpected Error**: {str(e)}"
-        return "❌ **Failed after retries**."
+        if response.status_code == 200:
+            data = response.json()
+            return data["choices"][0]["message"]["content"]
+        elif response.status_code == 404:
+            # ✅ Specific error for model not found
+            return f"❌ Error: Model '{actual_model}' not found. Available models are: {', '.join(MODELS.values())}"
+        else:
+            return f"❌ Error {response.status_code}: {response.text}"
+    
+    except requests.exceptions.Timeout:
+        return "⏰ Request timeout. Please try again."
+    except requests.exceptions.RequestException as e:
+        return f"🚫 Connection error: {str(e)}"
+    except Exception as e:
+        return f"⚠️ Unexpected error: {str(e)}"
 
-# --- Initialize API ---
-groq_api = GroqAPI()
+def respond(message: str, chat_history: List[Tuple[str, str]], model: str, temperature: float, max_tokens: int):
+    """Process user message and return bot response"""
+    
+    if not message.strip():
+        return "", chat_history
+    
+    # Show typing indicator
+    chat_history.append((message, "🤔 Thinking..."))
+    yield "", chat_history
+    
+    # Get bot response
+    bot_reply = query_groq_api(message, chat_history[:-1], model, temperature, max_tokens)
+    
+    # Replace typing indicator with actual response
+    chat_history[-1] = (message, bot_reply)
+    
+    return "", chat_history
 
-# --- Functions ---
 def clear_chat():
+    """Clear chat history"""
     return [], []
 
-def create_example_buttons():
-    return [
-        ("📝 List Comprehensions", "Explain Python list comprehensions with 2 examples"),
-        ("🐛 Debug Help", "How to fix 'IndexError: list index out of range'?"),
-        ("🔤 String Format", "Show 3 ways to format strings in Python"),
-        ("📊 Data Types", "What are Python's main data types?")
-    ]
-
-def process_message(message, history, model, temp, tokens):
-    if not message:
-        return "", history
-    history.append((message, "⏳ Thinking..."))
-    response = groq_api.query(message, history[:-1], model, temp, tokens)
-    history[-1] = (message, response)
-    return "", history
-
-def test_connection():
-    test_msg = "Say 'Hello' if you're working."
-    test_response = groq_api.query(test_msg, [], "Llama 3.2 (3B) - Fast & Free", 0.7, 100)
-    if "Hello" in test_response or "hello" in test_response:
-        return "✅ Connection successful! API is working."
-    else:
-        return f"⚠️ Test response: {test_response[:100]}..."
+def update_example_questions(programming_language: str):
+    """Update example questions based on selected programming language"""
+    
+    examples = {
+        "Python": [
+            "Explain list comprehensions with examples",
+            "How do decorators work in Python?",
+            "What's the difference between 'is' and '=='?",
+            "Show me how to handle exceptions properly"
+        ],
+        "JavaScript": [
+            "Explain promises and async/await",
+            "What is the event loop?",
+            "How does 'this' keyword work?",
+            "Explain closure with an example"
+        ],
+        "Java": [
+            "Explain polymorphism with examples",
+            "Difference between abstract class and interface",
+            "How does garbage collection work?",
+            "What are Java Streams?"
+        ],
+        "General": [
+            "What's the difference between SQL and NoSQL?",
+            "Explain REST API principles",
+            "What are design patterns?",
+            "How does Git branching work?"
+        ]
+    }
+    
+    return gr.update(choices=examples.get(programming_language, examples["General"]))
 
-# --- Gradio Interface ---
-with gr.Blocks(theme=gr.themes.Soft(), title="CodeMentor - Fast Programming Tutor") as demo:
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), title="CodeMentor - Programming Tutor") as demo:
+    
+    # Store chat history in state
     chat_state = gr.State([])
-
+    
     gr.Markdown("""
-    # 👨‍💻 CodeMentor - Fast Programming Help
-    ⚡ Optimized for GROQ Free Tier - Faster responses, timeouts handled
-    ⚠️ Free API has rate limits (1-2 requests/minute). If stuck, wait 60 seconds.
+    # 👨‍💻 CodeMentor - Your Personal Programming Tutor
+    
+    Hi! I'm CodeMentor, your friendly AI programming assistant. I can help you with:
+    - Learning programming concepts
+    - Debugging code
+    - Understanding different languages
+    - Best practices and design patterns
+    
+    Select your preferences below and start asking questions!
+    
+    ⚠️ **Note**: Using GROQ API with free tier (limited requests per minute)
     """)
-
+    
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ Quick Settings")
+            # UI Improvements
+            gr.Markdown("### ⚙️ Settings")
+            
+            # Model selection dropdown
             model_dropdown = gr.Dropdown(
                 choices=list(MODELS.keys()),
-                value="Llama 3.2 (3B) - Fast & Free",
-                label="Model"
+                value="Llama 3.2 (3B) - Fast",
+                label="Select AI Model",
+                info="✅ Updated with correct GROQ model names"
             )
-
-            gr.Markdown("### 🎯 Quick Questions")
             
-            # Example buttons
-            examples = create_example_buttons()
-            example_buttons = []
-            for btn_text, question in examples:
-                btn = gr.Button(btn_text, size="sm", variant="secondary")
-                btn.click(fn=lambda q=question: q, inputs=[], outputs=None)  # we'll connect later
-                example_buttons.append(btn)
-
+            # Programming language selection
+            language_dropdown = gr.Dropdown(
+                choices=["Python", "JavaScript", "Java", "C++", "General"],
+                value="Python",
+                label="Programming Language Focus",
+                info="Get language-specific examples"
+            )
+            
+            # Temperature slider
+            temperature_slider = gr.Slider(
+                minimum=0.1,
+                maximum=1.0,
+                value=0.7,
+                step=0.1,
+                label="Creativity (Temperature)",
+                info="Lower = more focused, Higher = more creative"
+            )
+            
+            # Response length slider
+            max_tokens_slider = gr.Slider(
+                minimum=100,
+                maximum=2000,
+                value=500,
+                step=100,
+                label="Response Length (Tokens)",
+                info="Maximum length of responses"
+            )
+            
+            # Example questions dropdown
+            gr.Markdown("### 💡 Example Questions")
+            example_dropdown = gr.Dropdown(
+                choices=[
+                    "Explain list comprehensions with examples",
+                    "How do decorators work in Python?",
+                    "What's the difference between 'is' and '=='?",
+                    "Show me how to handle exceptions properly"
+                ],
+                label="Quick Questions",
+                info="Select a question to ask",
+                allow_custom_value=True
+            )
+            
+            # Quick action buttons
+            gr.Markdown("### ⚡ Quick Actions")
+            with gr.Row():
+                clear_btn = gr.Button("🧹 Clear Chat", variant="secondary", size="sm")
+                reset_btn = gr.Button("🔄 Reset Settings", variant="secondary", size="sm")
+        
         with gr.Column(scale=2):
-            chatbot = gr.Chatbot(value=[], label="Chat", height=450)
-            msg = gr.Textbox(placeholder="Ask about programming...", label="Your Question", lines=2)
-
-            # Sliders
-            temp_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.5, label="temp", visible=False)
-            tokens_slider = gr.Slider(minimum=1, maximum=300, value=300, step=1, label="tokens", visible=False)
-
-            # Send / Clear / Test buttons
-            send_btn = gr.Button("🚀 Send", variant="primary")
-            clear_btn = gr.Button("🗑️ Clear", size="sm")
-            test_btn = gr.Button("🔍 Test Connection", size="sm", variant="primary")
-            test_output = gr.Textbox(label="Connection Test", visible=False)
-
-    # Connect example buttons to textbox
-    for btn, (_, question) in zip(example_buttons, examples):
-        btn.click(fn=lambda q=question: q, inputs=[], outputs=msg)
-
-    # Connect send button and Enter key
+            # Chat interface
+            chatbot = gr.Chatbot(
+                value=[],
+                label="CodeMentor",
+                height=500,
+                bubble_full_width=False
+            )
+            
+            # Message input
+            msg = gr.Textbox(
+                placeholder="Type your programming question here... (Press Enter to send)",
+                label="Your Question",
+                lines=2
+            )
+            
+            with gr.Row():
+                send_btn = gr.Button("🚀 Send", variant="primary")
+                stop_btn = gr.Button("⏹️ Stop", variant="stop")
+    
+    # Update example questions when language changes
+    language_dropdown.change(
+        fn=update_example_questions,
+        inputs=language_dropdown,
+        outputs=example_dropdown
+    )
+    
+    # Handle example question selection
+    example_dropdown.change(
+        fn=lambda x: x,
+        inputs=[example_dropdown],
+        outputs=msg
+    )
+    
+    # Handle message submission
     msg.submit(
-        fn=process_message,
-        inputs=[msg, chat_state, model_dropdown, temp_slider, tokens_slider],
+        fn=respond,
+        inputs=[msg, chat_state, model_dropdown, temperature_slider, max_tokens_slider],
         outputs=[msg, chatbot]
     )
+    
     send_btn.click(
-        fn=process_message,
-        inputs=[msg, chat_state, model_dropdown, temp_slider, tokens_slider],
+        fn=respond,
+        inputs=[msg, chat_state, model_dropdown, temperature_slider, max_tokens_slider],
         outputs=[msg, chatbot]
     )
-
-    # Clear chat
-    clear_btn.click(fn=clear_chat, inputs=[], outputs=[chatbot, chat_state])
-
-    # Test connection
-    test_btn.click(fn=test_connection, inputs=[], outputs=test_output)
+    
+    # Handle clear button
+    clear_btn.click(
+        fn=clear_chat,
+        inputs=None,
+        outputs=[chatbot, chat_state]
+    )
+    
+    # Handle reset button
+    def reset_settings():
+        return [
+            "Llama 3.2 (3B) - Fast",  # model_dropdown
+            "Python",  # language_dropdown
+            0.7,  # temperature_slider
+            500,  # max_tokens_slider
+            "Explain list comprehensions with examples"  # example_dropdown
+        ]
+    
+    reset_btn.click(
+        fn=reset_settings,
+        inputs=None,
+        outputs=[model_dropdown, language_dropdown, temperature_slider, max_tokens_slider, example_dropdown]
+    )
+    
+    # Footer with troubleshooting info
+    gr.Markdown("""
+    ---
+    ### ℹ️ About & Troubleshooting
+    
+    **Powered by**: GROQ API
+    **Current Models Available**:
+    - `llama-3.2-3b-preview` (Fast, 3B parameters)
+    - `llama-3.2-1b-preview` (Lightweight, 1B)
+    - `llama-3.2-90b-text-preview` (Most powerful, 90B)
+    - `llama-3.2-11b-text-preview` (Balanced, 11B)
+    - `mixtral-8x7b-32768` (Mixture of experts)
+    - `gemma2-9b-it` (Google's model)
+    
+    **If you see "model not found" error**:
+    1. Check GROQ Console for available models
+    2. Ensure your API key has access to the selected model
+    3. Try a different model from the dropdown
+    
+    **Note**: Free tier has rate limits. If requests fail, wait 1 minute and try again.
+    """)
 
 if __name__ == "__main__":
-    demo.launch(debug=False, server_name="0.0.0.0", server_port=7860, share=True)
+    demo.launch(debug=False, server_name="0.0.0.0", server_port=7860)