test 1

app.py

@@ -1,169 +1,51 @@
-import gradio as gr
-import openai
-import anthropic
-import google.generativeai as genai
-import os
-import asyncio
-import logging
-from dotenv import load_dotenv
+python import os from fastapi import FastAPI, Request from pydantic import BaseModel from fastapi.responses import JSONResponse import httpx # using httpx for the OpenAI API request
 
-# Set up logging to diagnose initialization issues
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+app = FastAPI()
 
-# Load environment variables
-load_dotenv()
-try:
-    openai.api_key = os.getenv("OPENAI_API_KEY")
-    anthropic_client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
-    genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
-    logger.info("Environment variables loaded successfully")
-except Exception as e:
-    logger.error(f"Error loading environment variables: {str(e)}")
-    raise
-
-# Initialize conversation history
-def initialize_chat():
-    return [{"role": "system", "content": "You are a helpful assistant."}]
-
-# Async functions for API calls
-async def get_openai_response(messages):
-    try:
-        response = await asyncio.get_event_loop().run_in_executor(
-            None,
-            lambda: openai.ChatCompletion.create(
-                model="gpt-3.5-turbo",
-                messages=messages,
-                temperature=0.7,
-                max_tokens=1000
-            )
-        )
-        return "ChatGPT (OpenAI)", response.choices[0].message["content"]
-    except Exception as e:
-        logger.error(f"OpenAI error: {str(e)}")
-        return "ChatGPT (OpenAI)", f"Error: {str(e)}"
+class QueryRequest(BaseModel): query: str provider: str # e.g., "openai", "anthropic", "gemini"
 
-async def get_claude_response(messages):
-    try:
-        user_message = messages[-1]["content"]
-        response = await asyncio.get_event_loop().run_in_executor(
-            None,
-            lambda: anthropic_client.messages.create(
-                model="claude-3-5-sonnet-20241022",
-                max_tokens=1000,
-                temperature=0.7,
-                messages=[{"role": "user", "content": user_message}]
-            )
-        )
-        return "Claude (Anthropic)", response.content[0].text
-    except Exception as e:
-        logger.error(f"Claude error: {str(e)}")
-        return "Claude (Anthropic)", f"Error: {str(e)}"
+@app.get("/") def read_root(): return {"message": "Multi-Model Selector is running"}
 
-async def get_gemini_response(messages):
-    try:
-        model = genai.GenerativeModel("gemini-1.5-pro")
-        user_message = messages[-1]["content"]
-        response = await asyncio.get_event_loop().run_in_executor(
-            None,
-            lambda: model.generate_content(
-                user_message,
-                generation_config={"max_output_tokens": 1000, "temperature": 0.7}
-            )
-        )
-        return "Gemini (Google)", response.text
-    except Exception as e:
-        logger.error(f"Gemini error: {str(e)}")
-        return "Gemini (Google)", f"Error: {str(e)}"
+@app.post("/ask") async def ask_question(request: QueryRequest): query = request.query provider = request.provider.lower()
 
-# Main async function to query selected models
-async def query_selected_models(message, history, use_openai, use_claude, use_gemini):
-    if not any([use_openai, use_claude, use_gemini]):
-        return "Please select at least one model.", history
-
-    # Initialize or retrieve conversation history
-    if not history:
-        messages = initialize_chat()
+try:
+    if provider == "openai":
+        return await ask_openai(query)
+    elif provider == "anthropic":
+        return {"error": "Anthropic support not implemented yet"}
+    elif provider == "gemini":
+        return {"error": "Gemini support not implemented yet"}
     else:
