Update app.py

app.py

@@ -1,68 +1,77 @@
 import os
-import time
-import json
+import threading
 import gradio as gr
 from openai import OpenAI
 from dotenv import load_dotenv
 
 # Load API keys from .env file
 load_dotenv()
-OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")  # OpenRouter API Key
-
-# Initialize OpenRouter Client
-openrouter_client = OpenAI(
-    base_url="https://openrouter.ai/api/v1",
-    api_key=OPENROUTER_API_KEY
-)
-
-# Query OpenRouter (Gemma-2-9B)
-def query_gemma_openrouter(user_input):
+API_KEY_LLAMA = os.getenv("OPENROUTER_API_KEY1")  # Llama API Key
+API_KEY_GEMMA = os.getenv("OPENROUTER_API_KEY2")  # Gemma API Key
+API_KEY_DEEPSEEK1 = os.getenv("OPENROUTER_API_KEY3")  # DeepSeek First Query
+API_KEY_DEEPSEEK2 = os.getenv("OPENROUTER_API_KEY4")  # DeepSeek Final Refinement
+
+# Create OpenAI Clients for each model
+llama_client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=API_KEY_LLAMA)
+gemma_client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=API_KEY_GEMMA)
+deepseek_client1 = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=API_KEY_DEEPSEEK1)
+deepseek_client2 = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=API_KEY_DEEPSEEK2)
+
+# Function to query Llama model
+def query_llama(user_input, results):
     try:
-        completion = openrouter_client.chat.completions.create(
-            model="google/gemma-2-9b-it:free",
+        completion = llama_client.chat.completions.create(
+            model="meta-llama/llama-3.2-3b-instruct:free",
             messages=[{"role": "user", "content": user_input}]
         )
-        return completion.choices[0].message.content
+        results["Llama"] = completion.choices[0].message.content
     except Exception as e:
-        return f"Error querying Gemma-2-9B: {str(e)}"
+        results["Llama"] = f"Error: {str(e)}"
 
-# Query OpenRouter (Llama-3.2-3B)
-def query_llama_openrouter(user_input):
+# Function to query Gemma model
+def query_gemma(user_input, results):
     try:
-        completion = openrouter_client.chat.completions.create(
-            model="meta-llama/llama-3.2-3b-instruct:free",
+        completion = gemma_client.chat.completions.create(
+            model="google/gemma-2-9b-it:free",
             messages=[{"role": "user", "content": user_input}]
         )
-        return completion.choices[0].message.content
+        results["Gemma"] = completion.choices[0].message.content
     except Exception as e:
-        return f"Error querying Llama-3.2-3B: {str(e)}"
+        results["Gemma"] = f"Error: {str(e)}"
 
-# Query OpenRouter (DeepSeek-R1)
-def query_deepseek_openrouter(user_input):
+# Function to query DeepSeek for additional context
+def query_deepseek_1(user_input, results):
     try:
-        completion = openrouter_client.chat.completions.create(
+        completion = deepseek_client1.chat.completions.create(
             model="deepseek/deepseek-r1:free",
             messages=[{"role": "user", "content": user_input}]
         )
-        return completion.choices[0].message.content
+        results["DeepSeek1"] = completion.choices[0].message.content
     except Exception as e:
-        return f"Error querying DeepSeek-R1: {str(e)}"
+        results["DeepSeek1"] = f"Error: {str(e)}"
 
-# Function to refine responses using DeepSeek-R1
+# Function to refine responses using DeepSeek-R1 (Final API)
 def refine_response(user_input):
     try:
-        # Get responses from all three models
-        gemma_response = query_gemma_openrouter(user_input)
-        llama_response = query_llama_openrouter(user_input)
-        deepseek_response = query_deepseek_openrouter(user_input)
-
-        # If any response is missing, return the available ones
-        responses = {
-            "Gemma": gemma_response.strip(),
-            "Llama": llama_response.strip(),
-            "DeepSeek-R1": deepseek_response.strip()
-        }
-        valid_responses = {k: v for k, v in responses.items() if v}
+        results = {}
+
+        # Create threads for parallel API calls
+        threads = [
+            threading.Thread(target=query_llama, args=(user_input, results)),
+            threading.Thread(target=query_gemma, args=(user_input, results)),
+            threading.Thread(target=query_deepseek_1, args=(user_input, results))
+        ]
+
+        # Start all threads
+        for thread in threads:
+            thread.start()
+
+        # Wait for all threads to complete
+        for thread in threads:
+            thread.join()
+
+        # Ensure all responses are received
+        valid_responses = {k: v.strip() for k, v in results.items() if v and "Error" not in v}
 
         if len(valid_responses) < 2:
             return "\n\n".join(f"{k} Response: {v}" for k, v in valid_responses.items())
@@ -71,47 +80,34 @@ def refine_response(user_input):
         improvement_prompt = f"""
         Here are three AI-generated responses:
 
-        Response 1 (Gemma): {gemma_response}
-        Response 2 (Llama 3.2): {llama_response}
-        Response 3 (DeepSeek-R1): {deepseek_response}
+        Response 1 (Llama): {results.get("Llama", "N/A")}
+        Response 2 (Gemma): {results.get("Gemma", "N/A")}
+        Response 3 (DeepSeek1): {results.get("DeepSeek1", "N/A")}
 
         Please combine the best elements of all three, improve clarity, and provide a final refined answer.
         """
 
-        # Retry loop for DeepSeek-R1 refinement
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                messages = [{"role": "user", "content": improvement_prompt}]
-                refined_completion = openrouter_client.chat.completions.create(
-                    model="deepseek/deepseek-r1:free",
-                    messages=messages
-                )
-
-                refined_content = refined_completion.choices[0].message.content
-
-                if refined_content.strip():
-                    return refined_content
-                else:
-                    print("Received empty response from DeepSeek-R1, retrying...")
-                    time.sleep(2)
-
-            except Exception as e:
-                print(f"Error on attempt {attempt + 1}: {str(e)}")
-                time.sleep(2)
-
-        return f"Refinement failed. Here’s the best available response:\n\n{max(valid_responses.values(), key=len)}"
+        # Query DeepSeek-R1 for refinement using API key 4
+        try:
+            refined_completion = deepseek_client2.chat.completions.create(
+                model="deepseek/deepseek-r1:free",
+                messages=[{"role": "user", "content": improvement_prompt}]
+            )
+            refined_content = refined_completion.choices[0].message.content
+            return refined_content if refined_content.strip() else "Refinement failed, returning best response."
+        except Exception as e:
+            return f"Error refining response: {str(e)}"
 
     except Exception as e:
-        return f"Error refining response: {str(e)}"
+        return f"Unexpected error: {str(e)}"
 
 # Create Gradio interface
 iface = gr.Interface(
     fn=refine_response, 
     inputs=gr.Textbox(lines=2, placeholder="Ask me anything..."), 
     outputs="text",
-    title="Multi-Model AI Enhancer",
-    description="Get responses from Gemma, Llama-3.2, and DeepSeek-R1. Then receive an improved final answer."
+    title="Multi-Model AI Enhancer (4 API Keys)",
+    description="Llama (API 1) + Gemma (API 2) + DeepSeek (API 3) → Final Refinement with DeepSeek (API 4)"
 )
 
 # Launch app