Working files locally testing

app.py

@@ -1,8 +1,21 @@
 import os
+import logging
 from fastapi import FastAPI, Request
 from pydantic import BaseModel
 from fastapi.responses import JSONResponse
 import httpx
+from dotenv import load_dotenv
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables from .env file
+load_dotenv()
+logger.info("Environment variables loaded from .env file")
+logger.info(f"OPENAI_API_KEY present: {'OPENAI_API_KEY' in os.environ}")
+logger.info(f"ANTHROPIC_API_KEY present: {'ANTHROPIC_API_KEY' in os.environ}")
+logger.info(f"GEMINI_API_KEY present: {'GEMINI_API_KEY' in os.environ}")
 
 app = FastAPI()
 
@@ -23,19 +36,20 @@ async def ask_question(request: QueryRequest):
         if provider == "openai":
             return await ask_openai(query)
         elif provider == "anthropic":
-            return {"error": "Anthropic support not implemented yet"}
+            return await ask_anthropic(query)
         elif provider == "gemini":
-            return {"error": "Gemini support not implemented yet"}
+            return await ask_gemini(query)
         else:
             return JSONResponse(content={"error": f"Unknown provider: {provider}"}, status_code=400)
     except Exception as e:
+        logger.error(f"Error processing request: {str(e)}")
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
 async def ask_openai(query: str):
     openai_api_key = os.getenv("OPENAI_API_KEY")
-
     if not openai_api_key:
-        return {"error": "API key not provided."}
+        logger.error("OpenAI API key not provided")
+        return {"error": "OpenAI API key not provided."}
 
     headers = {
         "Authorization": f"Bearer {openai_api_key}",
@@ -56,6 +70,76 @@ async def ask_openai(query: str):
         return {"response": answer}
 
     except httpx.HTTPStatusError as e:
-        return {"error": f"HTTP Status Error: {e.response.status_code}, {e.response.text}"}
+        logger.error(f"OpenAI HTTP Status Error: {e.response.status_code}, {e.response.text}")
+        return {"error": f"OpenAI HTTP Status Error: {e.response.status_code}, {e.response.text}"}
+    except Exception as e:
+        logger.error(f"OpenAI Error: {str(e)}")
+        return {"error": f"OpenAI Error: {str(e)}"}
+
+async def ask_anthropic(query: str):
+    anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not anthropic_api_key:
+        logger.error("Anthropic API key not provided")
+        return {"error": "Anthropic API key not provided."}
+
+    headers = {
+        "x-api-key": anthropic_api_key,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "model": "claude-3-5-sonnet-20241022",
+        "max_tokens": 1024,
+        "messages": [{"role": "user", "content": query}]
+    }
+
+    try:
+        async with httpx.AsyncClient() as client:
+            logger.info(f"Sending Anthropic request: {payload}")
+            response = await client.post("https://api.anthropic.com/v1/messages", headers=headers, json=payload)
+        
+        response.raise_for_status()
+        logger.info(f"Anthropic response: {response.json()}")
+        answer = response.json()['content'][0]['text']
+        return {"response": answer}
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"Anthropic HTTP Status Error: {e.response.status_code}, {e.response.text}")
+        return {"error": f"Anthropic HTTP Status Error: {e.response.status_code}, {e.response.text}"}
+    except Exception as e:
+        logger.error(f"Anthropic Error: {str(e)}")
+        return {"error": f"Anthropic Error: {str(e)}"}
+
+async def ask_gemini(query: str):
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    if not gemini_api_key:
+        logger.error("Gemini API key not provided")
+        return {"error": "Gemini API key not provided."}
+
+    headers = {
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "contents": [{"parts": [{"text": query}]}]
+    }
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={gemini_api_key}",
+                headers=headers,
+                json=payload
+            )
+        
+        response.raise_for_status()
+        answer = response.json()['candidates'][0]['content']['parts'][0]['text']
+        return {"response": answer}
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"Gemini HTTP Status Error: {e.response.status_code}, {e.response.text}")
+        return {"error": f"Gemini HTTP Status Error: {e.response.status_code}, {e.response.text}"}
     except Exception as e:
-        return {"error": f"An error occurred: {str(e)}"}
+        logger.error(f"Gemini Error: {str(e)}")
+        return {"error": f"Gemini Error: {str(e)}"}