-        messages = initialize_chat() + [
-            {"role": "user" if i % 2 == 0 else "assistant", "content": msg[0] if i % 2 == 0 else msg[1]}
-            for i, msg in enumerate(history)
-        ]
-
-    # Append new user message
-    messages.append({"role": "user", "content": message})
-
-    # Create tasks for selected models
-    tasks = []
-    if use_openai:
-        tasks.append(get_openai_response(messages))
-    if use_claude:
-        tasks.append(get_claude_response(messages))
-    if use_gemini:
-        tasks.append(get_gemini_response(messages))
-
-    # Run selected API calls concurrently
-    try:
-        responses = await asyncio.gather(*tasks, return_exceptions=True)
-    except Exception as e:
-        logger.error(f"Error in asyncio.gather: {str(e)}")
-        return f"Error querying models: {str(e)}", history
+        return JSONResponse(content={"error": f"Unknown provider: {provider}"}, status_code=400)
+except Exception as e:
+    return JSONResponse(content={"error": str(e)}, status_code=500)
+async def ask_openai(query: str): # Define the OpenAI API key openai_api_key = os.getenv("OPENAI_API_KEY")
 
-    # Format responses
-    response_text = ""
-    for model_name, response in responses:
-        response_text += f"**{model_name}**:\n{response}\n\n"
+if not openai_api_key:
+    return {"error": "API key not provided."}
 
-    # Update history
-    history.append((message, response_text.strip()))
-    logger.info("Query processed successfully")
+headers = {
+    "Authorization": f"Bearer {openai_api_key}",
+    "Content-Type": "application/json"
+}
 
-    return "", history
+payload = {
+    "model": "gpt-3.5-turbo",
+    "messages": [{"role": "user", "content": query}]
+}
 
-# Gradio interface
 try:
-    with gr.Blocks(theme=gr.themes.Soft(), title="Multi-Model AI Selector") as demo:
-        gr.Markdown(
-            """
-            # Multi-Model AI Chat Interface
-            Select one or more models to query and enter your question below. Responses will appear in the chat window.
-            """
-        )
-        
-        # Model selection checkboxes
-        with gr.Row():
-            use_openai = gr.Checkbox(label="ChatGPT (OpenAI)", value=True)
-            use_claude = gr.Checkbox(label="Claude (Anthropic)", value=True)
-            use_gemini = gr.Checkbox(label="Gemini (Google)", value=True)
-
-        # Chat interface
-        chatbot = gr.Chatbot(label="Conversation", height=400)
-        msg = gr.Textbox(placeholder="Type your query...", label="Your Query")
-        with gr.Row():
-            submit = gr.Button("Submit Query")
-            clear = gr.Button("Clear Chat")
-
-        # Bind query function to submit button and textbox (Enter key)
-        submit.click(
-            fn=query_selected_models,
-            inputs=[msg, chatbot, use_openai, use_claude, use_gemini],
-            outputs=[msg, chatbot]
-        )
-        msg.submit(
-            fn=query_selected_models,
-            inputs=[msg, chatbot, use_openai, use_claude, use_gemini],
-            outputs=[msg, chatbot]
-        )
-
-        # Clear chat history
-        clear.click(
-            fn=lambda: (None, []),
-            inputs=None,
-            outputs=[msg, chatbot]
-        )
-    logger.info("Gradio interface initialized successfully")
+    async with httpx.AsyncClient() as client:
+        response = await client.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
+    
+    # Check for success status
+    response.raise_for_status()
+
+    # Extract the answer
+    answer = response.json()['choices'][0]['message']['content']
+    return {"response": answer}
+
+except httpx.HTTPStatusError as e:
+    return {"error": f"HTTP Status Error: {e.response.status_code}, {e.response.text}"}
 except Exception as e:
-    logger.error(f"Error initializing Gradio interface: {str(e)}")
-    raise
-
-# Do not include demo.launch() for Hugging Face Spaces
+    return {"error": f"An error occurred: {str(e)}"}

requirements.txt

@@ -1,6 +1,7 @@
-gradio==4.42.0
-openai==1.51.0
-anthropic==0.37.1
-google-generativeai==0.8.3
-python-dotenv==1.0.1
-httpx==0.27.2
+fastapi
+uvicorn
+openai
+google-generativeai
+anthropic
+python-dotenv
+requests