Update app.py

app.py

@@ -3,187 +3,287 @@ import requests
 import os
 from typing import List, Tuple
 
-# Multiple API options
-APIS = {
-    "deepseek": {
-        "url": "https://api.deepseek.com/v1/chat/completions",
-        "key": os.getenv("DEEPSEEK_API_KEY"),
-        "model": "deepseek-chat",
-        "free": False
-    },
-    "groq": {
-        "url": "https://api.groq.com/openai/v1/chat/completions", 
-        "key": os.getenv("GROQ_API_KEY"),
-        "model": "llama3-8b-8192",  # Free tier available
-        "free": True
-    },
-    "together": {
-        "url": "https://api.together.xyz/v1/chat/completions",
-        "key": os.getenv("TOGETHER_API_KEY"), 
-        "model": "meta-llama/Llama-2-7b-chat-hf",
-        "free": True  # $5 free credit
-    },
-    "openrouter": {
-        "url": "https://openrouter.ai/api/v1/chat/completions",
-        "key": os.getenv("OPENROUTER_API_KEY"),
-        "model": "google/gemma-7b-it:free",  # Free model
-        "free": True
-    }
+# Groq API Configuration
+API_URL = "https://api.groq.com/openai/v1/chat/completions"
+API_KEY = os.getenv("GROQ_API_KEY")  # This will read from HF Secrets
+
+# Debug info (will show in HF Spaces logs)
+print(f"🔑 Groq API Key Status: {'✅ Found' if API_KEY else '❌ Missing'}")
+if API_KEY:
+    print(f"🔑 API Key Preview: {API_KEY[:8]}...")
+
+headers = {
+    "Authorization": f"Bearer {API_KEY}",
+    "Content-Type": "application/json"
 }
 
-def query_api(message: str, history: List[Tuple[str, str]], api_choice: str) -> str:
-    """Query selected API with error handling"""
-    
-    if api_choice not in APIS:
-        return f"❌ Unknown API: {api_choice}"
-    
-    config = APIS[api_choice]
+# Groq Models
+MODELS = {
+    "llama3-8b-8192": "Llama 3 8B ⚡ (Fastest)",
+    "llama3-70b-8192": "Llama 3 70B 🧠 (Smartest)", 
+    "mixtral-8x7b-32768": "Mixtral 8x7B ⚖️ (Balanced)",
+    "gemma-7b-it": "Gemma 7B 🔍 (Google)"
+}
+
+def query_groq(message: str, history: List[Tuple[str, str]], model: str) -> str:
+    """Query Groq API with comprehensive error handling"""
     
-    if not config["key"]:
-        return f"❌ **API Key Missing for {api_choice.upper()}**\n\nSet environment variable: `{api_choice.upper()}_API_KEY`"
+    # Check API key
+    if not API_KEY:
+        return """❌ **API Key Not Found**
+
+Please set up your API key in Hugging Face Spaces:
+
+1. Go to your Space's **Settings**
+2. Click **Repository secrets**  
+3. Add new secret:
+   - Name: `GROQ_API_KEY`
+   - Value: Your Groq API key
+4. Restart the Space
+
+Get your free API key at: [console.groq.com](https://console.groq.com)"""
     
     try:
-        # Build messages
-        messages = [{"role": "system", "content": "You are a helpful assistant."}]
+        # Build conversation history
+        messages = [{"role": "system", "content": "You are a helpful AI assistant powered by Groq's lightning-fast inference."}]
+        
+        # Add chat history
         for user_msg, bot_msg in history:
             if user_msg and bot_msg:
                 messages.extend([
                     {"role": "user", "content": user_msg},
                     {"role": "assistant", "content": bot_msg}
                 ])
+        
+        # Add current message
         messages.append({"role": "user", "content": message})
 
-        headers = {
-            "Authorization": f"Bearer {config['key']}",
-            "Content-Type": "application/json"
-        }
-        
-        # Add special headers for some APIs
-        if api_choice == "openrouter":
-            headers["HTTP-Referer"] = "https://your-app.com"
-            headers["X-Title"] = "Gradio Chat"
-
+        # Make API request
         response = requests.post(
-            config["url"],
+            API_URL,
             headers=headers,
             json={
-                "model": config["model"],
+                "model": model,
                 "messages": messages,
                 "temperature": 0.7,
-                "max_tokens": 1024
+                "max_tokens": 2048,
+                "stream": False,
+                "stop": None
             },
             timeout=30
         )
         
-        # Handle different error codes
+        # Handle HTTP errors
         if response.status_code == 401:
-            return f"❌ **Authentication Error ({api_choice})**\nInvalid API key"
-        elif response.status_code == 402:
-            return f"💳 **Payment Required ({api_choice})**\nAccount needs billing setup or credits"
+            return "❌ **Authentication Failed**\nInvalid API key. Please check your GROQ_API_KEY secret."
         elif response.status_code == 403:
-            return f"❌ **Access Denied ({api_choice})**\nPermission denied or quota exceeded"
+            return "❌ **Access Forbidden**\nAPI key doesn't have permission."
         elif response.status_code == 429:
-            return f"❌ **Rate Limited ({api_choice})**\nToo many requests, please wait"
-        elif response.status_code >= 500:
-            return f"❌ **Server Error ({api_choice})**\nAPI server error, try again later"
+            return "❌ **Rate Limited**\nToo many requests. Groq has generous limits, this should be rare."
+        elif response.status_code == 500:
+            return "❌ **Server Error**\nGroq server issue. Please try again."
+        elif response.status_code == 503:
+            return "❌ **Service Unavailable**\nGroq is temporarily down. Try again in a moment."
         
         response.raise_for_status()
+        
+        # Parse response
         result = response.json()
         
         if "choices" in result and len(result["choices"]) > 0:
-            return result["choices"][0]["message"]["content"]
+            content = result["choices"][0]["message"]["content"]
+            return content.strip()
         else:
-            return f"❌ **No Response from {api_choice}**\n```json\n{result}\n```"
+            return f"❌ **Unexpected Response Format**\n```json\n{result}\n```"
     
     except requests.exceptions.Timeout:
-        return f"❌ **Timeout ({api_choice})**\nRequest took too long"
+        return "❌ **Timeout**\nRequest took too long (>30s). Try again."
+    except requests.exceptions.ConnectionError:
+        return "❌ **Connection Error**\nCannot connect to Groq API. Check internet connection."
+    except requests.exceptions.RequestException as e:
+        return f"❌ **Request Error**\n{str(e)}"
     except Exception as e:
-        return f"❌ **Error ({api_choice})**\n{str(e)}"
+        return f"❌ **Unexpected Error**\n{str(e)}"
 
-def get_available_apis():
-    """Get list of APIs with their status"""
-    available = []
-    for name, config in APIS.items():
-        status = "🟢" if config["key"] else "🔴"
-        free_tag = " (FREE)" if config["free"] else " (PAID)"
-        available.append(f"{status} {name.upper()}{free_tag}")
-    return available
+def test_api_connection():
+    """Test API connection and return status"""
+    if not API_KEY:
+        return "🔴 API Key Missing"
+    
+    try:
+        response = requests.post(
+            API_URL,
+            headers=headers,
+            json={
+                "model": "llama3-8b-8192",
+                "messages": [{"role": "user", "content": "test"}],
+                "max_tokens": 5
+            },
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            return "🟢 Connected Successfully"
+        else:
+            return f"🔴 HTTP {response.status_code}"
+    except Exception as e:
+        return f"🔴 Connection Failed: {str(e)[:50]}"
 
-def create_interface():
-    available_apis = get_available_apis()
+def create_gradio_interface():
+    # Test connection at startup
+    connection_status = test_api_connection()
+    
+    # Custom CSS for better UI
+    css = """
+    .gradio-container {
+        max-width: 800px !important;
+        margin: auto !important;
+    }
+    .chat-message {
+        padding: 10px !important;
+    }
+    """
     
-    with gr.Blocks(title="Multi-API Chat", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🤖 Multi-API Chat Interface")
-        gr.Markdown("**Available APIs:**\n" + "\n".join([f"- {api}" for api in available_apis]))
+    with gr.Blocks(
+        title="⚡ Groq AI Chat",
+        theme=gr.themes.Soft(primary_hue="blue"),
+        css=css
+    ) as demo:
+        
+        # Header
+        gr.Markdown("""
+        # ⚡ Groq AI Chat
+        ### Lightning-fast AI responses powered by Groq's LPU™
+        """)
+        
+        # Status indicator
+        with gr.Row():
+            gr.Markdown(f"**Connection Status:** {connection_status}")
         
+        # Model selector
         with gr.Row():
-            api_choice = gr.Dropdown(
-                choices=list(APIS.keys()),
-                value="groq",  # Default to free option
-                label="Select API",
-                info="Choose your AI API provider"
+            model_dropdown = gr.Dropdown(
+                choices=list(MODELS.keys()),
+                value="llama3-8b-8192",
+                label="🤖 Select AI Model",
+                info="Choose the model that best fits your needs"
             )
         
-        chatbot = gr.Chatbot(label="Conversation", height=500)
+        # Chat interface
+        chatbot = gr.Chatbot(
+            label="💬 Chat History",
+            height=500,
+            bubble_full_width=False,
+            show_copy_button=True
+        )
         
+        # Input area
         with gr.Row():
-            msg = gr.Textbox(
-                label="Message",
-                placeholder="Type your message...",
-                scale=4
+            msg_textbox = gr.Textbox(
+                label="✍️ Your Message",
+                placeholder="Ask me anything... Groq responses are incredibly fast!",
+                scale=4,
+                lines=2,
+                max_lines=5
             )
-            send_btn = gr.Button("Send 📤", variant="primary")
-        
-        clear_btn = gr.Button("Clear Chat 🗑️")
+            send_button = gr.Button("Send ⚡", variant="primary", scale=1)
         
-        def respond(message: str, chat_history: List[List[str]], api: str):
+        # Control buttons
+        with gr.Row():
+            clear_button = gr.Button("🗑️ Clear Chat", variant="secondary")
+            
+        # Chat logic
+        def respond(message: str, chat_history: List[List[str]], model: str):
             if not message.strip():
                 return "", chat_history
             
+            # Convert gradio format to API format
             history_tuples = [(h[0], h[1]) for h in chat_history if len(h) >= 2]
-            bot_message = query_api(message.strip(), history_tuples, api)
+            
+            # Get AI response
+            bot_message = query_groq(message.strip(), history_tuples, model)
+            
+            # Update chat history
             chat_history.append([message, bot_message])
             return "", chat_history
         
         # Event handlers
-        msg.submit(respond, [msg, chatbot, api_choice], [msg, chatbot])
-        send_btn.click(respond, [msg, chatbot, api_choice], [msg, chatbot])
-        clear_btn.click(lambda: [], None, chatbot)
+        msg_textbox.submit(
+            respond, 
+            inputs=[msg_textbox, chatbot, model_dropdown], 
+            outputs=[msg_textbox, chatbot]
+        )
+        send_button.click(
+            respond, 
+            inputs=[msg_textbox, chatbot, model_dropdown], 
+            outputs=[msg_textbox, chatbot]
+        )
+        clear_button.click(
+            lambda: [], 
+            outputs=chatbot
+        )
         
-        # Examples
+        # Example prompts
         gr.Examples(
             examples=[
-                ["Hello! How are you?"],
-                ["Explain machine learning simply"],
-                ["Write a Python function to reverse a string"],
-                ["What's the difference between AI and ML?"]
+                ["Hello! What makes Groq special?"],
+                ["Explain quantum computing in simple terms"],
+                ["Write a Python function to find prime numbers"],
+                ["What's the difference between AI, ML, and Deep Learning?"],
+                ["Help me debug this error: 'TypeError: 'str' object is not callable'"],
+                ["Create a simple REST API with FastAPI"],
+                ["Explain the concept of recursion with examples"],
+                ["What are the latest trends in web development?"]
             ],
-            inputs=msg
+            inputs=msg_textbox,
+            label="💡 Try these examples:"
         )
         
+        # Information accordion
+        with gr.Accordion("ℹ️ About Groq & Models", open=False):
+            gr.Markdown(f"""
+            **🚀 Why Groq is Amazing:**
+            - ⚡ **Fastest AI inference** in the world (500+ tokens/second)
+            - 🆓 **Generous free tier** with high rate limits
+            - 🔄 **Real-time responses** feel like magic
+            - 🎯 **Consistent quality** across all models
+            
+            **🤖 Available Models:**
+            {chr(10).join([f"- **{model}**: {desc}" for model, desc in MODELS.items()])}
+            
+            **🔧 Technical Details:**
+            - Powered by Groq's custom LPU™ (Language Processing Unit)
+            - Optimized for transformer model inference
+            - Supports context windows up to 32K tokens
+            - Enterprise-grade reliability and security
+            """)
+        
+        # Footer
         gr.Markdown("""
         ---
-        ## 🔧 Setup Instructions:
-        
-        **Free Options (Recommended for testing):**
-        1. **Groq** (Free): Get API key at [console.groq.com](https://console.groq.com)
-        2. **Together** (Free $5): Get key at [api.together.xyz](https://api.together.xyz)
-        3. **OpenRouter** (Free models): Get key at [openrouter.ai](https://openrouter.ai)
-        
-        **Paid Options:**
-        4. **DeepSeek** (Paid): Needs billing setup at [platform.deepseek.com](https://platform.deepseek.com)
-        
-        **Set Environment Variables:**
-        ```bash
-        export GROQ_API_KEY="your-key"
-        export TOGETHER_API_KEY="your-key"  
-        export OPENROUTER_API_KEY="your-key"
-        export DEEPSEEK_API_KEY="your-key"
-        ```
+        **🔑 Setup Instructions:**
+        1. Get free API key: [console.groq.com](https://console.groq.com)
+        2. Add to HF Spaces: Settings → Repository secrets → `GROQ_API_KEY`
+        3. Restart your Space and enjoy lightning-fast AI!
+        
+        **💡 Tips:**
+        - Groq excels at coding, explanations, and creative tasks
+        - Try different models to see which fits your use case
+        - The speed difference is immediately noticeable!
         """)
     
     return demo
 
+# Create and launch the interface
 if __name__ == "__main__":
-    app = create_interface()
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    print("🚀 Initializing Groq Chat Interface...")
+    print(f"🔑 API Key Status: {'✅ Ready' if API_KEY else '❌ Please add GROQ_API_KEY to secrets'}")
+    
+    demo = create_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        show_api=False,  # Hide API docs for cleaner interface
+        favicon_path=None
+    )