Update App.py Version 4

app.py

@@ -1,320 +1,177 @@
 import gradio as gr
 import os
 import requests
-import json
-from typing import List, Tuple
 import time
 
-# Load GROQ API key from environment (set it in Hugging Face secrets)
+# Configuration
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
-GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
+MODEL = "llama-3.2-3b-preview"  # Fastest free model
 
-# ✅ UPDATED: Correct GROQ model names (as of Dec 2024)
-MODELS = {
-    "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"
-}
-
-# 🎯 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.
-
-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!
-
-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"""
+def ask_groq(message, history):
+    """Simple function to query GROQ"""
     
     if not GROQ_API_KEY:
-        return "⚠️ API Key not configured. Please set GROQ_API_KEY in environment variables."
+        return "❌ **ERROR**: Please add GROQ_API_KEY in Hugging Face Secrets (Settings → Secrets)"
     
+    # Prepare request
     headers = {
         "Authorization": f"Bearer {GROQ_API_KEY}",
         "Content-Type": "application/json"
     }
     
-    # Build messages list
-    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    # Build conversation history
+    messages = [
+        {"role": "system", "content": "You are a helpful programming tutor. Keep answers concise (2-3 sentences)."}
+    ]
     
-    # 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 conversation history (last 2 exchanges max for speed)
+    for human, assistant in history[-2:]:
+        messages.append({"role": "user", "content": human})
+        messages.append({"role": "assistant", "content": assistant})
     
     # 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,
+    data = {
+        "model": MODEL,
         "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-        "top_p": 0.9,
-        "stream": False
+        "temperature": 0.7,
+        "max_tokens": 200,  # Short for faster responses
+        "top_p": 0.9
     }
     
     try:
-        response = requests.post(GROQ_API_URL, headers=headers, json=payload, timeout=30)
+        response = requests.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers=headers,
+            json=data,
+            timeout=20  # 20 second timeout
+        )
         
         if response.status_code == 200:
-            data = response.json()
-            return data["choices"][0]["message"]["content"]
+            return response.json()["choices"][0]["message"]["content"]
+        elif response.status_code == 429:
+            return "⏰ **RATE LIMITED**: Free tier allows ~1 request/minute. Wait 60 seconds."
         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())}"
+            return f"❌ **MODEL ERROR**: '{MODEL}' not found. Try 'mixtral-8x7b-32768' instead."
         else:
-            return f"❌ Error {response.status_code}: {response.text}"
-    
+            return f"❌ **API ERROR {response.status_code}**: {response.text[:100]}..."
+            
     except requests.exceptions.Timeout:
-        return "⏰ Request timeout. Please try again."
-    except requests.exceptions.RequestException as e:
-        return f"🚫 Connection error: {str(e)}"
+        return "⏱️ **TIMEOUT**: GROQ is busy. Try shorter questions."
+    except requests.exceptions.ConnectionError:
+        return "🌐 **CONNECTION ERROR**: Check your internet or API key."
     except Exception as e:
-        return f"⚠️ Unexpected error: {str(e)}"
+        return f"⚠️ **ERROR**: {str(e)[:80]}"
 
-def respond(message: str, chat_history: List[Tuple[str, str]], model: str, temperature: float, max_tokens: int):
-    """Process user message and return bot response"""
+# Create the Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), title="⚡ Programming Tutor - GROQ") as demo:
     
-    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)
+    gr.Markdown("""
+    # 👨‍💻 Programming Tutor Chatbot
+    **Powered by GROQ API (Free Tier)**
     
