Update app.py

app.py

@@ -1,98 +1,107 @@
 import os
-import time
-import logging
-from fastapi import FastAPI, Request, HTTPException, Depends
-from fastapi.responses import JSONResponse
-from fastapi.concurrency import run_in_threadpool
-from gradio_client import Client
+import json
+import traceback # Import traceback for detailed error logging
+from fastapi import FastAPI, Request, HTTPException, status # Import status for clearer HTTP status codes
 import uvicorn
-from typing import Dict
-
-# ---------------- CONFIG ----------------
-VALID_API_KEY = os.getenv("APP_API_KEY")       # Your FastAPI security key
-SPACE_API_KEY = os.getenv("SPACE_API_KEY")     # Hugging Face Space key
-SPACE_NAME = os.getenv("SPACE_NAME", "Futuresony/Mr.Events")  # default space
-
-if not VALID_API_KEY or not SPACE_API_KEY:
-    raise RuntimeError("❌ APP_API_KEY and SPACE_API_KEY must be set as environment variables.")
+from gradio_client import Client
 
-# ---------------- LOGGER ----------------
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-)
-logger = logging.getLogger("prod-api")
+# Keys
+VALID_API_KEY = os.getenv("APP_API_KEY") # for your FastAPI security
 
-# ---------------- CLIENT ----------------
-client = Client(SPACE_NAME)
+# Connect to hosted space
+# Ensure this URL is correct and accessible
+GRADIO_SPACE_URL = "Futuresony/Mr.Events"
+try:
+    client = Client(GRADIO_SPACE_URL)
+    print(f"Successfully connected to Gradio Space: {GRADIO_SPACE_URL}")
+except Exception as e:
+    print(f"Error connecting to Gradio Space at {GRADIO_SPACE_URL}: {e}")
+    print(traceback.format_exc())
+    client = None # Set client to None if connection fails
 
-# ---------------- FASTAPI APP ----------------
 app = FastAPI(
-    title="Production Chat API",
-    description="Secure API that connects to Hugging Face Space",
-    version="1.0.0"
+    title="LLM with Tools API",
+    description="API to interact with the LLM chatbot with tool capabilities.",
+    version="1.0.0",
 )
 
-# ---------------- RATE LIMITER ----------------
-RATE_LIMIT = 5           # max requests
-WINDOW = 60              # per 60 seconds
-client_requests: Dict[str, list] = {}  # tracks requests per IP
-
-def rate_limiter(request: Request):
-    client_ip = request.client.host
-    now = time.time()
-
-    if client_ip not in client_requests:
-        client_requests[client_ip] = []
-
-    # remove old requests outside time window
-    client_requests[client_ip] = [
-        t for t in client_requests[client_ip] if now - t < WINDOW
-    ]
-
-    if len(client_requests[client_ip]) >= RATE_LIMIT:
-        logger.warning(f"Rate limit exceeded for {client_ip}")
-        raise HTTPException(status_code=429, detail="Too many requests. Try again later.")
-
-    client_requests[client_ip].append(now)
-
-# ---------------- ROUTES ----------------
-@app.post("/chat")
-async def chat(request: Request, _: None = Depends(rate_limiter)):
-    data = await request.json()
-
-    # API key check
-    api_key = request.headers.get("X-API-Key") or data.get("api_key")
-    if api_key != VALID_API_KEY:
-        logger.warning("Unauthorized access attempt.")
-        raise HTTPException(status_code=403, detail="Invalid API Key")
-
-    user_message = data.get("message")
-    if not user_message:
-        raise HTTPException(status_code=400, detail="Message is required")
-
+@app.post("/chat", summary="Send a message to the chatbot")
+async def chat(request: Request):
+    """
+    Processes incoming chat messages, validates the API key,
+    and forwards the request to the Gradio Space for processing.
+    Returns the chatbot's response.
+    """
+    print("\n--- Received new request to /chat ---")
+    api_key = None
     try:
