Update app.py

app.py

@@ -2,87 +2,125 @@ import os
 import uvicorn
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
-from transformers import pipeline
+from transformers import pipeline, AutoTokenizer, AutoModel, set_seed
 import torch
 from typing import Optional
+import asyncio
+import time
+import gc
 
 # Inisialisasi FastAPI
-app = FastAPI(title="LyonPoy AI Chat")
+app = FastAPI(title="LyonPoy AI Chat - CPU Optimized")
 
-# All 11 models configuration
+# Set seed untuk konsistensi
+set_seed(42)
+
+# CPU-Optimized 11 models configuration
 MODELS = {
-    "tinny-llama": {
-        "name": "Tinny Llama",
-        "model_path": "Lyon28/Tinny-Llama",
-        "task": "text-generation"
+    "distil-gpt-2": {
+        "name": "DistilGPT-2 ⚡",
+        "model_path": "Lyon28/Distil_GPT-2",
+        "task": "text-generation",
+        "max_tokens": 20,
+        "priority": 1  # Tercepat
     },
-    "pythia": {
-        "name": "Pythia",
-        "model_path": "Lyon28/Pythia",
-        "task": "text-generation"
+    "gpt-2-tinny": {
+        "name": "GPT-2 Tinny ⚡",
+        "model_path": "Lyon28/GPT-2-Tinny",
+        "task": "text-generation",
+        "max_tokens": 18,
+        "priority": 1
     },
     "bert-tinny": {
-        "name": "BERT Tinny",
+        "name": "BERT Tinny 📊",
         "model_path": "Lyon28/Bert-Tinny",
-        "task": "text-classification"
+        "task": "text-classification",
+        "max_tokens": 0,
+        "priority": 1
+    },
+    "distilbert-base-uncased": {
+        "name": "DistilBERT 📊",
+        "model_path": "Lyon28/Distilbert-Base-Uncased",
+        "task": "text-classification",
+        "max_tokens": 0,
+        "priority": 1
     },
     "albert-base-v2": {
-        "name": "ALBERT Base V2",
+        "name": "ALBERT Base 📊",
         "model_path": "Lyon28/Albert-Base-V2",
-        "task": "text-classification"
+        "task": "text-classification",
+        "max_tokens": 0,
+        "priority": 2
+    },
+    "electra-small": {
+        "name": "ELECTRA Small 📊",
+        "model_path": "Lyon28/Electra-Small",
+        "task": "text-classification",
+        "max_tokens": 0,
+        "priority": 2
     },
     "t5-small": {
-        "name": "T5 Small",
+        "name": "T5 Small 🔄",
         "model_path": "Lyon28/T5-Small",
-        "task": "text2text-generation"
+        "task": "text2text-generation",
+        "max_tokens": 25,
+        "priority": 2
     },
     "gpt-2": {
-        "name": "GPT-2",
+        "name": "GPT-2 Standard",
         "model_path": "Lyon28/GPT-2",
-        "task": "text-generation"
+        "task": "text-generation",
+        "max_tokens": 22,
+        "priority": 2
+    },
+    "tinny-llama": {
+        "name": "Tinny Llama",
+        "model_path": "Lyon28/Tinny-Llama",
+        "task": "text-generation",
+        "max_tokens": 25,
+        "priority": 3
+    },
+    "pythia": {
+        "name": "Pythia",
+        "model_path": "Lyon28/Pythia",
+        "task": "text-generation",
+        "max_tokens": 25,
+        "priority": 3
     },
     "gpt-neo": {
         "name": "GPT-Neo",
         "model_path": "Lyon28/GPT-Neo",
-        "task": "text-generation"
-    },
-    "distilbert-base-uncased": {
-        "name": "DistilBERT",
-        "model_path": "Lyon28/Distilbert-Base-Uncased",
-        "task": "text-classification"
-    },
-    "distil-gpt-2": {
-        "name": "DistilGPT-2",
-        "model_path": "Lyon28/Distil_GPT-2",
-        "task": "text-generation"
-    },
-    "gpt-2-tinny": {
-        "name": "GPT-2 Tinny",
-        "model_path": "Lyon28/GPT-2-Tinny",
-        "task": "text-generation"
-    },
-    "electra-small": {
-        "name": "ELECTRA Small",
-        "model_path": "Lyon28/Electra-Small",
-        "task": "text-classification"
+        "task": "text-generation",
+        "max_tokens": 30,
+        "priority": 3
     }
 }
 
 class ChatRequest(BaseModel):
     message: str
-    model: Optional[str] = "gpt-2"
+    model: Optional[str] = "distil-gpt-2"
 
-# Startup
+# CPU-Optimized startup
 @app.on_event("startup")
 async def load_models():
     app.state.pipelines = {}
+    app.state.tokenizers = {}
+    
+    # Set CPU optimizations
+    torch.set_num_threads(2)  # Limit threads untuk Hugging Face
+    os.environ['OMP_NUM_THREADS'] = '2'
+    os.environ['MKL_NUM_THREADS'] = '2'
+    os.environ['NUMEXPR_NUM_THREADS'] = '2'
+    
+    # Set cache
     os.environ['HF_HOME'] = '/tmp/.cache/huggingface'
+    os.environ['TRANSFORMERS_CACHE'] = '/tmp/.cache/huggingface'
     os.makedirs(os.environ['HF_HOME'], exist_ok=True)
-    print("🤖 LyonPoy AI Chat Ready!")
+    
+    print("🚀 LyonPoy AI Chat - CPU Optimized Ready!")
 
-# Frontend route
+# Lightweight frontend
 @app.get("/", response_class=HTMLResponse)
 async def get_frontend():
     html_content = '''
@@ -91,107 +129,133 @@ async def get_frontend():
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>LyonPoy AI Chat</title>
+    <title>LyonPoy AI Chat - CPU Fast</title>
     <style>
         * { margin: 0; padding: 0; box-sizing: border-box; }
         body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             height: 100vh; display: flex; justify-content: center; align-items: center;
         }
         .chat-container {
             width: 400px; height: 600px; background: #fff; border-radius: 15px;
-            box-shadow: 0 20px 40px rgba(0,0,0,0.15); display: flex; flex-direction: column; overflow: hidden;
+            box-shadow: 0 15px 35px rgba(0,0,0,0.1); display: flex; flex-direction: column; overflow: hidden;
         }
         .chat-header {
-            background: linear-gradient(135deg, #25d366, #128c7e); color: white;
-            padding: 20px; text-align: center;
+            background: linear-gradient(135deg, #00b4db, #0083b0); color: white;
+            padding: 15px; text-align: center;
+        }
+        .chat-header h1 { font-size: 16px; font-weight: 600; margin-bottom: 5px; }
+        .cpu-badge { 
+            background: rgba(255,255,255,0.2); padding: 3px 8px; border-radius: 10px; 
+            font-size: 10px; display: inline-block; margin-top: 3px;
         }
-        .chat-header h1 { font-size: 18px; font-weight: 600; margin-bottom: 8px; }
         .model-selector {
             background: rgba(255,255,255,0.2); border: none; color: white;
-            padding: 8px 12px; border-radius: 20px; font-size: 12px; cursor: pointer;
+            padding: 6px 10px; border-radius: 15px; font-size: 11px; cursor: pointer;
+            margin-top: 8px; width: 100%;
         }
         .chat-messages {
-            flex: 1; padding: 20px; overflow-y: auto; background: #f0f0f0;
-            display: flex; flex-direction: column; gap: 15px;
+            flex: 1; padding: 15px; overflow-y: auto; background: #f8f9fa;
+            display: flex; flex-direction: column; gap: 12px;
         }
         .message {
-            max-width: 80%; padding: 12px 16px; border-radius: 15px;
-            font-size: 14px; line-height: 1.4; animation: slideIn 0.3s ease;
+            max-width: 85%; padding: 10px 14px; border-radius: 12px;
+            font-size: 13px; line-height: 1.3; word-wrap: break-word;
         }
         .message.user {
-            background: #25d366; color: white; align-self: flex-end; border-bottom-right-radius: 5px;
+            background: #00b4db; color: white; align-self: flex-end; 
+            border-bottom-right-radius: 4px;
         }
         .message.bot {
             background: white; color: #333; align-self: flex-start;
-            border-bottom-left-radius: 5px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+            border-bottom-left-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        }
+        .message-time { font-size: 10px; opacity: 0.6; margin-top: 3px; }
+        .response-time { 
+            font-size: 9px; color: #666; margin-top: 2px; 
+            display: flex; align-items: center; gap: 3px;
+        }
+        .speed-indicator {
+            width: 6px; height: 6px; border-radius: 50%; display: inline-block;
         }
-        .message-time { font-size: 11px; opacity: 0.7; margin-top: 5px; }
+        .fast { background: #22c55e; }
+        .medium { background: #f59e0b; }
+        .slow { background: #ef4444; }
         .chat-input-container {
-            padding: 20px; background: white; border-top: 1px solid #e0e0e0;
-            display: flex; gap: 10px; align-items: center;
+            padding: 15px; background: white; border-top: 1px solid #e5e7eb;
+            display: flex; gap: 8px; align-items: center;
         }
         .chat-input {
-            flex: 1; padding: 12px 16px; border: 1px solid #e0e0e0;
-            border-radius: 25px; font-size: 14px; outline: none;
+            flex: 1; padding: 10px 14px; border: 1px solid #d1d5db;
+            border-radius: 20px; font-size: 13px; outline: none;
         }
-        .chat-input:focus { border-color: #25d366; box-shadow: 0 0 0 2px rgba(37, 211, 102, 0.2); }
+        .chat-input:focus { border-color: #00b4db; }
         .send-button {
-            background: #25d366; color: white; border: none; border-radius: 50%;
-            width: 45px; height: 45px; cursor: pointer; display: flex;
-            align-items: center; justify-content: center;
+            background: #00b4db; color: white; border: none; border-radius: 50%;
+            width: 40px; height: 40px; cursor: pointer; display: flex;
+            align-items: center; justify-content: center; font-size: 16px;
         }
-        .send-button:hover { background: #128c7e; }
-        .send-button:disabled { background: #ccc; cursor: not-allowed; }
+        .send-button:hover { background: #0083b0; }
+        .send-button:disabled { background: #d1d5db; cursor: not-allowed; }
         .welcome-message {
-            text-align: center; color: #666; font-size: 13px;
-            padding: 20px; border-radius: 10px; background: rgba(255,255,255,0.7);
+            text-align: center; color: #6b7280; font-size: 12px;
+            padding: 15px; border-radius: 8px; background: rgba(255,255,255,0.8);
         }
         .typing-indicator {
-            display: none; align-items: center; gap: 5px; padding: 12px 16px;
-            background: white; border-radius: 15px; align-self: flex-start;
+            display: none; align-items: center; gap: 4px; padding: 10px 14px;
+            background: white; border-radius: 12px; align-self: flex-start;
         }
         .typing-dot {
-            width: 8px; height: 8px; background: #999; border-radius: 50%;
-            animation: typing 1.4s infinite;
+            width: 6px; height: 6px; background: #9ca3af; border-radius: 50%;
+            animation: typing 1.2s infinite;
+        }
+        .typing-dot:nth-child(2) { animation-delay: 0.15s; }
+        .typing-dot:nth-child(3) { animation-delay: 0.3s; }
+        @keyframes typing { 0%, 60%, 100% { opacity: 0.3; } 30% { opacity: 1; } }
+        .model-status {
+            font-size: 10px; color: rgba(255,255,255,0.8); margin-top: 3px;
+        }
+        @media (max-width: 480px) { 
+            .chat-container { width: 100vw; height: 100vh; border-radius: 0; } 
+            .chat-header { padding: 12px; }
+            .chat-messages { padding: 12px; }
         }
-        .typing-dot:nth-child(2) { animation-delay: 0.2s; }
-        .typing-dot:nth-child(3) { animation-delay: 0.4s; }
-        @keyframes typing { 0%, 60%, 100% { transform: translateY(0); } 30% { transform: translateY(-10px); } }
-        @keyframes slideIn { from { opacity: 0; transform: translateY(20px); } to { opacity: 1; transform: translateY(0); } }
-        @media (max-width: 480px) { .chat-container { width: 100vw; height: 100vh; border-radius: 0; } }
     </style>
 </head>
 <body>
     <div class="chat-container">
         <div class="chat-header">
-            <h1>🤖 LyonPoy AI Chat</h1>
+            <h1>⚡ LyonPoy AI Chat</h1>
+            <div class="cpu-badge">CPU Optimized</div>
             <select class="model-selector" id="modelSelect">
-                <option value="gpt-2">GPT-2 (General)</option>
+                <option value="distil-gpt-2">🚀 DistilGPT-2 (Fastest)</option>
+                <option value="gpt-2-tinny">🚀 GPT-2 Tinny (Fast)</option>
+                <option value="bert-tinny">📊 BERT Tinny (Analysis)</option>
+                <option value="distilbert-base-uncased">📊 DistilBERT (Analysis)</option>
+                <option value="albert-base-v2">📊 ALBERT Base</option>
+                <option value="electra-small">📊 ELECTRA Small</option>
+                <option value="t5-small">🔄 T5 Small (Transform)</option>
+                <option value="gpt-2">GPT-2 Standard</option>
                 <option value="tinny-llama">Tinny Llama</option>
                 <option value="pythia">Pythia</option>
                 <option value="gpt-neo">GPT-Neo</option>
-                <option value="distil-gpt-2">DistilGPT-2</option>
-                <option value="gpt-2-tinny">GPT-2 Tinny</option>
-                <option value="bert-tinny">BERT Tinny</option>
-                <option value="albert-base-v2">ALBERT Base V2</option>
-                <option value="distilbert-base-uncased">DistilBERT</option>
-                <option value="electra-small">ELECTRA Small</option>
-                <option value="t5-small">T5 Small</option>
             </select>
+            <div class="model-status" id="modelStatus">Ready to chat!</div>
         </div>
         <div class="chat-messages" id="chatMessages">
             <div class="welcome-message">
-                👋 Halo! Saya LyonPoy AI Assistant.<br>
-                Pilih model di atas dan mulai chat dengan saya!
+                🚀 <strong>CPU-Optimized AI Chat</strong><br>
+                Models dioptimalkan untuk kecepatan di CPU<br>
+                Pilih model dan mulai chat!
             </div>
         </div>
         <div class="typing-indicator" id="typingIndicator">
             <div class="typing-dot"></div><div class="typing-dot"></div><div class="typing-dot"></div>
+            <span style="font-size: 11px; color: #6b7280; margin-left: 5px;">AI sedang berpikir...</span>
         </div>
         <div class="chat-input-container">
-            <input type="text" class="chat-input" id="chatInput" placeholder="Ketik pesan..." maxlength="500">
+            <input type="text" class="chat-input" id="chatInput" placeholder="Ketik pesan singkat (max 100 karakter)..." maxlength="100">
             <button class="send-button" id="sendButton">➤</button>
         </div>
     </div>
@@ -201,119 +265,325 @@ async def get_frontend():
         const sendButton = document.getElementById('sendButton');
         const modelSelect = document.getElementById('modelSelect');
         const typingIndicator = document.getElementById('typingIndicator');
+        const modelStatus = document.getElementById('modelStatus');
+
+        // Production API Base
+        const API_BASE = window.location.origin;
 
-        function scrollToBottom() { chatMessages.scrollTop = chatMessages.scrollHeight; }
+        function scrollToBottom() { 
+            chatMessages.scrollTop = chatMessages.scrollHeight; 
+        }
+        
+        function getSpeedClass(time) {
+            if (time < 2000) return 'fast';
+            if (time < 5000) return 'medium';
+            return 'slow';
+        }
         
-        function addMessage(content, isUser = false) {
+        function addMessage(content, isUser = false, responseTime = null) {
             const messageDiv = document.createElement('div');
             messageDiv.className = `message ${isUser ? 'user' : 'bot'}`;
             const time = new Date().toLocaleTimeString('id-ID', { hour: '2-digit', minute: '2-digit' });
-            messageDiv.innerHTML = `${content}<div class="message-time">${time}</div>`;
+            
+            let timeInfo = `<div class="message-time">${time}</div>`;
+            if (responseTime && !isUser) {
+                const speedClass = getSpeedClass(responseTime);
+                timeInfo += `<div class="response-time">
+                    <span class="speed-indicator ${speedClass}"></span>
+                    ${responseTime}ms
+                </div>`;
+            }
+            
+            messageDiv.innerHTML = `${content}${timeInfo}`;
             chatMessages.appendChild(messageDiv);
             scrollToBottom();
         }
 
-        function showTyping() { typingIndicator.style.display = 'flex'; scrollToBottom(); }
-        function hideTyping() { typingIndicator.style.display = 'none'; }
+        function showTyping() { 
+            typingIndicator.style.display = 'flex'; 
+            scrollToBottom(); 
+        }
+        
+        function hideTyping() { 
+            typingIndicator.style.display = 'none'; 
+        }
 
         async function sendMessage() {
             const message = chatInput.value.trim();
             if (!message) return;
 
-            chatInput.disabled = true; sendButton.disabled = true;
-            addMessage(message, true); chatInput.value = ''; showTyping();
+            chatInput.disabled = true; 
+            sendButton.disabled = true;
+            modelStatus.textContent = 'Processing...';
+            
+            addMessage(message, true); 
+            chatInput.value = ''; 
+            showTyping();
+            
+            const startTime = Date.now();
 
             try {
                 const response = await fetch('/chat', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ message: message, model: modelSelect.value })
+                    body: JSON.stringify({ 
+                        message: message, 
+                        model: modelSelect.value 
+                    })
                 });
+                
                 const data = await response.json();
+                const responseTime = Date.now() - startTime;
+                
                 hideTyping();
+                modelStatus.textContent = 'Ready';
+                
                 if (data.status === 'success') {
-                    addMessage(data.response);
+                    addMessage(data.response, false, responseTime);
                 } else {
-                    addMessage('❌ Maaf, terjadi kesalahan. Coba lagi nanti.');
+                    addMessage('⚠️ Model sedang loading, tunggu sebentar...', false, responseTime);
                 }
             } catch (error) {
+                const responseTime = Date.now() - startTime;
                 hideTyping();
-                addMessage('❌ Tidak dapat terhubung ke server.');
+                modelStatus.textContent = 'Error';
+                addMessage('❌ Koneksi bermasalah, coba lagi.', false, responseTime);
+                console.error('Error:', error);
             }
-            chatInput.disabled = false; sendButton.disabled = false; chatInput.focus();
+            
+            chatInput.disabled = false; 
+            sendButton.disabled = false; 
+            chatInput.focus();
         }
 
+        // Event listeners
         sendButton.addEventListener('click', sendMessage);
-        chatInput.addEventListener('keypress', (e) => { if (e.key === 'Enter') sendMessage(); });
+        chatInput.addEventListener('keypress', (e) => { 
+            if (e.key === 'Enter') sendMessage(); 
+        });
+        
         modelSelect.addEventListener('change', () => {
-            const modelName = modelSelect.options[modelSelect.selectedIndex].text;
-            addMessage(`🔄 Model diubah ke: ${modelName}`);
+            const selectedOption = modelSelect.options[modelSelect.selectedIndex];
+            const modelName = selectedOption.text;
+            modelStatus.textContent = `Model: ${modelName}`;
+            addMessage(`🔄 Switched to: ${modelName}`);
+        });
+        
+        // Auto-focus on load
+        window.addEventListener('load', () => {
+            chatInput.focus();
+            modelStatus.textContent = 'DistilGPT-2 Ready (Fastest)';
+        });
+        
+        // Character counter
+        chatInput.addEventListener('input', () => {
+            const remaining = 100 - chatInput.value.length;
+            if (remaining < 20) {
+                chatInput.style.borderColor = remaining < 10 ? '#ef4444' : '#f59e0b';
+            } else {
+                chatInput.style.borderColor = '#d1d5db';
+            }
         });
-        window.addEventListener('load', () => chatInput.focus());
     </script>
 </body>
 </html>
     '''
     return HTMLResponse(content=html_content)
 
-# Chat API
+# CPU-Optimized Chat API
 @app.post("/chat")
 async def chat(request: ChatRequest):
+    start_time = time.time()
+    
     try:
         model_id = request.model.lower()
         if model_id not in MODELS:
-            raise HTTPException(status_code=400, detail="Model tidak tersedia")
+            model_id = "distil-gpt-2"  # Default ke model tercepat
         
         model_config = MODELS[model_id]
         
-        # Load model jika belum ada
+        # Lazy loading dengan optimasi CPU
         if model_id not in app.state.pipelines:
-            print(f"⏳ Loading {model_config['name']}...")
-            device = 0 if torch.cuda.is_available() else -1
-            dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+            print(f"⚡ CPU Loading {model_config['name']}...")
             
-            app.state.pipelines[model_id] = pipeline(
-                task=model_config["task"],
-                model=model_config["model_path"],
-                device=device,
-                torch_dtype=dtype
-            )
+            # CPU-specific optimizations
+            pipeline_kwargs = {
+                "task": model_config["task"],
+                "model": model_config["model_path"],
+                "device": -1,  # Force CPU
+                "torch_dtype": torch.float32,  # CPU works best with float32
+                "model_kwargs": {
+                    "torchscript": False,
+                    "low_cpu_mem_usage": True
+                }
+            }
+            
+            app.state.pipelines[model_id] = pipeline(**pipeline_kwargs)
+            
+            # Cleanup memory
+            gc.collect()
         
         pipe = app.state.pipelines[model_id]
         
-        # Process berdasarkan task
+        # Ultra-fast processing dengan parameter minimal
+        input_text = request.message[:80]  # Limit input untuk CPU
+        
         if model_config["task"] == "text-generation":
+            # Minimal parameters untuk CPU speed
             result = pipe(
-                request.message,
-                max_length=min(len(request.message.split()) + 50, 200),
+                input_text,
+                max_length=min(len(input_text.split()) + model_config["max_tokens"], 60),
                 temperature=0.7,
                 do_sample=True,
-                pad_token_id=pipe.tokenizer.eos_token_id
+                top_p=0.85,
+                pad_token_id=pipe.tokenizer.eos_token_id,
+                num_return_sequences=1,
+                early_stopping=True
             )[0]['generated_text']
             
-            # Clean output
-            if result.startswith(request.message):
-                result = result[len(request.message):].strip()
+            # Quick cleanup
+            if result.startswith(input_text):
+                result = result[len(input_text):].strip()
             
+            # Limit to 1 sentence untuk speed
+            if '.' in result:
+                result = result.split('.')[0] + '.'
+            elif len(result) > 80:
+                result = result[:77] + '...'
+                
         elif model_config["task"] == "text-classification":
-            output = pipe(request.message)[0]
-            result = f"Sentimen: {output['label']} (Confidence: {output['score']:.2f})"
+            output = pipe(input_text, truncation=True, max_length=128)[0]
+            confidence = f"{output['score']:.2f}"
+            result = f"📊 {output['label']} ({confidence})"
             
         elif model_config["task"] == "text2text-generation":
-            result = pipe(request.message, max_length=150)[0]['generated_text']
+            result = pipe(
+                input_text, 
+                max_length=model_config["max_tokens"],
+                temperature=0.6,
+                early_stopping=True
+            )[0]['generated_text']
+        
+        # Final cleanup
+        if not result or len(result.strip()) < 3:
+            result = "🤔 Hmm, coba kata lain?"
+        elif len(result) > 100:
+            result = result[:97] + "..."
+            
+        processing_time = round((time.time() - start_time) * 1000)
+        
+        return {
+            "response": result,
+            "model": model_config["name"],
+            "status": "success",
+            "processing_time": f"{processing_time}ms"
+        }
+        
+    except Exception as e:
+        print(f"❌ CPU Error: {e}")
+        processing_time = round((time.time() - start_time) * 1000)
+        
+        # Fallback response
+        fallback_responses = [
+            "🔄 Coba lagi dengan kata yang lebih simple?",
+            "💭 Hmm, mungkin pertanyaan lain?", 
+            "⚡ Model sedang optimal, tunggu sebentar...",
+            "🚀 Coba model lain yang lebih cepat?"
+        ]
+        
+        import random
+        fallback = random.choice(fallback_responses)
+        
+        return {
+            "response": fallback,
+            "status": "error",
+            "processing_time": f"{processing_time}ms"
+        }
+
+# Optimized inference endpoint untuk production
+@app.post("/inference")
+async def inference(request: dict):
+    """CPU-Optimized inference endpoint"""
+    try:
+        message = request.get("message", "")[:80]  # Limit input
+        model_path = request.get("model", "Lyon28/Distil_GPT-2")
+        
+        # Fast model mapping
+        model_key = model_path.split("/")[-1].lower()
+        model_mapping = {
+            "distil_gpt-2": "distil-gpt-2",
+            "distil-gpt-2": "distil-gpt-2", 
+            "gpt-2-tinny": "gpt-2-tinny",
+            "bert-tinny": "bert-tinny",
+            "distilbert-base-uncased": "distilbert-base-uncased",
+            "albert-base-v2": "albert-base-v2",
+            "electra-small": "electra-small",
+            "t5-small": "t5-small",
+            "gpt-2": "gpt-2",
+            "tinny-llama": "tinny-llama",
+            "pythia": "pythia",
+            "gpt-neo": "gpt-neo"
+        }
+        
+        internal_model = model_mapping.get(model_key, "distil-gpt-2")
         
-        return {"response": result, "model": model_config["name"], "status": "success"}
+        # Quick processing
+        chat_request = ChatRequest(message=message, model=internal_model)
+        result = await chat(chat_request)
+        
+        return {
+            "result": result["response"],
+            "status": "success",
+            "model_used": result["model"],
+            "processing_time": result.get("processing_time", "0ms")
+        }
         
     except Exception as e:
-        print(f"❌ Error: {e}")
-        raise HTTPException(status_code=500, detail="Terjadi kesalahan")
+        print(f"❌ Inference Error: {e}")
+        return {
+            "result": "🔄 Sedang optimasi, coba lagi...",
+            "status": "error"
+        }
 
-# Health check
+# Lightweight health check
 @app.get("/health")
 async def health():
-    return {"status": "healthy", "gpu": torch.cuda.is_available()}
+    loaded_models = len(app.state.pipelines) if hasattr(app.state, 'pipelines') else 0
+    return {
+        "status": "healthy",
+        "platform": "CPU",
+        "loaded_models": loaded_models,
+        "total_models": len(MODELS),
+        "optimization": "CPU-Tuned"
+    }
+
+# Model info endpoint
+@app.get("/models")
+async def get_models():
+    return {
+        "models": [
+            {
+                "id": k,
+                "name": v["name"],
+                "task": v["task"],
+                "max_tokens": v["max_tokens"],
+                "priority": v["priority"],
+                "cpu_optimized": True
+            } 
+            for k, v in MODELS.items()
+        ],
+        "platform": "CPU",
+        "recommended": ["distil-gpt-2", "gpt-2-tinny", "bert-tinny"]
+    }
 
-# Run app
+# Run with CPU optimizations
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        workers=1,  # Single worker untuk CPU
+        timeout_keep_alive=30,
+        access_log=False  # Disable access log untuk performance
+    )