-    return "", chat_history
-
-def clear_chat():
-    """Clear chat history"""
-    return [], []
-
-def update_example_questions(programming_language: str):
-    """Update example questions based on selected programming language"""
+    ⚠️ **NOTE**: Free tier has rate limits. If stuck, wait 60 seconds between requests.
+    """)
     
-    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?"
-        ]
-    }
+    # Create chatbot interface
+    chatbot = gr.Chatbot(
+        label="Chat History",
+        height=400
+    )
     
-    return gr.update(choices=examples.get(programming_language, examples["General"]))
-
-# Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft(), title="CodeMentor - Programming Tutor") as demo:
+    # Create message input
+    msg = gr.Textbox(
+        placeholder="Ask a programming question... (Keep it short for faster responses)",
+        label="Your Question",
+        lines=2
+    )
     
-    # Store chat history in state
+    # Create state for chat history
     chat_state = gr.State([])
     
-    gr.Markdown("""
-    # 👨‍💻 CodeMentor - Your Personal Programming Tutor
+    # Function to handle message submission
+    def respond(message, history):
+        if not message.strip():
+            return "", history
+        
+        # Get response from GROQ
+        bot_reply = ask_groq(message, history)
+        
+        # Add to history
+        history.append((message, bot_reply))
+        
+        return "", history
     
-    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
+    # Clear function
+    def clear_chat():
+        return [], []
     
-    Select your preferences below and start asking questions!
+    # Create buttons in a row
+    with gr.Row():
+        send_btn = gr.Button("🚀 Send Message", variant="primary")
+        clear_btn = gr.Button("🗑️ Clear Chat", variant="secondary")
     
-    ⚠️ **Note**: Using GROQ API with free tier (limited requests per minute)
-    """)
+    # Create example questions in a separate row
+    gr.Markdown("### 💡 Quick Example Questions:")
     
     with gr.Row():
-        with gr.Column(scale=1):
-            # UI Improvements
-            gr.Markdown("### ⚙️ Settings")
-            
-            # Model selection dropdown
-            model_dropdown = gr.Dropdown(
-                choices=list(MODELS.keys()),
-                value="Llama 3.2 (3B) - Fast",
-                label="Select AI Model",
-                info="✅ Updated with correct GROQ model names"
-            )
-            
-            # 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")
+        examples = [
+            "Hello! Are you working?",
+            "Print 'Hello World' in Python",
+            "What is a function?",
+            "How to fix syntax errors?"
+        ]
         
-        with gr.Column(scale=2):
-            # Chat interface
-            chatbot = gr.Chatbot(
-                value=[],
-                label="CodeMentor",
-                height=500,
-                bubble_full_width=False
+        for example in examples:
+            btn = gr.Button(example, size="sm")
+            # When clicked, set the msg textbox to this example
+            btn.click(
+                fn=lambda x=example: x,
+                inputs=[],
+                outputs=msg
             )
-            
-            # 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
+    # Set up event handlers
     msg.submit(
         fn=respond,
-        inputs=[msg, chat_state, model_dropdown, temperature_slider, max_tokens_slider],
+        inputs=[msg, chat_state],
         outputs=[msg, chatbot]
     )
     
     send_btn.click(
         fn=respond,
-        inputs=[msg, chat_state, model_dropdown, temperature_slider, max_tokens_slider],
+        inputs=[msg, chat_state],
         outputs=[msg, chatbot]
     )
     
-    # Handle clear button
     clear_btn.click(
         fn=clear_chat,
-        inputs=None,
+        inputs=[],
         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
+    # Footer with instructions
     gr.Markdown("""
     ---
-    ### ℹ️ About & Troubleshooting
+    ### 🔧 **Troubleshooting Guide**
     
-    **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 errors or long delays:**
+    1. **Wait 60 seconds** between requests (free tier limit)
+    2. **Keep questions short** (under 15 words)
+    3. **Test with "Hello"** first
+    4. **Check API key** in Hugging Face Secrets
     
-    **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
+    **Working questions to test:**
+    - "Say hello"
+    - "What is Python?"
+    - "How to declare a variable?"
     
-    **Note**: Free tier has rate limits. If requests fail, wait 1 minute and try again.
+    **Model**: `llama-3.2-3b-preview` (Fastest free model)
+    **Timeout**: 20 seconds
     """)
 
+# Launch the app
 if __name__ == "__main__":
+    
     demo.launch(debug=False, server_name="0.0.0.0", server_port=7860)