Update app.py

app.py

@@ -7,71 +7,25 @@ from datetime import datetime
 
 # Groq API Configuration
 API_URL = "https://api.groq.com/openai/v1/chat/completions"
+API_KEY = os.getenv("GROQ_API_KEY")
 
-# Try multiple ways to get API key
-API_KEY = None
-api_key_sources = []
-
-# Method 1: Environment variable
-env_key = os.getenv("GROQ_API_KEY")
-if env_key:
-    API_KEY = env_key
-    api_key_sources.append("Environment variable GROQ_API_KEY")
-
-# Method 2: Alternative environment variable names
-alt_names = ["GROQ_KEY", "GROQ_API", "GROQ_TOKEN"]
-for name in alt_names:
-    alt_key = os.getenv(name)
-    if alt_key and not API_KEY:
-        API_KEY = alt_key
-        api_key_sources.append(f"Environment variable {name}")
-
-# Method 3: Check if running in HF Spaces
-hf_token = os.getenv("HF_TOKEN")  # HF Spaces sets this automatically
-is_hf_spaces = hf_token is not None
+print(f"🔑 API Key Found: {'Yes' if API_KEY else 'No'}")
 
 # In-memory chat history storage
 chat_history: List[Dict[str, str]] = []
 
-def get_api_key_status():
-    """Get detailed API key status for debugging"""
-    status = {
-        "found": API_KEY is not None,
-        "preview": API_KEY[:10] + "..." if API_KEY else "None",
-        "sources": api_key_sources,
-        "is_hf_spaces": is_hf_spaces,
-        "env_vars": {k: v[:10] + "..." if v and len(v) > 10 else v 
-                    for k, v in os.environ.items() 
-                    if 'GROQ' in k.upper() or 'API' in k.upper()}
-    }
-    return status
-
-def groq_with_memory(message: str, topic: str = "general", summarize: bool = False, max_history: int = 10, user_api_key: str = "") -> List[List[str]]:
-    """Groq API call with chat history and optional summarization, returning chatbot format"""
+def groq_with_memory(message: str, topic: str = "general", summarize: bool = False, max_history: int = 10) -> str:
+    """Groq API call with chat history and optional summarization"""
     
-    # Use user-provided API key if available
-    current_api_key = user_api_key.strip() if user_api_key.strip() else API_KEY
-    
-    if not current_api_key:
-        status = get_api_key_status()
-        error_msg = f"""❌ No API Key found. 
-        
-Debug Info:
-- Environment check: {status}
-- Running in HF Spaces: {is_hf_spaces}
-
-Solutions:
-1. If in HF Spaces: Go to Settings > Secrets and add GROQ_API_KEY
-2. If local: Set environment variable or enter API key in the input field below
-3. Get your key from: https://console.groq.com/keys"""
-        return [[message, error_msg]]
+    if not API_KEY:
+        return "❌ No API Key found"
     
     if not message.strip():
-        return [[None, "❌ Empty message"]]
+        return "❌ Empty message"
     
     try:
         headers = {
-            "Authorization": f"Bearer {current_api_key}",
+            "Authorization": f"Bearer {API_KEY}",
             "Content-Type": "application/json"
         }
         
@@ -86,10 +40,11 @@ Solutions:
         # Limit history to max_history messages to avoid token overflow
         recent_history = chat_history[-max_history:]
         
-        # Prepare messages for API call, excluding timestamp and topic
-        messages = [{"role": msg["role"], "content": msg["content"]} for msg in recent_history]
+        # Prepare messages for API call
+        messages = recent_history.copy()
         
         if summarize:
+            # Create a prompt to summarize the conversation
             summary_prompt = f"Summarize the following conversation history for the topic '{topic}':\n\n"
             for msg in recent_history:
                 if msg["topic"] == topic:
