Fix Vercel deployment: Use proper serverless handler and streamline dependencies

api/ask.py

@@ -3,10 +3,8 @@ Vercel Serverless Function for handling customer support questions.
 Endpoint: POST /api/ask
 """
 
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
+from http.server import BaseHTTPRequestHandler
+import json
 import sys
 import os
 
@@ -19,16 +17,17 @@ from src.llm_client import LLMClient
 from src.config import Settings
 
 # Initialize components (cached across invocations)
-settings = Settings()
+settings = None
 rag_system = None
 llm_client = None
 escalation_engine = None
 
 def initialize_components():
     """Initialize RAG system, LLM client, and escalation engine."""
-    global rag_system, llm_client, escalation_engine
+    global settings, rag_system, llm_client, escalation_engine
     
     if rag_system is None:
+        settings = Settings()
         articles_dir = os.path.join(
             os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
             "data",
@@ -41,88 +40,94 @@ def initialize_components():
             relevance_threshold=settings.relevance_threshold
         )
 
-app = FastAPI(title="Smart Escalation API")
-
-# Configure CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # In production, restrict to your domain
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-class QuestionRequest(BaseModel):
-    question: str
-
-class QuestionResponse(BaseModel):
-    response_type: str
-    message: str
-    confidence_explanation: str
-    sources: list = None
-
-@app.post("/api/ask", response_model=QuestionResponse)
-async def ask_question(request: QuestionRequest):
-    """
-    Process customer question and return answer or escalation.
+class handler(BaseHTTPRequestHandler):
+    """Vercel serverless function handler."""
     
-    Args:
-        request: QuestionRequest with 'question' field
-        
-    Returns:
-        QuestionResponse with response_type, message, confidence_explanation, sources
-    """
-    try:
-        # Initialize components on first request
-        initialize_components()
-        
-        # Validate question
-        if not request.question or len(request.question.strip()) == 0:
-            return JSONResponse(
-                status_code=400,
-                content={
-                    "response_type": "error",
-                    "message": "Question cannot be empty",
-                    "confidence_explanation": "Invalid request",
-                    "sources": None
-                }
-            )
+    def do_POST(self):
+        """Handle POST requests."""
+        try:
+            # Initialize components on first request
+            initialize_components()
+            
+            # Read request body
+            content_length = int(self.headers.get('Content-Length', 0))
+            body = self.rfile.read(content_length).decode('utf-8')
+            
+            # Parse JSON
+            try:
+                data = json.loads(body)
+                question = data.get('question', '').strip()
+            except json.JSONDecodeError:
+                self.send_error_response(400, "Invalid JSON")
+                return
+            
+            # Validate question
+            if not question:
+                self.send_error_response(400, "Question cannot be empty")
+                return
+            
+            # Retrieve relevant chunks
+            chunks = rag_system.retrieve(question, top_k=settings.top_k_chunks)
+            
+            # Decide whether to answer or escalate
+            decision = escalation_engine.process_question(question, chunks)
+            
+            # Send success response
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.send_header('Access-Control-Allow-Methods', 'POST, OPTIONS')
+            self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+            self.end_headers()
+            
+            response = {
+                "response_type": decision.action,
+                "message": decision.message,
+                "confidence_explanation": decision.confidence_explanation,
+                "sources": decision.sources
+            }
+            
+            self.wfile.write(json.dumps(response).encode('utf-8'))
+            
+        except Exception as e:
+            print(f"Error processing question: {str(e)}")
+            self.send_error_response(500, "Internal server error")
+    
+    def do_OPTIONS(self):
+        """Handle OPTIONS requests for CORS."""
+        self.send_response(200)
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        self.end_headers()
+    
+    def do_GET(self):
+        """Handle GET requests (health check)."""
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.end_headers()
         
-        # Retrieve relevant chunks
-        chunks = rag_system.retrieve(request.question, top_k=settings.top_k_chunks)
+        response = {
+            "status": "healthy",
+            "vector_store_loaded": rag_system is not None
+        }
         
-        # Decide whether to answer or escalate
-        decision = escalation_engine.process_question(request.question, chunks)
+        self.wfile.write(json.dumps(response).encode('utf-8'))
+    
+    def send_error_response(self, status_code, message):
+        """Send error response."""
+        self.send_response(status_code)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.end_headers()
         
-        return {
-            "response_type": decision.action,
-            "message": decision.message,
-            "confidence_explanation": decision.confidence_explanation,
-            "sources": decision.sources
+        response = {
+            "response_type": "error",
+            "message": message,
+            "confidence_explanation": "Request error",
+            "sources": None
         }
         
-    except Exception as e:
-        # Log error and return escalation response
-        print(f"Error processing question: {str(e)}")
-        return JSONResponse(
-            status_code=500,
-            content={
-                "response_type": "escalation",
-                "message": "I'm experiencing technical difficulties. Let me connect you with a human agent.",
-                "confidence_explanation": f"System error occurred",
-                "sources": None
-            }
-        )
-
-@app.get("/api/health")
-async def health_check():
-    """Health check endpoint."""
-    return {
-        "status": "healthy",
-        "vector_store_loaded": rag_system is not None
-    }
+        self.wfile.write(json.dumps(response).encode('utf-8'))
 
-# Vercel serverless function handler
-def handler(request: Request):
-    """Main handler for Vercel serverless function."""
-    return app(request)

requirements.txt

@@ -1,6 +1,4 @@
-# FastAPI and server dependencies
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
+# Core dependencies
 pydantic==2.5.0
 pydantic-settings==2.1.0
 python-dotenv==1.0.0
@@ -13,11 +11,3 @@ numpy==1.24.3
 # LLM API clients
 google-generativeai==0.3.2
 
-# Testing dependencies
-pytest==7.4.3
-pytest-asyncio==0.21.1
-hypothesis==6.92.1
-httpx==0.25.2
-
-# CORS support
-python-multipart==0.0.6

vercel.json

@@ -1,10 +1,5 @@
 {
   "buildCommand": "cd frontend && npm ci && npm run build",
   "outputDirectory": "frontend/dist",
-  "installCommand": "pip install -r requirements.txt",
-  "functions": {
-    "api/**/*.py": {
-      "runtime": "@vercel/python@4.3.0"
-    }
-  }
+  "installCommand": "pip install --upgrade pip && pip install -r requirements.txt"
 }