Update app.py

app.py

@@ -1,195 +1,189 @@
 import gradio as gr
 import requests
 import os
-from typing import List, Tuple, Any
+from typing import List, Tuple
 
-# Configuration - Set API key in Hugging Face Spaces Secrets
-API_URL = "https://api.deepseek.com/v1/chat/completions"
-API_KEY = os.getenv("DEEPSEEK_API_KEY")
-
-# Debug API key loading
-print(f"🔑 API Key Status: {'✅ Loaded' if API_KEY else '❌ Missing'}")
-if API_KEY:
-    print(f"🔑 API Key Preview: {API_KEY[:10]}...")
-
-# Validate API key at startup
-if not API_KEY:
-    print("❌ ERROR: DEEPSEEK_API_KEY environment variable not found!")
-    print("💡 Please set your API key:")
-    print("   - Local: export DEEPSEEK_API_KEY='your-key'")
-    print("   - HF Spaces: Add to Repository Secrets")
-
-headers = {
-    "Authorization": f"Bearer {API_KEY}",
-    "Content-Type": "application/json"
+# 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
+    }
 }
 
-def test_api_connection():
-    """Test if API is accessible"""
-    if not API_KEY:
-        return False, "API key not found"
+def query_api(message: str, history: List[Tuple[str, str]], api_choice: str) -> str:
+    """Query selected API with error handling"""
     
-    try:
-        response = requests.post(
-            API_URL,
-            headers=headers,
-            json={
-                "model": "deepseek-chat",
-                "messages": [{"role": "user", "content": "test"}],
-                "max_tokens": 10
-            },
-            timeout=10
-        )
-        return response.status_code == 200, f"Status: {response.status_code}"
-    except Exception as e:
-        return False, str(e)
-
-def query_deepseek(message: str, history: List[Tuple[str, str]]) -> str:
-    """Query DeepSeek API with robust error handling"""
+    if api_choice not in APIS:
+        return f"❌ Unknown API: {api_choice}"
+    
+    config = APIS[api_choice]
     
-    # Check API key first
-    if not API_KEY:
-        return "❌ **API Key Missing**\n\nPlease set DEEPSEEK_API_KEY environment variable:\n- Local: `export DEEPSEEK_API_KEY='your-key'`\n- HF Spaces: Add to Repository Secrets"
+    if not config["key"]:
+        return f"❌ **API Key Missing for {api_choice.upper()}**\n\nSet environment variable: `{api_choice.upper()}_API_KEY`"
     
     try:
-        # Build conversation history
+        # Build messages
         messages = [{"role": "system", "content": "You are a helpful assistant."}]
-        
-        # Add chat history
         for user_msg, bot_msg in history:
-            if user_msg and bot_msg:  # Skip empty messages
+            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})
 
-        # API request
+        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"
+
         response = requests.post(
-            API_URL,
+            config["url"],
             headers=headers,
             json={
-                "model": "deepseek-chat",
+                "model": config["model"],
                 "messages": messages,
                 "temperature": 0.7,
-                "max_tokens": 1024,
-                "stream": False
+                "max_tokens": 1024
             },
             timeout=30
         )
         
-        # Detailed error handling
+        # Handle different error codes
         if response.status_code == 401:
-            return "❌ **Authentication Error**\nInvalid API key. Please check your DEEPSEEK_API_KEY."
+            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"
         elif response.status_code == 403:
-            return "❌ **Access Denied**\nAPI key doesn't have permission or quota exceeded."
-        elif response.status_code == 404:
-            return "❌ **API Not Found**\nCheck if the API URL is correct: https://api.deepseek.com/v1/chat/completions"
+            return f"❌ **Access Denied ({api_choice})**\nPermission denied or quota exceeded"
         elif response.status_code == 429:
-            return "❌ **Rate Limited**\nToo many requests. Please wait and try again."
+            return f"❌ **Rate Limited ({api_choice})**\nToo many requests, please wait"
         elif response.status_code >= 500:
-            return f"❌ **Server Error**\nDeepSeek server error (HTTP {response.status_code}). Try again later."
+            return f"❌ **Server Error ({api_choice})**\nAPI server error, try again later"
         
         response.raise_for_status()
-        
-        # Parse response
         result = response.json()