@@ -104,73 +59,69 @@ Solutions:
             "temperature": 0.7
         }
         
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
+        print(f"🚀 Sending request to: {API_URL}")
+        print(f"📝 Payload: {json.dumps(payload, indent=2)}")
+        
+        response = requests.post(
+            API_URL,
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        
+        print(f"📊 Status Code: {response.status_code}")
+        print(f"📋 Response Headers: {dict(response.headers)}")
+        print(f"📄 Response Text (first 300 chars): {response.text[:300]}")
         
         if response.status_code == 200:
             result = response.json()
             if "choices" in result and len(result["choices"]) > 0:
                 response_content = result["choices"][0]["message"]["content"]
+                # Add assistant's response to history
                 chat_history.append({
                     "role": "assistant",
                     "content": response_content,
                     "topic": topic,
                     "timestamp": datetime.now().isoformat()
                 })
-                return [[message.strip(), response_content]]
+                return response_content
             else:
-                error_msg = f"❌ No choices in response: {json.dumps(result, indent=2)}"
-                return [[message.strip(), error_msg]]
+                return f"❌ No choices in response: {json.dumps(result, indent=2)}"
         else:
-            error_msg = f"❌ HTTP {response.status_code}: {response.text}"
-            return [[message.strip(), error_msg]]
+            return f"❌ HTTP {response.status_code}: {response.text}"
             
     except requests.exceptions.Timeout:
-        return [[message.strip(), "❌ Request timeout (30s)"]]
+        return "❌ Request timeout (30s)"
     except requests.exceptions.ConnectionError:
-        return [[message.strip(), "❌ Connection error - cannot reach Groq API"]]
+        return "❌ Connection error - cannot reach Groq API"
     except json.JSONDecodeError:
-        return [[message.strip(), f"❌ Invalid JSON response: {response.text}"]]
+        return f"❌ Invalid JSON response: {response.text}"
     except Exception as e:
-        return [[message.strip(), f"❌ Unexpected error: {str(e)}"]]
-
-def update_chatbot_display() -> List[List[str]]:
-    """Update the chatbot display with the entire chat history"""
-    display_history = []
-    for msg in chat_history:
-        if msg["role"] == "user":
-            display_history.append([msg["content"], None])
-        else:
-            if display_history:  # If there's a previous user message
-                display_history[-1][1] = msg["content"]
-            else:  # If assistant message without user message
-                display_history.append([None, msg["content"]])
-    return display_history
+        return f"❌ Unexpected error: {str(e)}"
 
 def clear_history():
     """Clear the chat history"""
     chat_history.clear()
-    return [], "✅ Chat history cleared"
+    return "✅ Chat history cleared"
 
-def view_history(topic: str = None) -> str:
+def view_history(topic: str = None):
     """View the chat history, optionally filtered by topic"""
     if not chat_history:
         return "❌ No chat history available"
     
     output = "📜 Chat History:\n\n"
     for msg in chat_history:
-        if topic is None or msg.get("topic") == topic:
-            output += f"[{msg['timestamp']}] {msg['role'].capitalize()} ({msg.get('topic', 'N/A')}): {msg['content']}\n\n"
+        if topic is None or msg["topic"] == topic:
+            output += f"[{msg['timestamp']}] {msg['role'].capitalize()} ({msg['topic']}): {msg['content']}\n"
     return output
 
-def manual_curl_example(user_api_key: str = ""):
+def manual_curl_example():
     """Generate curl command for manual testing"""
-    current_api_key = user_api_key.strip() if user_api_key.strip() else API_KEY
-    
-    if not current_api_key:
-        return "❌ No API key to generate curl. Set GROQ_API_KEY in environment or enter it below."
+    if not API_KEY:
+        return "❌ No API key to generate curl"
     
     curl_cmd = f'''curl -X POST "{API_URL}" \\
-  -H "Authorization: Bearer {current_api_key}" \\
+  -H "Authorization: Bearer {API_KEY}" \\
   -H "Content-Type: application/json" \\
   -d '{{
     "model": "llama3-8b-8192",
@@ -182,111 +133,38 @@ def manual_curl_example(user_api_key: str = ""):
 '''
     return curl_cmd
 
-def test_api_connection(user_api_key: str = ""):
-    """Test API connection"""
-    current_api_key = user_api_key.strip() if user_api_key.strip() else API_KEY
-    
-    if not current_api_key:
-        return "❌ No API key provided"
-    
-    try:
-        headers = {
-            "Authorization": f"Bearer {current_api_key}",
-            "Content-Type": "application/json"
-        }
-        
-        payload = {
-            "model": "llama3-8b-8192",
-            "messages": [{"role": "user", "content": "Test connection"}],
-            "max_tokens": 10
-        }
-        
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=10)
-        
-        if response.status_code == 200:
-            return f"✅ API connection successful! Status: {response.status_code}"
-        else:
-            return f"❌ API error: {response.status_code} - {response.text}"
-            
-    except Exception as e:
-        return f"❌ Connection test failed: {str(e)}"
-
 # Create Gradio interface
