Update app.py

app.py

@@ -1,196 +1,265 @@
 import os
 import shutil
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, HTTPException, Depends
 from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
 from sentence_transformers import SentenceTransformer, util
 import torch
 import requests
+from typing import List, Dict, Optional
+from pydantic import BaseModel
 
-# Rate limit
+# Rate limiting
 from slowapi import Limiter, _rate_limit_exceeded_handler
 from slowapi.util import get_remote_address
 from slowapi.errors import RateLimitExceeded
 
-# Inisialisasi FastAPI dan Limiter
+# Configuration
+class Config:
+    SUPABASE_URL = "https://olbjfxlclotxtnpjvpfj.supabase.co"
+    SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im9sYmpmeGxjbG90eHRucGp2cGZqIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTIyMzYwMDEsImV4cCI6MjA2NzgxMjAwMX0.7q_o5DCFEAAysnWXMChH4MI5qNhIVc4OgpT5JvgYxc0"
+    MODEL_NAME = "sentence-transformers/paraphrase-MiniLM-L3-v2"
+    SIMILARITY_THRESHOLD = 0.7
+    HF_CACHE = "/tmp/hf"
+    RATE_LIMIT = "10/minute"
+
+# Initialize FastAPI
+app = FastAPI(title="Biruu Chatbot API", version="1.0.0")
+
+# CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Rate Limiter
 limiter = Limiter(key_func=get_remote_address)
-app = FastAPI()
 app.state.limiter = limiter
 app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
 
-# 🔐 Paksa cache aman untuk Hugging Face Spaces
-HF_CACHE = "/tmp/hf"
-os.environ["TRANSFORMERS_CACHE"] = HF_CACHE
-os.environ["HF_HOME"] = HF_CACHE
-os.makedirs(HF_CACHE, exist_ok=True)
-
-# Bersihkan cache model jika terkunci
-if os.path.exists(f"{HF_CACHE}/models--sentence-transformers--paraphrase-MiniLM-L3-v2.lock"):
-    os.remove(f"{HF_CACHE}/models--sentence-transformers--paraphrase-MiniLM-L3-v2.lock")
-if os.path.exists(f"{HF_CACHE}/models--sentence-transformers--paraphrase-MiniLM-L3-v2"):
-    shutil.rmtree(f"{HF_CACHE}/models--sentence-transformers--paraphrase-MiniLM-L3-v2", ignore_errors=True)
-
-# Supabase
-SUPABASE_URL = "https://olbjfxlclotxtnpjvpfj.supabase.co"
-SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im9sYmpmeGxjbG90eHRucGp2cGZqIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTIyMzYwMDEsImV4cCI6MjA2NzgxMjAwMX0.7q_o5DCFEAAysnWXMChH4MI5qNhIVc4OgpT5JvgYxc0"
-
-# Model
-model = SentenceTransformer("sentence-transformers/paraphrase-MiniLM-L3-v2")
-
-# 🔍 Ambil FAQ berdasarkan UID
-def get_faq_from_supabase(admin_id):
-    """Ambil FAQ khusus untuk admin tertentu"""
-    url = f"{SUPABASE_URL}/rest/v1/faq_items?admin_id=eq.{admin_id}"
+# Setup Hugging Face cache
+os.makedirs(Config.HF_CACHE, exist_ok=True)
+os.environ["TRANSFORMERS_CACHE"] = Config.HF_CACHE
+os.environ["HF_HOME"] = Config.HF_CACHE
+
+# Clean up locked cache
+lock_file = f"{Config.HF_CACHE}/models--{Config.MODEL_NAME.replace('/', '--')}.lock"
+if os.path.exists(lock_file):
+    os.remove(lock_file)
+model_cache = f"{Config.HF_CACHE}/models--{Config.MODEL_NAME.replace('/', '--')}"
+if os.path.exists(model_cache):
+    shutil.rmtree(model_cache, ignore_errors=True)
+
+# Initialize model
+try:
+    model = SentenceTransformer(Config.MODEL_NAME)
+except Exception as e:
+    raise RuntimeError(f"Failed to load model: {str(e)}")
+
+# Pydantic Models
+class ChatMessage(BaseModel):
+    admin_id: str
+    session_id: str
+    is_bot: bool
+    is_admin: bool
+    message: str
+
+class DeleteRequest(BaseModel):
+    id: Optional[str] = None
+    uid: Optional[str] = None
+
+# Helper Functions
+def make_supabase_request(
+    method: str,
+    endpoint: str,
+    params: Optional[Dict] = None,
+    data: Optional[Dict] = None
+) -> requests.Response:
+    """Generic function to make Supabase API requests"""
+    url = f"{Config.SUPABASE_URL}{endpoint}"
     headers = {
-        "apikey": SUPABASE_KEY,
-        "Authorization": f"Bearer {SUPABASE_KEY}",
+        "apikey": Config.SUPABASE_KEY,
+        "Authorization": f"Bearer {Config.SUPABASE_KEY}",
         "Content-Type": "application/json"
     }