-        logger.info(f"Processing request from {request.client.host}: {user_message}")
-
-        # Call Hugging Face Space
-        result = await run_in_threadpool(
-            client.predict,
+        data = await request.json()
+        print(f"Request body: {data}")
+
+        # API key check from headers or JSON
+        api_key = request.headers.get("X-API-Key") or data.get("api_key")
+        print(f"API Key received: {'Yes' if api_key else 'No'}")
+        print(f"Validating against configured API Key: {'Yes' if VALID_API_KEY else 'No'}")
+
+        if not api_key or api_key != VALID_API_KEY:
+            print("API key validation failed.")
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid or missing API Key")
+
+        user_message = data.get("message")
+        if not user_message:
+            print("Error: 'message' field is required.")
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="'message' field is required")
+
+        # Although the Gradio space loads history internally using the API key,
+        # you might consider if you need to pass any history from the FastAPI client.
+        # For this setup, we rely on the Space's internal history management per API key.
+        # Passing an empty list is acceptable if the Space ignores it and uses its internal state.
+        chat_history = [] # Assuming the Space manages history internally based on api_key
+
+        if client is None:
+             print("Error: Gradio client is not initialized.")
+             raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Chat service is unavailable. Gradio client failed to initialize.")
+
+        print(f"Calling Gradio Space API /chat with message='{user_message}' and api_key='{api_key}'...")
+
+        # Call your hosted Space
+        # Pass the api_key received in the FastAPI request to the Gradio chat function
+        # Ensure the parameter names match your Gradio function signature if using keywords
+        # The gradio_client's predict method maps arguments positionally unless keywords are used and matched by the target function
+        # Assuming the Gradio `chat` function signature is chat(query, chat_history, api_key)
+        # If your Gradio Space's chat function parameters are different, adjust the keywords here.
+        result = client.predict(
             query=user_message,
-            api_key=SPACE_API_KEY,
+            chat_history=chat_history, # Pass the history (empty or from request)
+            api_key=api_key, # Pass the received api_key for history separation
             api_name="/chat"
         )
 
-        logger.info(f"Response delivered to {request.client.host}")
-        return {"response": result}
+        print(f"Received response from Gradio Space: {result}")
+
+        # Assuming the response from the Space is the final text response
+        # If the Space returns a more complex object, you might need to extract the text.
+        if isinstance(result, str):
+            return {"response": result}
+        else:
+             # Handle cases where the Gradio space might return something other than a string
+             print(f"Warning: Gradio Space returned non-string result: {result}")
+             return {"response": json.dumps(result)} # Return as JSON string if it's not a simple string
+
+    except HTTPException as http_exc:
+        print(f"HTTP Exception: {http_exc.detail}")
+        raise http_exc # Re-raise FastAPI HTTP exceptions
 
     except Exception as e:
-        logger.error(f"Space call failed: {str(e)}")
-        return JSONResponse(
-            status_code=500,
-            content={"error": "Internal Server Error", "details": str(e)},
-        )
+        print(f"An unexpected error occurred: {e}")
+        print(traceback.format_exc()) # Log the full traceback
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"An internal server error occurred: {e}")
 
-# ---------------- ENTRY ----------------
 if __name__ == "__main__":
-    logger.info("🚀 Starting Production Chat API...")
-    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False, workers=2)
+    # Ensure this is run in a suitable environment for uvicorn (e.g., not directly in Colab)
+    # If running in a production environment like a Docker container or a proper server,
+    # you would typically use a command like 'uvicorn main:app --host 0.0.0.0 --port 80'
+    # This block is mainly for local testing.
+    print("Starting FastAPI server with uvicorn...")
+    #uvicorn.run(app, host="0.0.0.0", port=7860) # Commented out for Colab execution
+    print("Uvicorn run command is commented out. To run the FastAPI server, execute this script in a suitable environment.")