HF Spaces

README.md

@@ -19,14 +19,13 @@ pinned: false
 - `.env.example` — Example environment variables
 
 ## Port Configuration
-- **FastAPI**: Port 8000 (internal)
-- **Gradio**: Port 7860 (default for Hugging Face Spaces)
+- Single port (7860) with FastAPI mounted at the `/api` path
 
 ## API Endpoints
-- **Upload Documents**: `https://codegeass321-backendserver-8000.hf.space/upload`
-- **Ask Questions**: `https://codegeass321-backendserver-8000.hf.space/ask`
-- **Check Status**: `https://codegeass321-backendserver-8000.hf.space/status`
-- **API Documentation**: `https://codegeass321-backendserver-8000.hf.space/docs`
+- **Upload Documents**: `https://codegeass321-backendserver.hf.space/api/upload`
+- **Ask Questions**: `https://codegeass321-backendserver.hf.space/api/ask`
+- **Check Status**: `https://codegeass321-backendserver.hf.space/api/status`
+- **API Documentation**: `https://codegeass321-backendserver.hf.space/api/docs`
 
 ## Running Locally
 ```sh

api.py

@@ -22,6 +22,14 @@ from utils import (
 
 load_dotenv()
 
+# Configure logging
+import logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
 app = FastAPI()
 
 # Define the specific origins that are allowed to make requests to your API
@@ -47,6 +55,15 @@ client = authenticate()
 store = {"value": None}
 
 
+@app.get("/")
+async def root():
+    """Root endpoint that redirects to status."""
+    logger.info("Root endpoint called")
+    return {
+        "message": "API is running. Use /status, /upload, or /ask endpoints."
+    }
+
+
 @app.options("/upload")
 async def options_upload():
     return JSONResponse(
@@ -67,9 +84,9 @@ async def upload(files: List[UploadFile] = File(...)):
         "Access-Control-Allow-Headers": "Content-Type, Authorization",
     }
     try:
-        print(f"Upload request received with {len(files)} files")
+        logger.info(f"Upload request received with {len(files)} files")
         for i, file in enumerate(files):
-            print(f"File {i+1}: {file.filename}, content_type: {file.content_type}")
+            logger.info(f"File {i+1}: {file.filename}, content_type: {file.content_type}")
         
         if not files:
             return JSONResponse(
@@ -79,17 +96,17 @@ async def upload(files: List[UploadFile] = File(...)):
             )
         
         # Explicitly clear memory before processing new files
-        print("Clearing previous vector store from memory...")
+        logger.info("Clearing previous vector store from memory...")
         store["value"] = None
         gc.collect()
-        print("Memory cleared.")
+        logger.info("Memory cleared.")
 
-        print("Starting document processing...")
+        logger.info("Starting document processing...")
         try:
             raw_docs = load_documents_gradio(files)
-            print(f"Documents loaded: {len(raw_docs)} documents")
+            logger.info(f"Documents loaded: {len(raw_docs)} documents")
         except Exception as doc_error:
-            print(f"Error loading documents: {doc_error}")
+            logger.error(f"Error loading documents: {doc_error}")
             return JSONResponse(
                 content={"status": "error", "message": f"Error loading documents: {str(doc_error)}"},
                 status_code=500,
@@ -103,24 +120,24 @@ async def upload(files: List[UploadFile] = File(...)):
                 headers=headers
             )
             
-        print("Documents loaded. Splitting documents...")
+        logger.info("Documents loaded. Splitting documents...")
         try:
             chunks = split_documents(raw_docs)
-            print(f"Documents split into {len(chunks)} chunks")
+            logger.info(f"Documents split into {len(chunks)} chunks")
         except Exception as split_error:
-            print(f"Error splitting documents: {split_error}")
+            logger.error(f"Error splitting documents: {split_error}")
             return JSONResponse(
                 content={"status": "error", "message": f"Error splitting documents: {str(split_error)}"},
                 status_code=500,
                 headers=headers
             )
             
-        print("Documents split. Building vector store...")
+        logger.info("Documents split. Building vector store...")
         try:
             store["value"] = build_vectorstore(chunks)
-            print("Vector store built successfully.")
+            logger.info("Vector store built successfully.")
         except Exception as vector_error:
-            print(f"Error building vector store: {vector_error}")
+            logger.error(f"Error building vector store: {vector_error}")
             return JSONResponse(
                 content={"status": "error", "message": f"Error building vector store: {str(vector_error)}"},
                 status_code=500,
@@ -134,8 +151,8 @@ async def upload(files: List[UploadFile] = File(...)):
     except Exception as e:
         import traceback
         error_trace = traceback.format_exc()
-        print(f"An error occurred during upload: {e}")
-        print(f"Traceback: {error_trace}")
+        logger.error(f"An error occurred during upload: {e}")
+        logger.error(f"Traceback: {error_trace}")
         return JSONResponse(
             content={"status": "error", "message": f"An internal server error occurred: {str(e)}"},
             status_code=500,
@@ -147,8 +164,10 @@ async def ask(
     text: Optional[str] = Form(None),
     audio: Optional[UploadFile] = File(None)
 ):
+    logger.info(f"Ask endpoint called: text={bool(text)}, audio={bool(audio)}")
     transcribed = None
     if store["value"] is None:
+        logger.warning("Ask called but no document is loaded")
         return JSONResponse({"status": "error", "message": "Please upload and process a document first."}, status_code=400)
     if text and text.strip():
         query = text.strip()
@@ -169,13 +188,21 @@ async def ask(
         except Exception as e:
             return JSONResponse({"status": "error", "message": f"Audio decode failed: {str(e)}"}, status_code=400)
     else:
+        logger.warning("Ask called with no text or audio")
         return JSONResponse({"status": "error", "message": "Please provide a question by typing or speaking."}, status_code=400)
+    
+    logger.info(f"Processing query: {query[:100]}...")
+    
     if store["value"]["chunks"] <= 50:
         top_chunks = retrieve_context(query, store["value"])
     else:
         top_chunks = retrieve_context_approx(query, store["value"])
+    
     prompt = build_prompt(top_chunks, query)
     answer = ask_gemini(prompt, client)
+    
+    logger.info(f"Generated answer: {answer[:100]}...")
+    
     return {"status": "success", "answer": answer.strip(), "transcribed": transcribed}
 
 @app.get("/status")
@@ -185,11 +212,13 @@ async def status():
     import sys
     import psutil
     
+    logger.info("Status endpoint called")
+    
     # Get memory info
     process = psutil.Process(os.getpid())
     memory_info = process.memory_info()
     
-    return {
+    status_info = {
         "status": "ok",
         "message": "Server is running",
         "google_api_key_set": bool(os.environ.get("GOOGLE_API_KEY")),
@@ -207,3 +236,7 @@ async def status():
             "SYSTEM": os.environ.get("SYSTEM")
         }
     }
+    
+    logger.info(f"Status response: {status_info}")
+    
+    return status_info

app.py

@@ -1,26 +1,31 @@
 import gradio as gr
-from api import app
+from api import app as fastapi_app
 import uvicorn
 import threading
 import time
 import os
+import logging
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import RedirectResponse
 
-# FastAPI port - used internally
-FASTAPI_PORT = 8000
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
-# Create a simple Gradio interface
+# Create a Gradio app that will also host the FastAPI app
 def create_interface():
     with gr.Blocks(title="ChatDocxAI Backend") as interface:
         gr.Markdown("# ChatDocxAI Backend")
         gr.Markdown(f"""
         This is the backend server for ChatDocxAI. It provides the following endpoints:
         
-        - `https://codegeass321-backendserver-8000.hf.space/upload` - Upload documents
-        - `https://codegeass321-backendserver-8000.hf.space/ask` - Ask questions about uploaded documents
-        - `https://codegeass321-backendserver-8000.hf.space/status` - Check API status
+        - `/api/upload` - Upload documents
+        - `/api/ask` - Ask questions about uploaded documents
+        - `/api/status` - Check API status
         
         The frontend should be configured to communicate with this backend.
         """)
@@ -33,26 +38,26 @@ def create_interface():
         with gr.Row():
             with gr.Column():
                 gr.Markdown("## API Documentation")
-                doc_link = gr.HTML(f"<a href='https://codegeass321-backendserver-8000.hf.space/docs' target='_blank'>View FastAPI Docs</a>")
+                doc_link = gr.HTML(f"<a href='/api/docs' target='_blank'>View FastAPI Docs</a>")
     
     return interface
 
-# Set up FastAPI to run on port 8000
-def start_fastapi():
-    uvicorn.run(app, host="0.0.0.0", port=FASTAPI_PORT, log_level="info")
+# Create a new FastAPI app that will mount both the original FastAPI app and the Gradio app
+app = FastAPI()
 
-# Start FastAPI in a separate thread
-fastapi_thread = threading.Thread(target=start_fastapi)
-fastapi_thread.daemon = True
-fastapi_thread.start()
+# Mount the original FastAPI app under the /api prefix
+logger.info("Mounting FastAPI app at /api")
+app.mount("/api", fastapi_app)
 
-# Allow some time for FastAPI to start
-time.sleep(2)
-
-# Create and launch the Gradio interface
+# Create the Gradio interface
+logger.info("Creating Gradio interface")
 interface = create_interface()
 
-# Launch the Gradio interface on the default Hugging Face Spaces port (7860)
+# Gradio blocks to FastAPI app
+logger.info("Mounting Gradio app at /")
+app = gr.mount_gradio_app(app, interface, path="/")
+
+# When running directly, start the app
 if __name__ == "__main__":
-    # Use the port specified by Hugging Face Spaces
-    interface.launch(server_name="0.0.0.0")
+    logger.info("Starting server on port 7860")
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")