Update app.py

app.py

@@ -1,143 +1,120 @@
-from gradio_client import Client
 import gradio as gr
-import random
+import requests
+import json
 
-# Hidden server configuration
-SERVERS = [
-    "BICORP/GOGOGOGO",
-    "BICORP/server-2",
-    "BICORP/server-3", 
-    "BICORP/server-4",
-    "BICORP/server-5",
-    "BICORP/server-6"
-]
+# --- API Configuration ---
+BLACKBOX_URL = "https://api.blackbox.ai/api/chat"
 
-MODELS = [
-    "Lake 1 Base",
-    "Lake 1 Advanced",
-    "Lake 2 Chat [Closed Alpha]",
-    "Lake 2 Base [Closed Beta]",
-    "Lake 2 Pro [Planned]"
-]
+# --- Model Configuration ---
+api_models = {
+    "Lake 1 Mini": "mistralai/Mistral-Small-24B-Instruct-2501",
+    "Lake 1 Base": "databricks/dbrx-instruct",
+    "Lake 1 Chat": "deepseek-ai/deepseek-llm-67b-chat",
+}
 
-PRESETS = ["Fast", "Normal", "Quality", "Unreal Performance"]
+# --- Default Settings ---
+DEFAULT_SETTINGS = {
+    'tpm': 600,  # tokens per minute
+    'rpm': 7,   # requests per minute
+    'preset': 'Normal'
+}
 
-def get_random_server():
-    """Randomly select from available servers"""
-    return random.choice(SERVERS)
-
-def get_model_info(model_name: str) -> str:
-    """Fetch model specs with retry logic"""
-    max_retries = 2
-    for _ in range(max_retries):
+def call_blackbox_api(prompt: str, model: str, max_new_tokens: int) -> str:
+    headers = {'Content-Type': 'application/json'}
+    payload = json.dumps({
+        "messages": [{"role": "user", "content": prompt}],
+        "model": model,
+        "max_tokens": str(max_new_tokens)
+    })
+    response = requests.post(BLACKBOX_URL, headers=headers, data=payload)
+    if response.status_code == 200 and "application/json" in response.headers.get('Content-Type', ''):
         try:
-            client = Client(get_random_server())
-            return client.predict(model_name, api_name="/get_model_info")
+            data = response.json()
+            if 'choices' in data and data['choices']:
+                return data['choices'][0]['message']['content']
+            else:
+                return "Error: Unexpected response format."
         except Exception as e:
-            continue
-    return "⚠️ Failed to load specifications. Please try again later."
+            return f"Error parsing JSON: {e}"
+    else:
+        return f"{response.text}"
 
-def handle_chat(message: str, history, model: str, preset: str):
-    """Process chat messages with automatic server selection"""
-    try:
-        client = Client(get_random_server())
-        result = client.predict(
-            message,
-            model,
-            preset,
-            api_name="/chat"
-        )
-        return result
-    except Exception as e:
-        return "⚠️ Service unavailable. Please try your request again."
+def generate_response(message: str, model_name: str, preset: str) -> str:
+    max_tokens = DEFAULT_SETTINGS['tpm']
+    api_model = api_models[model_name]
+    return call_blackbox_api(message, model=api_model, max_new_tokens=max_tokens)
 
-def respond(message, history, model, preset):
-    """
-    Append the user's message and model's response to the conversation history.
-    Returns an empty string (to clear the input textbox) and the updated chat history.
-    """
-    history = history or []
-    response = handle_chat(message, history, model, preset)
-    history.append((message, response))
-    return "", history
+def chat_handler(message, history, settings_state):
+    model = settings_state.get("model", "Lake 1 Mini")
+    preset = settings_state.get("preset", "Normal")
+    response = generate_response(message, model, preset)
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": response})
+    return history
 
