Create app.py

app.py

@@ -0,0 +1,226 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "gradio>=4.25.0",
+#     "requests>=2.32.2",
+#     "groq>=0.5.0",
+#     "python-dotenv>=1.0.0",
+# ]
+# ///
+
+import gradio as gr
+import requests
+import json
+import os
+from groq import Groq
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Initialize global variables
+reasoning_history = []
+ENV_DEEPSEEK_KEY = os.getenv("DEEPSEEK_API_KEY", "")
+ENV_GROQ_KEY = os.getenv("GROQ_API_KEY", "")
+
+def validate_keys(deepseek_key, groq_key):
+    """Validate API keys and return appropriate message"""
+    if not deepseek_key or not groq_key:
+        missing = []
+        if not deepseek_key:
+            missing.append("DeepSeek")
+        if not groq_key:
+            missing.append("Groq")
+        return False, f"Missing API key(s) for: {', '.join(missing)}. Please configure keys."
+    return True, "Keys configured successfully!"
+
+def process_deepseek(message, api_key):
+    if not api_key:
+        raise ValueError("DeepSeek API key not configured")
+        
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    data = {
+        "model": "deepseek-reasoner",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": message}
+        ],
+        "stream": True,
+        "max_tokens": 1
+    }
+    
+    response = requests.post(
+        "https://api.deepseek.com/chat/completions",
+        headers=headers,
+        json=data,
+        stream=True
+    )
+    
+    reasoning = []
+    for line in response.iter_lines():
+        if line:
+            try:
+                cleaned_line = line.decode('utf-8').replace('data: ', '').strip()
+                if cleaned_line == '[DONE]':
+                    continue
+                chunk = json.loads(cleaned_line)
+                if chunk.get('choices'):
+                    content = chunk['choices'][0]['delta'].get('reasoning_content', '')
+                    if content:
+                        reasoning.append(content)
+            except Exception as e:
+                continue
+    
+    return ' '.join(reasoning)
+
+def chat_fn(message, history, deepseek_key, groq_key):
+    # Use environment variables if available, otherwise use UI inputs
+    active_deepseek_key = ENV_DEEPSEEK_KEY or deepseek_key
+    active_groq_key = ENV_GROQ_KEY or groq_key
+    
+    # Validate keys before processing
+    is_valid, validation_message = validate_keys(active_deepseek_key, active_groq_key)
+    if not is_valid:
+        yield {"role": "assistant", "content": validation_message}
+        return
+    
+    try:
+        reasoning = process_deepseek(message, active_deepseek_key)
+    except Exception as e:
+        yield {"role": "assistant", "content": f"DeepSeek API Error: {str(e)}"}
+        return
+    
+    reasoning_history.append(reasoning)
+    
+    groq_prompt = f"""You will be given a query and reasoning steps. 
+    Review the reasoning, thinking through each of the steps and provide a concise answer to the user.
+    
+    <user_query>{message}</user_query>
+    <reasoning>{reasoning}</reasoning>"""
+    
+    try:
+        client = Groq(api_key=active_groq_key)
+        groq_response = client.chat.completions.create(
+            model="llama-3.3-70b-specdec",
+            messages=[{"role": "user", "content": groq_prompt}],
+            temperature=0.7,
+            max_tokens=1024,
+            top_p=1,
+            stream=True,
+        )
+        
+        accumulated_response = ""
+        for chunk in groq_response:
+            part = chunk.choices[0].delta.content or ""
+            accumulated_response += part
+            yield {"role": "assistant", "content": accumulated_response}
+            
+    except Exception as e:
+        yield {"role": "assistant", "content": f"Groq API Error: {str(e)}"}
+
+def show_reasoning():
+    return reasoning_history[-1] if reasoning_history else "No reasoning available"
+
+def toggle_reasoning_visibility(visible):
+    return gr.update(visible=visible)
+
+def show_settings():
+    return gr.update(visible=True)
+
+def hide_settings():
+    return gr.update(visible=False)
+
+# Create the Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Thoughtful Lightning") as demo:
+    # Initialize error banner
+    error_banner = gr.Markdown(visible=False)
+    
+    # Main Interface
+    gr.Markdown("## ⚡ Thoughtful Lightning")
+    gr.Markdown("*Powered by DeepSeek R1 reasoning and Groq's lightning-fast inference*")
+    
+    # Settings Group (Initially Hidden)
+    with gr.Group(visible=False) as settings_group:
+        gr.Markdown("### ⚙️ Settings")
+        gr.Markdown("*Note: Environment variables will be used if available*")
+        with gr.Row():
+            with gr.Column(scale=1):
+                deepseek_key = gr.Textbox(
+                    label="DeepSeek API Key",
+                    type="password",
+                    value="",
+                    placeholder="Enter DeepSeek API key" if not ENV_DEEPSEEK_KEY else "Using key from environment",
+                    info="DeepSeek R1 API key for reasoning"
+                )
+                groq_key = gr.Textbox(
+                    label="Groq API Key",
+                    type="password",
+                    value="",
+                    placeholder="Enter Groq API key" if not ENV_GROQ_KEY else "Using key from environment",
+                    info="Groq API key for fast inference"
+                )
+        with gr.Row():
+            close_btn = gr.Button("Close")
+            settings_status = gr.Markdown()
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            settings_btn = gr.Button("⚙️ Settings")
+            reasoning_btn = gr.Button("🧐 Show Reasoning")
+    
+    with gr.Row():
+        chat_interface = gr.ChatInterface(
+            chat_fn,
+            additional_inputs=[deepseek_key, groq_key],
+            examples=[
+                ["How many r's are in strawberry"],
+                ["Which is greater 9.11 or 9.9"],
+                ["Best way to learn Rust in 2024?"]
+            ]
+        )
+    
+    reasoning_output = gr.Textbox(
+        label="Reasoning Steps",
+        interactive=False,
+        visible=False,
+        lines=8,
+        max_lines=12
+    )
+    
+    # Event handlers
+    settings_btn.click(
+        fn=show_settings,
+        outputs=[settings_group]
+    )
+    
+    close_btn.click(
+        fn=hide_settings,
+        outputs=[settings_group]
+    )
+    
+    reasoning_btn.click(
+        fn=show_reasoning,
+        outputs=reasoning_output
+    ).then(
+        fn=toggle_reasoning_visibility,
+        inputs=[gr.State(True)],
+        outputs=[reasoning_output]
+    )
+
+if __name__ == "__main__":
+    # Create .env file if it doesn't exist
+    if not os.path.exists(".env"):
+        with open(".env", "w") as f:
+            f.write("DEEPSEEK_API_KEY=\nGROQ_API_KEY=\n")
+            
+    # Show error if no keys are configured
+    if not (ENV_DEEPSEEK_KEY or ENV_GROQ_KEY):
+        print("\n⚠️  No API keys found in environment variables.")
+        print("You can either:")
+        print("1. Add them to your .env file")
+        print("2. Configure them in the UI settings\n")
+    
+    demo.queue().launch()