Upload 2 files

app.py

@@ -0,0 +1,325 @@
+import gradio as gr
+from sentence_transformers import SentenceTransformer
+import json
+import numpy as np
+import os
+import httpx
+
+# ==================== CONFIGURATION ====================
+
+# Model - akan auto-download dari HF Hub saat pertama kali
+HF_MODEL_NAME = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+
+# Path lokal untuk development (opsional, diabaikan jika tidak ada)
+LOCAL_MODEL_PATH = r"E:\huggingface_models\hub\models--sentence-transformers--paraphrase-multilingual-MiniLM-L12-v2\snapshots"
+
+# Supabase configuration (dari environment variables untuk keamanan)
+# Di HF Space: Settings > Repository secrets
+# Di lokal: set environment variable atau gunakan default untuk testing
+SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY", "")
+
+def get_model_path():
+    """Deteksi environment dan return path model yang sesuai"""
+    # Cek apakah folder lokal ada
+    if os.path.exists(LOCAL_MODEL_PATH):
+        # Cari snapshot terbaru
+        snapshots = os.listdir(LOCAL_MODEL_PATH)
+        if snapshots:
+            return os.path.join(LOCAL_MODEL_PATH, snapshots[0])
+    # Fallback ke HF Hub (untuk deployment di Space)
+    return HF_MODEL_NAME
+
+# Load model saat startup
+print("Loading model...")
+model_path = get_model_path()
+print(f"Using model from: {model_path}")
+model = SentenceTransformer(model_path)
+print("Model loaded successfully!")
+
+
+def get_embedding(text: str):
+    """Generate embedding untuk single text"""
+    if not text or not text.strip():
+        return {"error": "Text tidak boleh kosong"}
+    
+    try:
+        embedding = model.encode(text.strip())
+        return {"embedding": embedding.tolist()}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_embeddings_batch(texts_json: str):
+    """Generate embeddings untuk multiple texts (JSON array)"""
+    try:
+        texts = json.loads(texts_json)
+        if not isinstance(texts, list):
+            return {"error": "Input harus JSON array"}
+        
+        if len(texts) == 0:
+            return {"error": "Array tidak boleh kosong"}
+        
+        # Filter empty strings
+        texts = [t.strip() for t in texts if t and t.strip()]
+        
+        if len(texts) == 0:
+            return {"error": "Semua text kosong"}
+        
+        embeddings = model.encode(texts)
+        return {"embeddings": embeddings.tolist()}
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON format. Gunakan format: [\"teks 1\", \"teks 2\"]"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def calculate_similarity(text1: str, text2: str):
+    """Hitung cosine similarity antara dua teks"""
+    if not text1 or not text1.strip():
+        return {"error": "Text 1 tidak boleh kosong"}
+    if not text2 or not text2.strip():
+        return {"error": "Text 2 tidak boleh kosong"}
+    
+    try:
+        embeddings = model.encode([text1.strip(), text2.strip()])
+        
+        # Cosine similarity
+        similarity = np.dot(embeddings[0], embeddings[1]) / (
+            np.linalg.norm(embeddings[0]) * np.linalg.norm(embeddings[1])
+        )
+        
+        return {
+            "similarity": float(similarity),
+            "percentage": f"{similarity * 100:.2f}%"
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+# ==================== SUPABASE PROXY FUNCTIONS ====================
+
+def get_supabase_headers():
+    """Get headers untuk Supabase API calls"""
+    return {
+        "apikey": SUPABASE_KEY,
+        "Authorization": f"Bearer {SUPABASE_KEY}",
+        "Content-Type": "application/json",
+        "Prefer": "return=representation"
+    }
+
+
+def db_get_all_embeddings():
+    """Ambil semua embeddings dari Supabase"""
+    if not SUPABASE_URL or not SUPABASE_KEY:
+        return {"error": "Supabase not configured"}
+    
+    try:
+        url = f"{SUPABASE_URL}/rest/v1/proposal_embeddings?select=nim,content_hash,embedding_combined,embedding_judul,embedding_deskripsi,embedding_problem,embedding_metode,nama,judul"
+        
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(url, headers=get_supabase_headers())
+        
+        if response.status_code == 200:
+            return {"data": response.json(), "count": len(response.json())}
+        else:
+            return {"error": f"Supabase error: {response.status_code}", "detail": response.text}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def db_get_embedding(nim: str, content_hash: str):
+    """Ambil embedding untuk NIM dan content_hash tertentu"""
+    if not SUPABASE_URL or not SUPABASE_KEY:
+        return {"error": "Supabase not configured"}
+    
+    try:
+        url = f"{SUPABASE_URL}/rest/v1/proposal_embeddings?nim=eq.{nim}&content_hash=eq.{content_hash}&select=*"
+        
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(url, headers=get_supabase_headers())
+        
+        if response.status_code == 200:
+            data = response.json()
+            return {"data": data[0] if data else None, "found": len(data) > 0}
+        else:
+            return {"error": f"Supabase error: {response.status_code}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def db_save_embedding(data_json: str):
+    """Simpan embedding ke Supabase (upsert)"""
+    if not SUPABASE_URL or not SUPABASE_KEY:
+        return {"error": "Supabase not configured"}
+    
+    try:
+        data = json.loads(data_json)
+        
+        # Validate required fields
+        if not data.get("nim") or not data.get("content_hash"):
+            return {"error": "nim and content_hash are required"}
+        
+        if not data.get("embedding_combined"):
+            return {"error": "embedding_combined is required"}
+        
+        url = f"{SUPABASE_URL}/rest/v1/proposal_embeddings"
+        headers = get_supabase_headers()
+        headers["Prefer"] = "resolution=merge-duplicates,return=representation"
+        
+        payload = {
+            "nim": data["nim"],
+            "content_hash": data["content_hash"],
+            "embedding_combined": data["embedding_combined"],
+            "embedding_judul": data.get("embedding_judul"),
+            "embedding_deskripsi": data.get("embedding_deskripsi"),
+            "embedding_problem": data.get("embedding_problem"),
+            "embedding_metode": data.get("embedding_metode"),
+            "nama": data.get("nama"),
+            "judul": data.get("judul")
+        }
+        
+        with httpx.Client(timeout=30.0) as client:
+            response = client.post(url, headers=headers, json=payload)
+        
+        if response.status_code in [200, 201]:
+            return {"success": True, "data": response.json()}
+        else:
+            return {"error": f"Supabase error: {response.status_code}", "detail": response.text}
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON format"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def db_check_connection():
+    """Test koneksi ke Supabase"""
+    if not SUPABASE_URL or not SUPABASE_KEY:
+        return {"connected": False, "error": "Supabase URL or KEY not configured"}
+    
+    try:
+        url = f"{SUPABASE_URL}/rest/v1/proposal_embeddings?select=id&limit=1"
+        
+        with httpx.Client(timeout=10.0) as client:
+            response = client.get(url, headers=get_supabase_headers())
+        
+        return {
+            "connected": response.status_code == 200,
+            "status_code": response.status_code,
+            "supabase_url": SUPABASE_URL[:30] + "..." if len(SUPABASE_URL) > 30 else SUPABASE_URL
+        }
+    except Exception as e:
+        return {"connected": False, "error": str(e)}
+
+
+# Gradio Interface
+with gr.Blocks(title="Semantic Embedding API") as demo:
+    gr.Markdown("# 🔤 Semantic Embedding API")
+    gr.Markdown("API untuk menghasilkan text embedding menggunakan `paraphrase-multilingual-MiniLM-L12-v2`")
+    gr.Markdown("**Model**: Multilingual, mendukung 50+ bahasa termasuk Bahasa Indonesia")
+    
+    with gr.Tab("🔢 Single Embedding"):
+        gr.Markdown("Generate embedding vector untuk satu teks")
+        text_input = gr.Textbox(
+            label="Input Text", 
+            placeholder="Masukkan teks untuk di-embed...",
+            lines=2
+        )
+        single_output = gr.JSON(label="Embedding Result")
+        single_btn = gr.Button("Generate Embedding", variant="primary")
+        single_btn.click(fn=get_embedding, inputs=text_input, outputs=single_output)
+    
+    with gr.Tab("📦 Batch Embedding"):
+        gr.Markdown("Generate embeddings untuk multiple teks sekaligus")
+        batch_input = gr.Textbox(
+            label="JSON Array of Texts", 
+            placeholder='["teks pertama", "teks kedua", "teks ketiga"]',
+            lines=4
+        )
+        batch_output = gr.JSON(label="Embeddings Result")
+        batch_btn = gr.Button("Generate Embeddings", variant="primary")
+        batch_btn.click(fn=get_embeddings_batch, inputs=batch_input, outputs=batch_output)
+    
+    with gr.Tab("📊 Similarity Check"):
+        gr.Markdown("Hitung kemiripan semantik antara dua teks")
+        with gr.Row():
+            sim_text1 = gr.Textbox(label="Text 1", placeholder="Teks pertama...", lines=2)
+            sim_text2 = gr.Textbox(label="Text 2", placeholder="Teks kedua...", lines=2)
+        sim_output = gr.JSON(label="Similarity Result")
+        sim_btn = gr.Button("Calculate Similarity", variant="primary")
+        sim_btn.click(fn=calculate_similarity, inputs=[sim_text1, sim_text2], outputs=sim_output)
+    
+    with gr.Tab("💾 Database (Supabase)"):
+        gr.Markdown("### Supabase Cache Operations")
+        gr.Markdown("Proxy untuk akses Supabase (API key aman di server)")
+        
+        with gr.Row():
+            db_check_btn = gr.Button("🔌 Check Connection", variant="secondary")
+            db_check_output = gr.JSON(label="Connection Status")
+            db_check_btn.click(fn=db_check_connection, outputs=db_check_output)
+        
+        gr.Markdown("---")
+        
+        gr.Markdown("#### Get All Cached Embeddings")
+        db_all_btn = gr.Button("📥 Get All Embeddings", variant="primary")
+        db_all_output = gr.JSON(label="All Embeddings")
+        db_all_btn.click(fn=db_get_all_embeddings, outputs=db_all_output)
+        
+        gr.Markdown("---")
+        
+        gr.Markdown("#### Get Single Embedding by NIM")
+        with gr.Row():
+            db_nim_input = gr.Textbox(label="NIM", placeholder="10121xxx")
+            db_hash_input = gr.Textbox(label="Content Hash", placeholder="abc123...")
+        db_get_btn = gr.Button("🔍 Get Embedding", variant="primary")
+        db_get_output = gr.JSON(label="Embedding Result")
+        db_get_btn.click(fn=db_get_embedding, inputs=[db_nim_input, db_hash_input], outputs=db_get_output)
+        
+        gr.Markdown("---")
+        
+        gr.Markdown("#### Save Embedding")
+        db_save_input = gr.Textbox(
+            label="Embedding Data (JSON)", 
+            placeholder='{"nim": "123", "content_hash": "abc", "embedding_combined": [...], ...}',
+            lines=4
+        )
+        db_save_btn = gr.Button("💾 Save Embedding", variant="primary")
+        db_save_output = gr.JSON(label="Save Result")
+        db_save_btn.click(fn=db_save_embedding, inputs=db_save_input, outputs=db_save_output)
+    
+    with gr.Accordion("📡 API Usage (untuk Developer)", open=False):
+        gr.Markdown("""
+### Endpoints
+
+#### Embedding
+- `get_embedding` - Single text embedding
+- `get_embeddings_batch` - Batch text embeddings  
+- `calculate_similarity` - Compare two texts
+
+#### Database (Supabase Proxy)
+- `db_check_connection` - Test Supabase connection
+- `db_get_all_embeddings` - Get all cached embeddings
+- `db_get_embedding` - Get embedding by NIM + hash
+- `db_save_embedding` - Save embedding to cache
+
+### Example API Call
+```javascript
+// Get all cached embeddings
+const response = await fetch("YOUR_SPACE_URL/gradio_api/call/db_get_all_embeddings", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ data: [] })
+});
+const result = await response.json();
+const eventId = result.event_id;
+
+// Get result
+const dataResponse = await fetch(`YOUR_SPACE_URL/gradio_api/call/db_get_all_embeddings/${eventId}`);
+```
+        """)
+    
+    gr.Markdown("---")
+    gr.Markdown("*Dibuat untuk Monitoring Proposal Skripsi KK E - UNIKOM*")
+
+# Launch dengan API enabled
+demo.launch()

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+sentence-transformers>=2.2.0
+torch
+numpy
+httpx>=0.24.0