-with gr.Blocks(title="BI Corp AI Assistant", theme="soft") as demo:
-    gr.Markdown("# <center>🏔️ BI Corp AI Assistant</center>")
-    gr.Markdown("### <center>Enterprise-Grade AI Solutions</center>")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            model_dropdown = gr.Dropdown(
-                label="🤖 Model Selection",
-                choices=MODELS,
-                value=MODELS[0],
-                interactive=True
-            )
-            preset_dropdown = gr.Dropdown(
-                label="⚙️ Performance Preset",
-                choices=PRESETS,
-                value=PRESETS[0],
-                interactive=True
-            )
-            model_info = gr.Markdown(
-                value=get_model_info(MODELS[0]),
-                label="📝 Model Specifications"
-            )
+def update_settings(model, preset):
+    new_state = {"model": model, "preset": preset}
+    settings_text = f"Model: **{model}**, Preset: **{preset}**"
+    return new_state, settings_text
+
+def create_interface():
+    with gr.Blocks(title="Lake AI Assistant", theme="soft") as demo:
+        settings_state = gr.State(value={"model": "Lake 1 Mini", "preset": "Normal"})
         
-        with gr.Column(scale=3):
-            # Reduced the height of the Chatbot to keep the textbox visible.
-            chatbot = gr.Chatbot(
-                height=300,
-                label="💬 Conversation",
-                show_copy_button=True
-            )
-            message_input = gr.Textbox(
-                placeholder="Type your message...",
-                container=True,
-                scale=7,
-                autofocus=True
-            )
-            send_button = gr.Button("🚀 Send", variant="primary")
-    
-    # Update the model specifications when a different model is selected.
-    model_dropdown.change(
-        fn=get_model_info,
-        inputs=model_dropdown,
-        outputs=model_info,
-        queue=False
-    )
-    
-    # Wire the Send button and Enter key in the Textbox to process chat messages.
-    send_button.click(
-        fn=respond,
-        inputs=[message_input, chatbot, model_dropdown, preset_dropdown],
-        outputs=[message_input, chatbot],
-        queue=True
-    )
-    
-    # Allow the Enter key in the textbox to trigger the same function.
-    message_input.submit(
-        fn=respond,
-        inputs=[message_input, chatbot, model_dropdown, preset_dropdown],
-        outputs=[message_input, chatbot],
-        queue=True
-    )
-    
-    # Clear history button to reset the conversation.
-    clear_btn = gr.Button("🧹 Clear History")
-    clear_btn.click(
-        fn=lambda: ("", []),
-        inputs=[],
-        outputs=[message_input, chatbot],
-        queue=False
-    )
+        with gr.Tabs():      
+            with gr.Tab("Chat"):
+                gr.Markdown("## Chat with Lake AI Assistant")
+                chatbot = gr.Chatbot(label="💬 Conversation", height=400, show_copy_button=True, type="messages")
+                chat_input = gr.Textbox(label="Your Message", placeholder="Type your message here...", interactive=True)
+                send_button = gr.Button("Send")
+                donate_button = gr.Button("Donate ☕")
+                
+                send_button.click(
+                    fn=chat_handler,
+                    inputs=[chat_input, chatbot, settings_state],
+                    outputs=chatbot
+                )
+                chat_input.submit(
+                    fn=chat_handler,
+                    inputs=[chat_input, chatbot, settings_state],
+                    outputs=chatbot
+                )
+                # Corrected donation button implementation
+                donate_button.click(
+                    fn=None,
+                    inputs=None,
+                    outputs=None,
+                    js="window.open('https://buymeacoffee.com/bronio_int', '_blank')"
+                )
+
+            with gr.Tab("Settings"):
+                gr.Markdown("## Settings")
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Model & Performance")
+                        model_dropdown = gr.Dropdown(
+                            label="Model Selection",
+                            interactive=True,
+                            choices=["Lake 1 Mini", "Lake 1 Base", "Lake 1 Chat"],
+                            value="Lake 1 Mini"
+                        )
+                        preset_dropdown = gr.Dropdown(
+                            label="Performance Preset",
+                            interactive=True,
+                            choices=["Fast", "Normal", "Quality"],
+                            value="Normal"
+                        )
+                        update_settings_button = gr.Button("Update Settings")
+                        settings_info = gr.Markdown("")
+                
+                update_settings_button.click(
+                    fn=update_settings,
+                    inputs=[model_dropdown, preset_dropdown],
+                    outputs=[settings_state, settings_info]
+                )
     
-    # Initialize model specifications on app load.
-    demo.load(
-        fn=lambda: get_model_info(MODELS[0]),
-        outputs=model_info,
-        queue=False
-    )
+    return demo
 
 if __name__ == "__main__":
-    demo.launch()
+    demo = create_interface()
+    demo.launch()