OpenAI Anthropic Gemini vertical

app.py

@@ -198,94 +198,127 @@ async def ask_gemini(query: str, history: List[Dict[str, str]]) -> str:
         logger.error(f"Gemini Error: {str(e)}\nStack trace: {traceback.format_exc()}")
         return f"Error: Gemini Error: {str(e)}"
 
-async def query_model(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]]], None]:
+async def query_model(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]], List[Dict[str, str]]], None]:
     logger.info(f"Processing query with providers: {providers}")
-    responses = []  # To collect responses from each provider
-    streaming_response = ""
+    openai_response = ""
+    anthropic_response = ""
+    gemini_response = ""
+    
+    # Initialize chatbot messages for each provider
+    openai_messages = []
+    anthropic_messages = []
+    gemini_messages = []
+    
+    # Populate history for each chatbot
+    for msg in history:
+        openai_messages.append({"role": "user", "content": msg["user"]})
+        anthropic_messages.append({"role": "user", "content": msg["user"]})
+        gemini_messages.append({"role": "user", "content": msg["user"]})
+        if msg["bot"]:
+            # Parse the combined response to extract provider-specific responses
+            lines = msg["bot"].split("\n\n")
+            for line in lines:
+                if line.startswith("[OpenAI]:"):
+                    openai_messages.append({"role": "assistant", "content": line[len("[OpenAI]:"):].strip()})
+                elif line.startswith("[Anthropic]:"):
+                    anthropic_messages.append({"role": "assistant", "content": line[len("[Anthropic]:"):].strip()})
+                elif line.startswith("[Gemini]:"):
+                    gemini_messages.append({"role": "assistant", "content": line[len("[Gemini]:"):].strip()})
 
     # Handle OpenAI (streaming)
     if "OpenAI" in providers:
+        openai_messages.append({"role": "user", "content": query})
         async for chunk in ask_openai(query, history):
-            streaming_response += chunk
+            openai_response += chunk
             # Yield streaming updates for OpenAI
-            chatbot_messages = []
-            for msg in history:
-                chatbot_messages.append({"role": "user", "content": msg["user"]})
-                if msg["bot"]:
-                    chatbot_messages.append({"role": "assistant", "content": msg["bot"]})
-            chatbot_messages.append({"role": "user", "content": query})
-            chatbot_messages.append({"role": "assistant", "content": streaming_response})
-            yield "", chatbot_messages, history  # Yield partial updates
-        if streaming_response.strip():
-            responses.append(f"[OpenAI]: {streaming_response}")
+            openai_messages[-1] = {"role": "assistant", "content": openai_response}
+            yield "", openai_messages, anthropic_messages, gemini_messages
+        if openai_response.strip() and not openai_response.startswith("Error:"):
+            openai_messages[-1] = {"role": "assistant", "content": openai_response}
 
     # Handle Anthropic (non-streaming)
     if "Anthropic" in providers:
-        response = await ask_anthropic(query, history)
-        if response.strip() and not response.startswith("Error:"):
-            responses.append(f"[Anthropic]: {response}")
+        anthropic_messages.append({"role": "user", "content": query})
+        anthropic_response = await ask_anthropic(query, history)
+        if anthropic_response.strip() and not anthropic_response.startswith("Error:"):
+            anthropic_messages.append({"role": "assistant", "content": anthropic_response})
 
     # Handle Gemini (non-streaming)
     if "Gemini" in providers:
-        response = await ask_gemini(query, history)
-        if response.strip() and not response.startswith("Error:"):
-            responses.append(f"[Gemini]: {response}")
+        gemini_messages.append({"role": "user", "content": query})
+        gemini_response = await ask_gemini(query, history)
+        if gemini_response.strip() and not gemini_response.startswith("Error:"):
+            gemini_messages.append({"role": "assistant", "content": gemini_response})
 
-    # Combine responses
+    # Combine responses for history
+    responses = []
+    if openai_response.strip() and not openai_response.startswith("Error:"):
+        responses.append(f"[OpenAI]: {openai_response}")
+    if anthropic_response.strip() and not anthropic_response.startswith("Error:"):
+        responses.append(f"[Anthropic]: {anthropic_response}")
+    if gemini_response.strip() and not gemini_response.startswith("Error:"):
+        responses.append(f"[Gemini]: {gemini_response}")
+    
     combined_response = "\n\n".join(responses) if responses else "No valid responses received."