-with gr.Blocks(title="Groq Debug with Memory", css="""
-    .chatbot-container { max-height: 500px; overflow-y: auto; }
-    .input-container { position: sticky; bottom: 0; background: white; padding: 10px; }
-""") as demo:
+with gr.Blocks(title="Groq Debug with Memory") as demo:
     gr.Markdown("# 🔍 Groq API Debug Tool with Memory")
     
-    # Global API key input
-    with gr.Row():
-        global_api_key = gr.Textbox(
-            label="API Key (Optional - if not set in environment)",
-            placeholder="Enter your Groq API key here...",
-            type="password",
-            scale=3
-        )
-        test_button = gr.Button("Test Connection", scale=1)
-        
-    connection_status = gr.Textbox(label="Connection Status", interactive=False)
-    
-    test_button.click(
-        test_api_connection,
-        inputs=[global_api_key],
-        outputs=[connection_status]
-    )
-    
     with gr.Tab("Chat with Memory"):
         gr.Markdown("Chat with Groq, maintain history, and summarize by topic")
         
-        chatbot = gr.Chatbot(
-            label="Conversation",
-            container=True,
-            height=500,
-            elem_classes="chatbot-container",
-            bubble_full_width=False
+        chat_input = gr.Textbox(
+            label="Message",
+            placeholder="Enter your message",
+            value="Hello, how can you help me today?"
         )
-        with gr.Row(elem_classes="input-container"):
-            chat_input = gr.Textbox(
-                label="Message",
-                placeholder="Enter your message",
-                value="Hello, how can you help me today?",
-                show_label=False,
-                container=False,
-                scale=3
-            )
-            topic_input = gr.Textbox(
-                label="Topic",
-                placeholder="Topic (e.g., 'coding')",
-                value="general",
-                show_label=False,
-                container=False,
-                scale=1
-            )
-            summarize_checkbox = gr.Checkbox(
-                label="Summarize",
-                value=False,
-                scale=1
-            )
-            chat_button = gr.Button("Send", variant="primary", scale=1)
-        
-        def chat_and_update(message, topic, summarize, api_key):
-            # Get the new chat entry
-            new_chat = groq_with_memory(message, topic, summarize, user_api_key=api_key)
-            # Return updated chatbot display and clear input
-            return update_chatbot_display(), ""
-        
-        chat_button.click(
-            chat_and_update,
-            inputs=[chat_input, topic_input, summarize_checkbox, global_api_key],
-            outputs=[chatbot, chat_input]
+        topic_input = gr.Textbox(
+            label="Topic",
+            placeholder="Enter topic (e.g., 'coding', 'general')",
+            value="general"
+        )
+        summarize_checkbox = gr.Checkbox(
+            label="Summarize conversation for this topic",
+            value=False
+        )
+        chat_button = gr.Button("Send Message", variant="primary")
+        chat_output = gr.Textbox(
+            label="Response",
+            lines=10,
+            max_lines=20
         )
         
-        # Enable Enter key
-        chat_input.submit(
-            chat_and_update,
-            inputs=[chat_input, topic_input, summarize_checkbox, global_api_key],
-            outputs=[chatbot, chat_input]
+        chat_button.click(
+            groq_with_memory,
+            inputs=[chat_input, topic_input, summarize_checkbox],
+            outputs=[chat_output]
         )
     
     with gr.Tab("View History"):
@@ -296,10 +174,8 @@ with gr.Blocks(title="Groq Debug with Memory", css="""
             label="Filter by Topic (optional)",
             placeholder="Enter topic to filter (leave blank for all)"
         )
-        with gr.Row():
-            history_button = gr.Button("View History")
-            clear_button = gr.Button("Clear History", variant="secondary")
-        
+        history_button = gr.Button("View History")
+        clear_button = gr.Button("Clear History", variant="secondary")
         history_output = gr.Textbox(
             label="Chat History",
             lines=10,
@@ -311,14 +187,9 @@ with gr.Blocks(title="Groq Debug with Memory", css="""
             inputs=[history_topic],
             outputs=[history_output]
         )
-        
-        def clear_and_update():
-            clear_history()
-            return [], "✅ Chat history cleared"
-        
         clear_button.click(
-            clear_and_update,
-            outputs=[chatbot, history_output]
+            clear_history,
+            outputs=[history_output]
         )
     
     with gr.Tab("Manual Test"):
@@ -332,57 +203,28 @@ with gr.Blocks(title="Groq Debug with Memory", css="""
         
         curl_button.click(
             manual_curl_example,
-            inputs=[global_api_key],
             outputs=[curl_output]
         )
     
-    with gr.Tab("Debug Info"):
-        gr.Markdown("**System Information & Troubleshooting**")
-        
-        debug_button = gr.Button("Show Debug Info")
-        debug_output = gr.JSON(label="Debug Information")
-        
-        def show_debug_info():
-            status = get_api_key_status()
-            debug_info = {
-                "api_key_status": status,
-                "api_url": API_URL,
-                "available_env_vars": list(os.environ.keys()),
-                "python_version": os.sys.version,
-                "current_directory": os.getcwd()
-            }
-            return debug_info
-        
-        debug_button.click(
-            show_debug_info,
-            outputs=[debug_output]
-        )
-        
+    with gr.Tab("API Info"):
         gr.Markdown(f"""
-        **Setup Instructions:**
-        
-        **For Hugging Face Spaces:**
-        1. Go to your Space Settings
-        2. Click on "Secrets" tab  
-        3. Add new secret: `GROQ_API_KEY` = your_api_key_here
-        4. Restart the space
-        
-        **For Local Development:**
-        ```bash
-        export GROQ_API_KEY="your_api_key_here"
-        python app.py
-        ```
-        
-        **Get API Key:**
-        - Visit: https://console.groq.com/keys
-        - Create account and generate API key
-        
-        **Troubleshooting:**
-        - ✅ API Key Status: {'Found' if API_KEY else 'Missing'}
-        - ✅ Running in HF Spaces: {is_hf_spaces}
-        - ✅ API URL: `{API_URL}`
-        
-        **Alternative:** Enter your API key in the field above for temporary testing.
+        **Debug Information:**
+        - API URL: `{API_URL}`
+        - API Key Status: {'✅ Found' if API_KEY else '❌ Missing'}
+        - API Key Preview: `{API_KEY[:10] + '...' if API_KEY else 'None'}`
+        
+        **Common Issues:**
+        1. **Wrong URL** - Make sure using correct Groq endpoint
+        2. **Invalid Model** - Check if model name is correct
+        3. **Malformed Request** - Check JSON structure
+        4. **Rate Limiting** - Wait between requests
+        5. **Network Issues** - Check HF Spaces connectivity
+        
+        **Expected Models:**
+        - `llama3-8b-8192`
+        - `llama3-70b-8192`
+        - `mixtral-8x7b-32768`
+        - `gemma-7b-it`
         """)
 
 if __name__ == "__main__":