+    
     try:
-        r = requests.get(url, headers=headers)
-        r.raise_for_status()
-        return r.json()
-    except Exception as e:
-        print(f"❌ Error mengambil FAQ untuk admin {admin_id}:", e)
+        if method == "GET":
+            response = requests.get(url, headers=headers, params=params)
+        elif method == "POST":
+            response = requests.post(url, headers=headers, json=data)
+        elif method == "DELETE":
+            response = requests.delete(url, headers=headers)
+        else:
+            raise ValueError("Unsupported HTTP method")
+        
+        response.raise_for_status()
+        return response
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Supabase request failed: {str(e)}"
+        )
+
+def get_faq_from_supabase(admin_id: str) -> List[Dict]:
+    """Get FAQ items for a specific admin"""
+    try:
+        response = make_supabase_request(
+            "GET",
+            "/rest/v1/faq_items",
+            params={"admin_id": f"eq.{admin_id}"}
+        )
+        return response.json()
+    except HTTPException:
         return []
 
-# 🔮 Endpoint prediksi jawaban dari pertanyaan user
+# API Endpoints
 @app.post("/predict")
-@limiter.limit("5/minute")
-async def predict(request: Request):
-    body = await request.json()
-    admin_id, question = body.get("data", [None, None])  # admin_id dari UID di link
-
+@limiter.limit(Config.RATE_LIMIT)
+async def predict(request: Request, data: List[str] = ["", ""]):
+    """Get answer for user question"""
+    if len(data) != 2:
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid input format. Expected [admin_id, question]"
+        )
+    
+    admin_id, question = data
     if not admin_id or not question:
-        return {"data": ["Admin ID atau pertanyaan tidak valid."]}
+        raise HTTPException(
+            status_code=400,
+            detail="Admin ID and question are required"
+        )
 
-    # Ambil FAQ khusus admin ini saja
+    # Get FAQs for this admin
     faqs = get_faq_from_supabase(admin_id)
     if not faqs:
-        return {"data": ["Maaf, belum ada FAQ yang tersedia."]}
+        return {"data": ["Maaf, belum ada FAQ yang tersedia untuk chatbot ini."]}
 
-    # Proses pencarian jawaban
+    # Process question
     questions = [f["question"] for f in faqs]
     answers = [f["answer"] for f in faqs]
 
     try:
-        embeddings = model.encode(questions, convert_to_tensor=True)
+        # Encode questions and user input
+        question_embeddings = model.encode(questions, convert_to_tensor=True)
         query_embedding = model.encode(question, convert_to_tensor=True)
-        similarity = util.pytorch_cos_sim(query_embedding, embeddings)
+        
+        # Calculate similarity
+        similarity = util.pytorch_cos_sim(query_embedding, question_embeddings)
         best_idx = torch.argmax(similarity).item()
+        best_score = similarity[0][best_idx].item()
         
-        # Threshold similarity (minimal 0.5)
-        if similarity[0][best_idx] < 0.5:
-            return {"data": ["Maaf, saya tidak mengerti pertanyaan Anda."]}
+        # Apply threshold
+        if best_score < Config.SIMILARITY_THRESHOLD:
+            return {"data": ["Maaf, saya tidak mengerti pertanyaan Anda. Coba tanyakan dengan cara lain."]}
             
         return {"data": [answers[best_idx]]}
     except Exception as e:
-        print("❌ Error processing question:", e)
-        return {"data": ["Terjadi kesalahan saat memproses pertanyaan."]}
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing question: {str(e)}"
+        )
 
-# Save chat
 @app.post("/save_chat")
-async def save_chat(request: Request):
-    body = await request.json()
-    admin_id = body.get("admin_id")
-    session_id = body.get("session_id")
-    is_bot = body.get("is_bot", False)
-    is_admin = body.get("is_admin", False)
-    message = body.get("message")
-
-    if not all([admin_id, session_id, message]):
-        return JSONResponse({"error": "Data tidak lengkap"}, status_code=400)
-
-    url = f"{SUPABASE_URL}/rest/v1/chat_logs"
-    headers = {
-        "apikey": SUPABASE_KEY,
-        "Authorization": f"Bearer {SUPABASE_KEY}",
-        "Content-Type": "application/json",
-        "Prefer": "return=representation"
-    }
-    payload = {
-        "admin_id": admin_id,
-        "session_id": session_id,
-        "is_bot": is_bot,
-        "is_admin": is_admin,
-        "message": message
-    }
-
+async def save_chat(chat: ChatMessage):
+    """Save chat message to database"""
     try:
-        r = requests.post(url, json=payload, headers=headers)
-        r.raise_for_status()
-        return {"message": "Pesan berhasil disimpan", "id": r.json()[0]["id"]}
+        response = make_supabase_request(
+            "POST",
+            "/rest/v1/chat_logs",
+            data={
+                "admin_id": chat.admin_id,
+                "session_id": chat.session_id,
+                "is_bot": chat.is_bot,
+                "is_admin": chat.is_admin,
+                "message": chat.message
+            }
+        )
+        saved_data = response.json()[0]
+        return {
+            "message": "Pesan berhasil disimpan",
+            "id": saved_data["id"]
+        }
+    except HTTPException as e:
+        raise e
     except Exception as e:
-        print("❌ Gagal menyimpan pesan:", e)
-        return JSONResponse({"error": "Gagal menyimpan pesan"}, status_code=500)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to save chat: {str(e)}"
+        )
 
-# Chat history
 @app.get("/chat_history")
-async def get_chat_history(request: Request, admin_id: str, session_id: str):
-    """Ambil history chat spesifik untuk sesi ini"""
-    url = f"{SUPABASE_URL}/rest/v1/chat_logs"
-    params = {
-        "admin_id": f"eq.{admin_id}",
-        "or": f"(session_id.eq.{session_id},is_bot.eq.true)",
-        "order": "created_at.asc"
-    }
-    headers = {
-        "apikey": SUPABASE_KEY,
-        "Authorization": f"Bearer {SUPABASE_KEY}"
-    }
-
+async def get_chat_history(admin_id: str, session_id: str):
+    """Get chat history for specific session"""
     try:
-        r = requests.get(url, params=params, headers=headers)
-        r.raise_for_status()
-        return r.json()
+        response = make_supabase_request(
+            "GET",
+            "/rest/v1/chat_logs",
+            params={
+                "admin_id": f"eq.{admin_id}",
+                "or": f"(session_id.eq.{session_id},is_bot.eq.true)",
+                "order": "created_at.asc"
+            }
+        )
+        return response.json()
+    except HTTPException as e:
+        raise e
     except Exception as e:
-        print(f"❌ Error mengambil history untuk {session_id}:", e)
-        return JSONResponse({"error": "Gagal mengambil history"}, status_code=500)
-        
-# 🧹 Hapus satu pesan berdasarkan ID
-@app.post("/delete_chat")
-async def delete_chat(request: Request):
-    body = await request.json()
-    message_id = body.get("id")
-
-    if not message_id:
-        return JSONResponse({"error": "ID pesan wajib diisi."}, status_code=400)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to get chat history: {str(e)}"
+        )
 
-    url = f"{SUPABASE_URL}/rest/v1/chat_logs?id=eq.{message_id}"
-    headers = {
-        "apikey": SUPABASE_KEY,
-        "Authorization": f"Bearer {SUPABASE_KEY}",
-        "Content-Type": "application/json",
-        "Prefer": "return=representation"
-    }
+@app.post("/delete_chat")
+async def delete_chat(request: DeleteRequest):
+    """Delete specific chat message"""
+    if not request.id:
+        raise HTTPException(
+            status_code=400,
+            detail="Message ID is required"
+        )
 
     try:
-        r = requests.delete(url, headers=headers)
-        r.raise_for_status()
-        return {"message": f"Pesan dengan ID {message_id} berhasil dihapus."}
+        make_supabase_request(
+            "DELETE",
+            f"/rest/v1/chat_logs?id=eq.{request.id}"
+        )
+        return {"message": f"Pesan dengan ID {request.id} berhasil dihapus."}
+    except HTTPException as e:
+        raise e
     except Exception as e:
-        print("❌ Gagal hapus pesan:", e)
-        return JSONResponse({"error": "Gagal menghapus pesan."}, status_code=500)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to delete message: {str(e)}"
+        )
 
-# 🧼 Hapus semua pesan milik user tertentu
 @app.post("/delete_all_by_uid")
-async def delete_all_by_uid(request: Request):
-    body = await request.json()
-    uid = body.get("uid")
-
-    if not uid:
-        return JSONResponse({"error": "UID wajib diisi."}, status_code=400)
-
-    url = f"{SUPABASE_URL}/rest/v1/chat_logs?uid=eq.{uid}"
-    headers = {
-        "apikey": SUPABASE_KEY,
-        "Authorization": f"Bearer {SUPABASE_KEY}",
-        "Content-Type": "application/json",
-        "Prefer": "return=representation"
-    }
+async def delete_all_by_uid(request: DeleteRequest):
+    """Delete all messages for specific user"""
+    if not request.uid:
+        raise HTTPException(
+            status_code=400,
+            detail="UID is required"
+        )
 
     try:
-        r = requests.delete(url, headers=headers)
-        r.raise_for_status()
-        return {"message": f"Semua pesan dengan UID {uid} berhasil dihapus."}
+        make_supabase_request(
+            "DELETE",
+            f"/rest/v1/chat_logs?admin_id=eq.{request.uid}"
+        )
+        return {"message": f"Semua pesan untuk UID {request.uid} berhasil dihapus."}
+    except HTTPException as e:
+        raise e
     except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to delete messages: {str(e)}"
+        )
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "version": "1.0.0"}