-    # Update history with the combined response
     updated_history = history + [{"user": query, "bot": combined_response}]
     logger.info(f"Updated history: {updated_history}")
 
     # Yield final response
-    chatbot_messages = []
-    for msg in updated_history:
-        chatbot_messages.append({"role": "user", "content": msg["user"]})
-        if msg["bot"]:
-            chatbot_messages.append({"role": "assistant", "content": msg["bot"]})
-    yield "", chatbot_messages, updated_history
+    yield "", openai_messages, anthropic_messages, gemini_messages
 
-async def submit_query(query: str, providers: List[str], history: List[Dict[str, str]]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]]], None]:
+async def submit_query(query: str, providers: List[str]) -> AsyncGenerator[Tuple[str, List[Dict[str, str]], List[Dict[str, str]], List[Dict[str, str]]], None]:
     if not query.strip():
-        chatbot_messages = [{"role": "assistant", "content": "Please enter a query."}]
-        yield "", chatbot_messages, history
+        openai_messages = [{"role": "assistant", "content": "Please enter a query."}]
+        anthropic_messages = [{"role": "assistant", "content": "Please enter a query."}]
+        gemini_messages = [{"role": "assistant", "content": "Please enter a query."}]
+        yield "", openai_messages, anthropic_messages, gemini_messages
         return
     
     if not providers:
-        chatbot_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
-        yield "", chatbot_messages, history
+        openai_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
+        anthropic_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
+        gemini_messages = [{"role": "assistant", "content": "Please select at least one provider."}]
+        yield "", openai_messages, anthropic_messages, gemini_messages
         return
 
-    async for response_chunk, chatbot_messages, updated_history in query_model(query, providers, history):
-        yield "", chatbot_messages, updated_history  # Keep query textbox unchanged during streaming
+    # Initialize history
+    history = []
+    
+    async for response_chunk, openai_messages, anthropic_messages, gemini_messages in query_model(query, providers, history):
+        yield "", openai_messages, anthropic_messages, gemini_messages
     # Final yield to clear the query textbox
-    yield "", chatbot_messages, updated_history
+    yield "", openai_messages, anthropic_messages, gemini_messages
 
 # Gradio interface
 def clear_history():
-    return [], []
+    return [], [], []
 
 # Define Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# Multi-Model Chat")
-    gr.Markdown("Chat with OpenAI, Anthropic, or Gemini. Select providers and start typing!")
+    gr.Markdown("Chat with OpenAI, Anthropic, or Gemini. Select providers and compare responses side by side!")
     
     providers = gr.CheckboxGroup(choices=["OpenAI", "Anthropic", "Gemini"], label="Select Providers", value=["OpenAI"])
-    history_state = gr.State(value=[])
-    chatbot = gr.Chatbot(label="Conversation", type="messages")
     query = gr.Textbox(label="Enter your query", placeholder="e.g., What is the capital of the United States?")
-    submit_button = gr.Button("Submit")
-    clear_button = gr.Button("Clear History")
+    
+    with gr.Row():
+        openai_chatbot = gr.Chatbot(label="OpenAI", type="messages", scale=1)
+        anthropic_chatbot = gr.Chatbot(label="Anthropic", type="messages", scale=1)
+        gemini_chatbot = gr.Chatbot(label="Gemini", type="messages", scale=1)
+    
+    with gr.Row():
+        submit_button = gr.Button("Submit")
+        clear_button = gr.Button("Clear History")
 
     submit_button.click(
         fn=submit_query,
-        inputs=[query, providers, history_state],
-        outputs=[query, chatbot, history_state]
+        inputs=[query, providers],
+        outputs=[query, openai_chatbot, anthropic_chatbot, gemini_chatbot]
     )
     clear_button.click(
         fn=clear_history,
         inputs=[],
-        outputs=[chatbot, history_state]
+        outputs=[openai_chatbot, anthropic_chatbot, gemini_chatbot]
     )
 
 # Launch the Gradio app