+        
         if "choices" in result and len(result["choices"]) > 0:
             return result["choices"][0]["message"]["content"]
         else:
-            return f"❌ **Unexpected Response**\n```json\n{result}\n```"
+            return f"❌ **No Response from {api_choice}**\n```json\n{result}\n```"
     
     except requests.exceptions.Timeout:
-        return "❌ **Timeout Error**\nRequest took too long. Please try again."
-    except requests.exceptions.ConnectionError:
-        return "❌ **Connection Error**\nCannot connect to DeepSeek API. Check your internet connection."
-    except requests.exceptions.RequestException as e:
-        return f"❌ **Request Error**\n{str(e)}"
+        return f"❌ **Timeout ({api_choice})**\nRequest took too long"
     except Exception as e:
-        return f"❌ **Unexpected Error**\n{str(e)}"
+        return f"❌ **Error ({api_choice})**\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 create_interface():
-    # Test API connection at startup
-    api_ok, api_msg = test_api_connection()
-    status_msg = f"🟢 API Connected: {api_msg}" if api_ok else f"🔴 API Issue: {api_msg}"
+    available_apis = get_available_apis()
     
-    with gr.Blocks(
-        title="DeepSeek Chat",
-        theme=gr.themes.Soft(),
-        analytics_enabled=False
-    ) as demo:
+    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]))
         
-        gr.Markdown("# 🤖 DeepSeek API Chat")
-        gr.Markdown(f"**Status:** {status_msg}")
+        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"
+            )
         
-        chatbot = gr.Chatbot(
-            label="Conversation",
-            bubble_full_width=False,
-            height=500
-        )
+        chatbot = gr.Chatbot(label="Conversation", height=500)
         
         with gr.Row():
             msg = gr.Textbox(
-                label="Your Message",
-                placeholder="Type your message here...",
-                scale=4,
-                lines=2
+                label="Message",
+                placeholder="Type your message...",
+                scale=4
             )
-            with gr.Column(scale=1):
-                submit = gr.Button("Send 📤", variant="primary")
-                clear = gr.Button("Clear 🗑️")
-
-        # Chat handler
-        def respond(message: str, chat_history: List[List[str]]) -> Tuple[str, List[List[str]]]:
+            send_btn = gr.Button("Send 📤", variant="primary")
+        
+        clear_btn = gr.Button("Clear Chat 🗑️")
+        
+        def respond(message: str, chat_history: List[List[str]], api: str):
             if not message.strip():
                 return "", chat_history
             
-            # Convert to tuple format for API
             history_tuples = [(h[0], h[1]) for h in chat_history if len(h) >= 2]
-            bot_message = query_deepseek(message.strip(), history_tuples)
+            bot_message = query_api(message.strip(), history_tuples, api)
             chat_history.append([message, bot_message])
             return "", chat_history
-
+        
         # Event handlers
-        msg.submit(respond, [msg, chatbot], [msg, chatbot])
-        submit.click(respond, [msg, chatbot], [msg, chatbot])
-        clear.click(lambda: [], None, chatbot, queue=False)
+        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)
         
         # Examples
         gr.Examples(
             examples=[
-                ["Hello! Can you introduce yourself?"],
-                ["Explain quantum computing in simple terms"],
-                ["Write a Python function to calculate Fibonacci numbers"],
-                ["What are the key features of DeepSeek?"],
-                ["Help me debug this error: 'list index out of range'"]
+                ["Hello! How are you?"],
+                ["Explain machine learning simply"],
+                ["Write a Python function to reverse a string"],
+                ["What's the difference between AI and ML?"]
             ],
             inputs=msg
         )
         
-        # Footer
         gr.Markdown("""
         ---
-        **Troubleshooting:**
-        - ❌ API Key Missing → Set `DEEPSEEK_API_KEY` environment variable
-        - ❌ 401 Error → Invalid API key
-        - ❌ 403 Error → No permission or quota exceeded
-        - ❌ 404 Error → Wrong API URL
+        ## 🔧 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"
+        ```
         """)
     
     return demo
 
-# Launch configuration
 if __name__ == "__main__":
-    print("🚀 Starting DeepSeek Gradio App...")
-    
     app = create_interface()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        share=False,  # Set to True if you want public link
-        quiet=False
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860)