Replace app.py with pure API version - no HTML interfaces

app.py

@@ -1,23 +1,19 @@
 #!/usr/bin/env python3
 """
-Textilindo AI Assistant - Hugging Face Spaces FastAPI Application
-Main application file for deployment on Hugging Face Spaces
+Textilindo AI Training API - Pure API Version
+No HTML interfaces, only API endpoints for training and chat
 """
 
 import os
 import json
 import logging
+import torch
 from pathlib import Path
-from typing import Optional, Dict, Any
-from fastapi import FastAPI, HTTPException, Request, BackgroundTasks
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-from fastapi.middleware.cors import CORSMiddleware
+from datetime import datetime
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, HTTPException, BackgroundTasks
 from pydantic import BaseModel
 import uvicorn
-from huggingface_hub import InferenceClient
-import requests
-from datetime import datetime
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
@@ -25,21 +21,40 @@ logger = logging.getLogger(__name__)
 
 # Initialize FastAPI app
 app = FastAPI(
-    title="Textilindo AI Assistant",
-    description="AI Assistant for Textilindo textile company",
+    title="Textilindo AI Training API",
+    description="Pure API-based training system for Textilindo AI Assistant",
     version="1.0.0"
 )
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# Training status storage
+training_status = {
+    "is_training": False,
+    "progress": 0,
+    "status": "idle",
+    "current_step": 0,
+    "total_steps": 0,
+    "loss": 0.0,
+    "start_time": None,
+    "end_time": None,
+    "error": None
+}
 
 # Request/Response models
+class TrainingRequest(BaseModel):
+    model_name: str = "distilgpt2"
+    dataset_path: str = "data/lora_dataset_20250910_145055.jsonl"
+    config_path: str = "configs/training_config.yaml"
+    max_samples: int = 20
+    epochs: int = 1
+    batch_size: int = 1
+    learning_rate: float = 5e-5
+
+class TrainingResponse(BaseModel):
+    success: bool
+    message: str
+    training_id: str
+    status: str
+
 class ChatRequest(BaseModel):
     message: str
     conversation_id: Optional[str] = None
@@ -49,240 +64,47 @@ class ChatResponse(BaseModel):
     conversation_id: str
     status: str = "success"
 
-class HealthResponse(BaseModel):
-    status: str
-    message: str
-    version: str = "1.0.0"
-
-class TextilindoAI:
-    """Textilindo AI Assistant using HuggingFace Inference API"""
-    
-    def __init__(self):
-        self.api_key = os.getenv('HUGGINGFACE_API_KEY')
-        self.model = os.getenv('DEFAULT_MODEL', 'meta-llama/Llama-3.1-8B-Instruct')
-        self.system_prompt = self.load_system_prompt()
-        
-        if not self.api_key:
-            logger.warning("HUGGINGFACE_API_KEY not found. Using mock responses.")
-            self.client = None
-        else:
-            try:
-                self.client = InferenceClient(
-                    token=self.api_key,
-                    model=self.model
-                )
-                logger.info(f"Initialized with model: {self.model}")
-            except Exception as e:
-                logger.error(f"Failed to initialize InferenceClient: {e}")
-                self.client = None
-    
-    def load_system_prompt(self) -> str:
-        """Load system prompt from config file"""
-        try:
-            prompt_path = Path("configs/system_prompt.md")
-            if prompt_path.exists():
-                with open(prompt_path, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                
-                # Extract system prompt from markdown
-                if 'SYSTEM_PROMPT = """' in content:
-                    start = content.find('SYSTEM_PROMPT = """') + len('SYSTEM_PROMPT = """')
-                    end = content.find('"""', start)
-                    return content[start:end].strip()
-                else:
-                    # Fallback: use entire content
-                    return content.strip()
-            else:
-                return self.get_default_system_prompt()
-        except Exception as e:
-            logger.error(f"Error loading system prompt: {e}")
-            return self.get_default_system_prompt()
-    
-    def get_default_system_prompt(self) -> str:
-        """Default system prompt if file not found"""
-        return """You are a friendly and helpful AI assistant for Textilindo, a textile company.
-        
-Always respond in Indonesian (Bahasa Indonesia).
-Keep responses short and direct.
-Be friendly and helpful.
-Use exact information from the knowledge base.
-The company uses yards for sales.
-Minimum purchase is 1 roll (67-70 yards)."""
-    
-    def generate_response(self, user_message: str) -> str:
-        """Generate response using HuggingFace Inference API"""
-        if not self.client:
-            return self.get_mock_response(user_message)
-        
-        try:
-            # Create full prompt with system prompt
-            full_prompt = f"<|system|>\n{self.system_prompt}\n<|user|>\n{user_message}\n<|assistant|>\n"
-            
-            # Generate response
-            response = self.client.text_generation(
-                full_prompt,
-                max_new_tokens=512,
-                temperature=0.7,
-                top_p=0.9,
-                top_k=40,
-                repetition_penalty=1.1,
-                stop_sequences=["<|end|>", "<|user|>"]
-            )
-            
-            # Extract only the assistant's response
-            if "<|assistant|>" in response:
-                assistant_response = response.split("<|assistant|>")[-1].strip()
-                assistant_response = assistant_response.replace("<|end|>", "").strip()
-                return assistant_response
-            else:
-                return response
-                
-        except Exception as e:
-            logger.error(f"Error generating response: {e}")
-            return self.get_mock_response(user_message)
-    
-    def get_mock_response(self, user_message: str) -> str:
-        """Mock responses for testing without API key"""
-        mock_responses = {
-            "dimana lokasi textilindo": "Textilindo berkantor pusat di Jl. Raya Prancis No.39, Kosambi Tim., Kec. Kosambi, Kabupaten Tangerang, Banten 15213",
-            "jam berapa textilindo beroperasional": "Jam operasional Senin-Jumat 08:00-17:00, Sabtu 08:00-12:00.",
-            "berapa ketentuan pembelian": "Minimal order 1 roll per jenis kain",
-            "bagaimana dengan pembayarannya": "Pembayaran dapat dilakukan via transfer bank atau cash on delivery",
-            "apa ada gratis ongkir": "Gratis ongkir untuk order minimal 5 roll.",
-            "apa bisa dikirimkan sample": "hallo kak untuk sampel kita bisa kirimkan gratis ya kak 😊"
+# API Information
+@app.get("/")
+async def api_info():
+    """API information endpoint"""
+    return {
+        "name": "Textilindo AI Training API",
+        "version": "1.0.0",
+        "description": "Pure API-based training system for Textilindo AI Assistant",
+        "hardware": "2 vCPU, 16 GB RAM (CPU basic)",
+        "status": "ready",
+        "endpoints": {
+            "training": {
+                "start": "POST /api/train/start",
+                "status": "GET /api/train/status", 
+                "data": "GET /api/train/data",
+                "gpu": "GET /api/train/gpu",
+                "test": "POST /api/train/test"
+            },
+            "chat": {
+                "chat": "POST /chat",
+                "health": "GET /health"
+            }
         }
-        
-        # Simple keyword matching
-        user_lower = user_message.lower()
-        for key, response in mock_responses.items():
-            if any(word in user_lower for word in key.split()):
-                return response
-                
-        return "Halo! Saya adalah asisten AI Textilindo. Bagaimana saya bisa membantu Anda hari ini? 😊"
-
-# Initialize AI assistant
-ai_assistant = TextilindoAI()
-
-# Routes
-@app.get("/", response_class=HTMLResponse)
-async def root():
-    """Serve the main chat interface"""
-    try:
-        with open("templates/chat.html", "r", encoding="utf-8") as f:
-            return HTMLResponse(content=f.read())
-    except FileNotFoundError:
-        return HTMLResponse(content="""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>Textilindo AI Assistant</title>
-            <meta charset="utf-8">
-            <style>
-                body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
-                .chat-container { border: 1px solid #ddd; border-radius: 10px; padding: 20px; margin: 20px 0; }
-                .message { margin: 10px 0; padding: 10px; border-radius: 5px; }
-                .user { background-color: #e3f2fd; text-align: right; }
-                .assistant { background-color: #f5f5f5; }
-                input[type="text"] { width: 70%; padding: 10px; border: 1px solid #ddd; border-radius: 5px; }
-                button { padding: 10px 20px; background-color: #2196f3; color: white; border: none; border-radius: 5px; cursor: pointer; }
-            </style>
-        </head>
-        <body>
-            <h1>🤖 Textilindo AI Assistant</h1>
-            <div class="chat-container">
-                <div id="chat-messages"></div>
-                <div style="margin-top: 20px;">
-                    <input type="text" id="message-input" placeholder="Tulis pesan Anda..." onkeypress="handleKeyPress(event)">
-                    <button onclick="sendMessage()">Kirim</button>
-                </div>
-            </div>
-            <script>
-                async function sendMessage() {
-                    const input = document.getElementById('message-input');
-                    const message = input.value.trim();
-                    if (!message) return;
-                    
-                    // Add user message
-                    addMessage(message, 'user');
-                    input.value = '';
-                    
-                    // Get AI response
-                    try {
-                        const response = await fetch('/chat', {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json' },
-                            body: JSON.stringify({ message: message })
-                        });
-                        const data = await response.json();
-                        addMessage(data.response, 'assistant');
-                    } catch (error) {
-                        addMessage('Maaf, terjadi kesalahan. Silakan coba lagi.', 'assistant');
-                    }
-                }
-                
-                function addMessage(text, sender) {
-                    const messages = document.getElementById('chat-messages');
-                    const div = document.createElement('div');
-                    div.className = `message ${sender}`;
-                    div.textContent = text;
-                    messages.appendChild(div);
-                    messages.scrollTop = messages.scrollHeight;
-                }
-                
-                function handleKeyPress(event) {
-                    if (event.key === 'Enter') {
-                        sendMessage();
-                    }
-                }
-            </script>
-        </body>
-        </html>
-        """)
-
-@app.post("/chat", response_model=ChatResponse)
-async def chat(request: ChatRequest):
-    """Chat endpoint"""
-    try:
-        response = ai_assistant.generate_response(request.message)
-        return ChatResponse(
-            response=response,
-            conversation_id=request.conversation_id or "default",
-            status="success"
-        )
-    except Exception as e:
-        logger.error(f"Error in chat endpoint: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error")
+    }
 
-@app.get("/health", response_model=HealthResponse)
+# Health check
+@app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    return HealthResponse(
-        status="healthy",
-        message="Textilindo AI Assistant is running",
-        version="1.0.0"
-    )
-
-@app.get("/info")
-async def get_info():
-    """Get application information"""
     return {
-        "name": "Textilindo AI Assistant",
-        "version": "1.0.0",
-        "model": ai_assistant.model,
-        "has_api_key": bool(ai_assistant.api_key),
-        "client_initialized": bool(ai_assistant.client)
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "hardware": "2 vCPU, 16 GB RAM"
     }
 
-# Import training API
-from training_api import (
-    TrainingRequest, TrainingResponse, training_status,
-    train_model_async, load_training_config, load_training_data, check_gpu_availability
-)
-
 # Training API endpoints
 @app.post("/api/train/start", response_model=TrainingResponse)
-async def start_training_api(request: TrainingRequest, background_tasks: BackgroundTasks):
-    """Start training process via API"""
+async def start_training(request: TrainingRequest, background_tasks: BackgroundTasks):
+    """Start training process"""
+    global training_status
+    
     if training_status["is_training"]:
         raise HTTPException(status_code=400, detail="Training already in progress")
     
@@ -315,12 +137,12 @@ async def start_training_api(request: TrainingRequest, background_tasks: Backgro
     )
 
 @app.get("/api/train/status")
-async def get_training_status_api():
+async def get_training_status():
     """Get current training status"""
     return training_status
 
 @app.get("/api/train/data")
-async def get_training_data_info_api():
+async def get_training_data_info():
     """Get information about available training data"""
     data_dir = Path("data")
     if not data_dir.exists():
@@ -350,10 +172,9 @@ async def get_training_data_info_api():
     }
 
 @app.get("/api/train/gpu")
-async def get_gpu_info_api():
+async def get_gpu_info():
     """Get GPU information"""
     try:
-        import torch
         gpu_available = torch.cuda.is_available()
         if gpu_available:
             gpu_count = torch.cuda.device_count()
@@ -371,7 +192,7 @@ async def get_gpu_info_api():
         return {"error": str(e)}
 
 @app.post("/api/train/test")
-async def test_trained_model_api():
+async def test_trained_model():
     """Test the trained model"""
     model_path = "./models/textilindo-trained"
     if not Path(model_path).exists():
@@ -379,7 +200,6 @@ async def test_trained_model_api():
     
     try:
         from transformers import AutoTokenizer, AutoModelForCausalLM
-        import torch
         
         tokenizer = AutoTokenizer.from_pretrained(model_path)
         model = AutoModelForCausalLM.from_pretrained(model_path)
@@ -409,160 +229,198 @@ async def test_trained_model_api():
     except Exception as e:
         return {"error": str(e)}
 
-# Legacy training endpoints (for backward compatibility)
-@app.get("/train")
-async def training_interface():
-    """Training interface"""
-    try:
-        with open("templates/training.html", "r", encoding="utf-8") as f:
-            return HTMLResponse(content=f.read())
-    except FileNotFoundError:
-        return HTMLResponse(content="""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>Textilindo AI Training</title>
-            <meta charset="utf-8">
-            <style>
-                body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
-                .container { background: #f5f5f5; padding: 20px; border-radius: 10px; margin: 20px 0; }
-                button { background: #2196f3; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; }
-                button:hover { background: #1976d2; }
-                .log { background: #000; color: #0f0; padding: 10px; border-radius: 5px; font-family: monospace; height: 300px; overflow-y: auto; }
-            </style>
-        </head>
-        <body>
-            <h1>🤖 Textilindo AI Training Interface</h1>
-            
-            <div class="container">
-                <h2>Training Options</h2>
-                <p>Choose your training method:</p>
-                
-                <button onclick="startLightweightTraining()">Start Lightweight Training</button>
-                <button onclick="checkResources()">Check Resources</button>
-                <button onclick="viewData()">View Training Data</button>
-            </div>
-            
-            <div class="container">
-                <h2>Training Log</h2>
-                <div id="log" class="log">Ready to start training...</div>
-            </div>
-            
-            <script>
-                function addLog(message) {
-                    const log = document.getElementById('log');
-                    const timestamp = new Date().toLocaleTimeString();
-                    log.innerHTML += `[${timestamp}] ${message}\\n`;
-                    log.scrollTop = log.scrollHeight;
-                }
-                
-                async function startLightweightTraining() {
-                    addLog('Starting lightweight training...');
-                    try {
-                        const response = await fetch('/train/start', {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json' }
-                        });
-                        const result = await response.json();
-                        addLog(`Training result: ${result.message}`);
-                    } catch (error) {
-                        addLog(`Error: ${error.message}`);
-                    }
-                }
-                
-                async function checkResources() {
-                    addLog('Checking resources...');
-                    try {
-                        const response = await fetch('/train/status');
-                        const result = await response.json();
-                        addLog(`Resources: ${JSON.stringify(result, null, 2)}`);
-                    } catch (error) {
-                        addLog(`Error: ${error.message}`);
-                    }
-                }
-                
-                async function viewData() {
-                    addLog('Loading training data...');
-                    try {
-                        const response = await fetch('/train/data');
-                        const result = await response.json();
-                        addLog(`Data files: ${result.files.join(', ')}`);
-                    } catch (error) {
-                        addLog(`Error: ${error.message}`);
-                    }
-                }
-            </script>
-        </body>
-        </html>
-        """)
-
-@app.post("/train/start")
-async def start_training():
-    """Start lightweight training"""
+# Chat API endpoint
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """Chat with the AI assistant"""
     try:
-        # Import training script
-        import subprocess
-        import sys
+        # Simple mock response for now
+        mock_responses = {
+            "dimana lokasi textilindo": "Textilindo berkantor pusat di Jl. Raya Prancis No.39, Kosambi Tim., Kec. Kosambi, Kabupaten Tangerang, Banten 15213",
+            "jam berapa textilindo beroperasional": "Jam operasional Senin-Jumat 08:00-17:00, Sabtu 08:00-12:00.",
+            "berapa ketentuan pembelian": "Minimal order 1 roll per jenis kain",
+            "apa ada gratis ongkir": "Gratis ongkir untuk order minimal 5 roll.",
+            "apa bisa dikirimkan sample": "Hallo kak untuk sampel kita bisa kirimkan gratis ya kak 😊"
+        }
         
-        # Run the training script
-        result = subprocess.run([
-            sys.executable, "train_on_space.py"
-        ], capture_output=True, text=True, timeout=300)  # 5 minute timeout
+        # Simple keyword matching
+        user_lower = request.message.lower()
+        response = "Halo! Saya adalah asisten AI Textilindo. Bagaimana saya bisa membantu Anda hari ini? 😊"
+        
+        for key, mock_response in mock_responses.items():
+            if any(word in user_lower for word in key.split()):
+                response = mock_response
+                break
+        
+        return ChatResponse(
+            response=response,
+            conversation_id=request.conversation_id or "default",
+            status="success"
+        )
         
-        if result.returncode == 0:
-            return {"message": "Training completed successfully!", "output": result.stdout}
-        else:
-            return {"message": "Training failed", "error": result.stderr}
-            
-    except subprocess.TimeoutExpired:
-        return {"message": "Training timed out (5 minutes limit)"}
     except Exception as e:
-        return {"message": f"Training error: {str(e)}"}
+        logger.error(f"Chat error: {e}")
+        return ChatResponse(
+            response="Maaf, terjadi kesalahan. Silakan coba lagi.",
+            conversation_id=request.conversation_id or "default",
+            status="error"
+        )
 
-@app.get("/train/status")
-async def training_status():
-    """Get training status and resources"""
+# Training function
+async def train_model_async(
+    model_name: str,
+    dataset_path: str,
+    config_path: str,
+    max_samples: int,
+    epochs: int,
+    batch_size: int,
+    learning_rate: float
+):
+    """Async training function"""
+    global training_status
+    
     try:
-        import psutil
+        training_status.update({
+            "is_training": True,
+            "status": "starting",
+            "progress": 0,
+            "start_time": datetime.now().isoformat(),
+            "error": None
+        })
+        
+        logger.info("🚀 Starting training...")
+        
+        # Import training libraries
+        from transformers import (
+            AutoTokenizer, 
+            AutoModelForCausalLM,
+            TrainingArguments,
+            Trainer,
+            DataCollatorForLanguageModeling
+        )
+        from datasets import Dataset
+        
+        # Check GPU
+        gpu_available = torch.cuda.is_available()
+        logger.info(f"GPU available: {gpu_available}")
+        
+        # Load model and tokenizer
+        logger.info(f"📥 Loading model: {model_name}")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        
+        # Load model
+        if gpu_available:
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16,
+                device_map="auto"
+            )
+        else:
+            model = AutoModelForCausalLM.from_pretrained(model_name)
+        
+        logger.info("✅ Model loaded successfully")
+        
+        # Load training data
+        training_data = load_training_data(dataset_path, max_samples)
+        if not training_data:
+            raise Exception("No training data loaded")
+        
+        # Convert to dataset
+        dataset = Dataset.from_list(training_data)
+        
+        def tokenize_function(examples):
+            return tokenizer(
+                examples["text"],
+                truncation=True,
+                padding=True,
+                max_length=256,
+                return_tensors="pt"
+            )
+        
+        tokenized_dataset = dataset.map(tokenize_function, batched=True)
+        
+        # Training arguments
+        training_args = TrainingArguments(
+            output_dir="./models/textilindo-trained",
+            num_train_epochs=epochs,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=2,
+            learning_rate=learning_rate,
+            warmup_steps=5,
+            save_steps=10,
+            logging_steps=1,
+            save_total_limit=1,
+            prediction_loss_only=True,
+            remove_unused_columns=False,
+            fp16=gpu_available,
+            dataloader_pin_memory=gpu_available,
+            report_to=None,
+        )
+        
+        # Data collator
+        data_collator = DataCollatorForLanguageModeling(
+            tokenizer=tokenizer,
+            mlm=False,
+        )
+        
+        # Create trainer
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=tokenized_dataset,
+            data_collator=data_collator,
+            tokenizer=tokenizer,
+        )
+        
+        # Start training
+        training_status["status"] = "training"
+        trainer.train()
+        
+        # Save model
+        model.save_pretrained("./models/textilindo-trained")
+        tokenizer.save_pretrained("./models/textilindo-trained")
+        
+        # Update status
+        training_status.update({
+            "is_training": False,
+            "status": "completed",
+            "progress": 100,
+            "end_time": datetime.now().isoformat()
+        })
+        
+        logger.info("✅ Training completed successfully!")
         
-        return {
-            "status": "ready",
-            "cpu_count": psutil.cpu_count(),
-            "memory_total_gb": round(psutil.virtual_memory().total / (1024**3), 2),
-            "memory_available_gb": round(psutil.virtual_memory().available / (1024**3), 2),
-            "disk_free_gb": round(psutil.disk_usage('.').free / (1024**3), 2)
-        }
     except Exception as e:
-        return {"status": "error", "message": str(e)}
+        logger.error(f"Training failed: {e}")
+        training_status.update({
+            "is_training": False,
+            "status": "failed",
+            "error": str(e),
+            "end_time": datetime.now().isoformat()
+        })
 
-@app.get("/train/data")
-async def training_data():
-    """Get training data information"""
+def load_training_data(dataset_path: str, max_samples: int = 20) -> list:
+    """Load training data from JSONL file"""
+    data = []
     try:
-        data_dir = Path("data")
-        if data_dir.exists():
-            jsonl_files = list(data_dir.glob("*.jsonl"))
-            return {
-                "files": [f.name for f in jsonl_files],
-                "count": len(jsonl_files)
-            }
-        else:
-            return {"files": [], "count": 0}
+        with open(dataset_path, 'r', encoding='utf-8') as f:
+            for i, line in enumerate(f):
+                if i >= max_samples:
+                    break
+                if line.strip():
+                    item = json.loads(line)
+                    # Create training text
+                    instruction = item.get('instruction', '')
+                    output = item.get('output', '')
+                    text = f"Question: {instruction} Answer: {output}"
+                    data.append({"text": text})
+        logger.info(f"Loaded {len(data)} training samples")
+        return data
     except Exception as e:
-        return {"error": str(e)}
-
-# Mount static files if they exist
-if Path("static").exists():
-    app.mount("/static", StaticFiles(directory="static"), name="static")
+        logger.error(f"Error loading data: {e}")
+        return []
 
 if __name__ == "__main__":
-    # Get port from environment variable (Hugging Face Spaces uses 7860)
-    port = int(os.getenv("PORT", 7860))
-    
-    # Run the application
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=port,
-        log_level="info"
-    )
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app_api_only.py

@@ -0,0 +1,426 @@
+#!/usr/bin/env python3
+"""
+Textilindo AI Training API - Pure API Version
+No HTML interfaces, only API endpoints for training and chat
+"""
+
+import os
+import json
+import logging
+import torch
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from pydantic import BaseModel
+import uvicorn
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Textilindo AI Training API",
+    description="Pure API-based training system for Textilindo AI Assistant",
+    version="1.0.0"
+)
+
+# Training status storage
+training_status = {
+    "is_training": False,
+    "progress": 0,
+    "status": "idle",
+    "current_step": 0,
+    "total_steps": 0,
+    "loss": 0.0,
+    "start_time": None,
+    "end_time": None,
+    "error": None
+}
+
+# Request/Response models
+class TrainingRequest(BaseModel):
+    model_name: str = "distilgpt2"
+    dataset_path: str = "data/lora_dataset_20250910_145055.jsonl"
+    config_path: str = "configs/training_config.yaml"
+    max_samples: int = 20
+    epochs: int = 1
+    batch_size: int = 1
+    learning_rate: float = 5e-5
+
+class TrainingResponse(BaseModel):
+    success: bool
+    message: str
+    training_id: str
+    status: str
+
+class ChatRequest(BaseModel):
+    message: str
+    conversation_id: Optional[str] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    conversation_id: str
+    status: str = "success"
+
+# API Information
+@app.get("/")
+async def api_info():
+    """API information endpoint"""
+    return {
+        "name": "Textilindo AI Training API",
+        "version": "1.0.0",
+        "description": "Pure API-based training system for Textilindo AI Assistant",
+        "hardware": "2 vCPU, 16 GB RAM (CPU basic)",
+        "status": "ready",
+        "endpoints": {
+            "training": {
+                "start": "POST /api/train/start",
+                "status": "GET /api/train/status", 
+                "data": "GET /api/train/data",
+                "gpu": "GET /api/train/gpu",
+                "test": "POST /api/train/test"
+            },
+            "chat": {
+                "chat": "POST /chat",
+                "health": "GET /health"
+            }
+        }
+    }
+
+# Health check
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "hardware": "2 vCPU, 16 GB RAM"
+    }
+
+# Training API endpoints
+@app.post("/api/train/start", response_model=TrainingResponse)
+async def start_training(request: TrainingRequest, background_tasks: BackgroundTasks):
+    """Start training process"""
+    global training_status
+    
+    if training_status["is_training"]:
+        raise HTTPException(status_code=400, detail="Training already in progress")
+    
+    # Validate inputs
+    if not Path(request.dataset_path).exists():
+        raise HTTPException(status_code=404, detail=f"Dataset not found: {request.dataset_path}")
+    
+    if not Path(request.config_path).exists():
+        raise HTTPException(status_code=404, detail=f"Config not found: {request.config_path}")
+    
+    # Start training in background
+    training_id = f"train_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    
+    background_tasks.add_task(
+        train_model_async,
+        request.model_name,
+        request.dataset_path,
+        request.config_path,
+        request.max_samples,
+        request.epochs,
+        request.batch_size,
+        request.learning_rate
+    )
+    
+    return TrainingResponse(
+        success=True,
+        message="Training started successfully",
+        training_id=training_id,
+        status="started"
+    )
+
+@app.get("/api/train/status")
+async def get_training_status():
+    """Get current training status"""
+    return training_status
+
+@app.get("/api/train/data")
+async def get_training_data_info():
+    """Get information about available training data"""
+    data_dir = Path("data")
+    if not data_dir.exists():
+        return {"files": [], "count": 0}
+    
+    jsonl_files = list(data_dir.glob("*.jsonl"))
+    files_info = []
+    
+    for file in jsonl_files:
+        try:
+            with open(file, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            files_info.append({
+                "name": file.name,
+                "size": file.stat().st_size,
+                "lines": len(lines)
+            })
+        except Exception as e:
+            files_info.append({
+                "name": file.name,
+                "error": str(e)
+            })
+    
+    return {
+        "files": files_info,
+        "count": len(jsonl_files)
+    }
+
+@app.get("/api/train/gpu")
+async def get_gpu_info():
+    """Get GPU information"""
+    try:
+        gpu_available = torch.cuda.is_available()
+        if gpu_available:
+            gpu_count = torch.cuda.device_count()
+            gpu_name = torch.cuda.get_device_name(0)
+            gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+            return {
+                "available": True,
+                "count": gpu_count,
+                "name": gpu_name,
+                "memory_gb": round(gpu_memory, 2)
+            }
+        else:
+            return {"available": False}
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.post("/api/train/test")
+async def test_trained_model():
+    """Test the trained model"""
+    model_path = "./models/textilindo-trained"
+    if not Path(model_path).exists():
+        return {"error": "No trained model found"}
+    
+    try:
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        
+        tokenizer = AutoTokenizer.from_pretrained(model_path)
+        model = AutoModelForCausalLM.from_pretrained(model_path)
+        
+        # Test prompt
+        test_prompt = "Question: dimana lokasi textilindo? Answer:"
+        inputs = tokenizer(test_prompt, return_tensors="pt")
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=inputs.input_ids.shape[1] + 30,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        return {
+            "success": True,
+            "test_prompt": test_prompt,
+            "response": response,
+            "model_path": model_path
+        }
+        
+    except Exception as e:
+        return {"error": str(e)}
+
+# Chat API endpoint
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """Chat with the AI assistant"""
+    try:
+        # Simple mock response for now
+        mock_responses = {
+            "dimana lokasi textilindo": "Textilindo berkantor pusat di Jl. Raya Prancis No.39, Kosambi Tim., Kec. Kosambi, Kabupaten Tangerang, Banten 15213",
+            "jam berapa textilindo beroperasional": "Jam operasional Senin-Jumat 08:00-17:00, Sabtu 08:00-12:00.",
+            "berapa ketentuan pembelian": "Minimal order 1 roll per jenis kain",
+            "apa ada gratis ongkir": "Gratis ongkir untuk order minimal 5 roll.",
+            "apa bisa dikirimkan sample": "Hallo kak untuk sampel kita bisa kirimkan gratis ya kak 😊"
+        }
+        
+        # Simple keyword matching
+        user_lower = request.message.lower()
+        response = "Halo! Saya adalah asisten AI Textilindo. Bagaimana saya bisa membantu Anda hari ini? 😊"
+        
+        for key, mock_response in mock_responses.items():
+            if any(word in user_lower for word in key.split()):
+                response = mock_response
+                break
+        
+        return ChatResponse(
+            response=response,
+            conversation_id=request.conversation_id or "default",
+            status="success"
+        )
+        
+    except Exception as e:
+        logger.error(f"Chat error: {e}")
+        return ChatResponse(
+            response="Maaf, terjadi kesalahan. Silakan coba lagi.",
+            conversation_id=request.conversation_id or "default",
+            status="error"
+        )
+
+# Training function
+async def train_model_async(
+    model_name: str,
+    dataset_path: str,
+    config_path: str,
+    max_samples: int,
+    epochs: int,
+    batch_size: int,
+    learning_rate: float
+):
+    """Async training function"""
+    global training_status
+    
+    try:
+        training_status.update({
+            "is_training": True,
+            "status": "starting",
+            "progress": 0,
+            "start_time": datetime.now().isoformat(),
+            "error": None
+        })
+        
+        logger.info("🚀 Starting training...")
+        
+        # Import training libraries
+        from transformers import (
+            AutoTokenizer, 
+            AutoModelForCausalLM,
+            TrainingArguments,
+            Trainer,
+            DataCollatorForLanguageModeling
+        )
+        from datasets import Dataset
+        
+        # Check GPU
+        gpu_available = torch.cuda.is_available()
+        logger.info(f"GPU available: {gpu_available}")
+        
+        # Load model and tokenizer
+        logger.info(f"📥 Loading model: {model_name}")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        
+        # Load model
+        if gpu_available:
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16,
+                device_map="auto"
+            )
+        else:
+            model = AutoModelForCausalLM.from_pretrained(model_name)
+        
+        logger.info("✅ Model loaded successfully")
+        
+        # Load training data
+        training_data = load_training_data(dataset_path, max_samples)
+        if not training_data:
+            raise Exception("No training data loaded")
+        
+        # Convert to dataset
+        dataset = Dataset.from_list(training_data)
+        
+        def tokenize_function(examples):
+            return tokenizer(
+                examples["text"],
+                truncation=True,
+                padding=True,
+                max_length=256,
+                return_tensors="pt"
+            )
+        
+        tokenized_dataset = dataset.map(tokenize_function, batched=True)
+        
+        # Training arguments
+        training_args = TrainingArguments(
+            output_dir="./models/textilindo-trained",
+            num_train_epochs=epochs,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=2,
+            learning_rate=learning_rate,
+            warmup_steps=5,
+            save_steps=10,
+            logging_steps=1,
+            save_total_limit=1,
+            prediction_loss_only=True,
+            remove_unused_columns=False,
+            fp16=gpu_available,
+            dataloader_pin_memory=gpu_available,
+            report_to=None,
+        )
+        
+        # Data collator
+        data_collator = DataCollatorForLanguageModeling(
+            tokenizer=tokenizer,
+            mlm=False,
+        )
+        
+        # Create trainer
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=tokenized_dataset,
+            data_collator=data_collator,
+            tokenizer=tokenizer,
+        )
+        
+        # Start training
+        training_status["status"] = "training"
+        trainer.train()
+        
+        # Save model
+        model.save_pretrained("./models/textilindo-trained")
+        tokenizer.save_pretrained("./models/textilindo-trained")
+        
+        # Update status
+        training_status.update({
+            "is_training": False,
+            "status": "completed",
+            "progress": 100,
+            "end_time": datetime.now().isoformat()
+        })
+        
+        logger.info("✅ Training completed successfully!")
+        
+    except Exception as e:
+        logger.error(f"Training failed: {e}")
+        training_status.update({
+            "is_training": False,
+            "status": "failed",
+            "error": str(e),
+            "end_time": datetime.now().isoformat()
+        })
+
+def load_training_data(dataset_path: str, max_samples: int = 20) -> list:
+    """Load training data from JSONL file"""
+    data = []
+    try:
+        with open(dataset_path, 'r', encoding='utf-8') as f:
+            for i, line in enumerate(f):
+                if i >= max_samples:
+                    break
+                if line.strip():
+                    item = json.loads(line)
+                    # Create training text
+                    instruction = item.get('instruction', '')
+                    output = item.get('output', '')
+                    text = f"Question: {instruction} Answer: {output}"
+                    data.append({"text": text})
+        logger.info(f"Loaded {len(data)} training samples")
+        return data
+    except Exception as e:
+        logger.error(f"Error loading data: {e}")
+        return []
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app_backup.py

@@ -0,0 +1,568 @@
+#!/usr/bin/env python3
+"""
+Textilindo AI Assistant - Hugging Face Spaces FastAPI Application
+Main application file for deployment on Hugging Face Spaces
+"""
+
+import os
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+from fastapi import FastAPI, HTTPException, Request, BackgroundTasks
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+from huggingface_hub import InferenceClient
+import requests
+from datetime import datetime
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Textilindo AI Assistant",
+    description="AI Assistant for Textilindo textile company",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Request/Response models
+class ChatRequest(BaseModel):
+    message: str
+    conversation_id: Optional[str] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    conversation_id: str
+    status: str = "success"
+
+class HealthResponse(BaseModel):
+    status: str
+    message: str
+    version: str = "1.0.0"
+
+class TextilindoAI:
+    """Textilindo AI Assistant using HuggingFace Inference API"""
+    
+    def __init__(self):
+        self.api_key = os.getenv('HUGGINGFACE_API_KEY')
+        self.model = os.getenv('DEFAULT_MODEL', 'meta-llama/Llama-3.1-8B-Instruct')
+        self.system_prompt = self.load_system_prompt()
+        
+        if not self.api_key:
+            logger.warning("HUGGINGFACE_API_KEY not found. Using mock responses.")
+            self.client = None
+        else:
+            try:
+                self.client = InferenceClient(
+                    token=self.api_key,
+                    model=self.model
+                )
+                logger.info(f"Initialized with model: {self.model}")
+            except Exception as e:
+                logger.error(f"Failed to initialize InferenceClient: {e}")
+                self.client = None
+    
+    def load_system_prompt(self) -> str:
+        """Load system prompt from config file"""
+        try:
+            prompt_path = Path("configs/system_prompt.md")
+            if prompt_path.exists():
+                with open(prompt_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                # Extract system prompt from markdown
+                if 'SYSTEM_PROMPT = """' in content:
+                    start = content.find('SYSTEM_PROMPT = """') + len('SYSTEM_PROMPT = """')
+                    end = content.find('"""', start)
+                    return content[start:end].strip()
+                else:
+                    # Fallback: use entire content
+                    return content.strip()
+            else:
+                return self.get_default_system_prompt()
+        except Exception as e:
+            logger.error(f"Error loading system prompt: {e}")
+            return self.get_default_system_prompt()
+    
+    def get_default_system_prompt(self) -> str:
+        """Default system prompt if file not found"""
+        return """You are a friendly and helpful AI assistant for Textilindo, a textile company.
+        
+Always respond in Indonesian (Bahasa Indonesia).
+Keep responses short and direct.
+Be friendly and helpful.
+Use exact information from the knowledge base.
+The company uses yards for sales.
+Minimum purchase is 1 roll (67-70 yards)."""
+    
+    def generate_response(self, user_message: str) -> str:
+        """Generate response using HuggingFace Inference API"""
+        if not self.client:
+            return self.get_mock_response(user_message)
+        
+        try:
+            # Create full prompt with system prompt
+            full_prompt = f"<|system|>\n{self.system_prompt}\n<|user|>\n{user_message}\n<|assistant|>\n"
+            
+            # Generate response
+            response = self.client.text_generation(
+                full_prompt,
+                max_new_tokens=512,
+                temperature=0.7,
+                top_p=0.9,
+                top_k=40,
+                repetition_penalty=1.1,
+                stop_sequences=["<|end|>", "<|user|>"]
+            )
+            
+            # Extract only the assistant's response
+            if "<|assistant|>" in response:
+                assistant_response = response.split("<|assistant|>")[-1].strip()
+                assistant_response = assistant_response.replace("<|end|>", "").strip()
+                return assistant_response
+            else:
+                return response
+                
+        except Exception as e:
+            logger.error(f"Error generating response: {e}")
+            return self.get_mock_response(user_message)
+    
+    def get_mock_response(self, user_message: str) -> str:
+        """Mock responses for testing without API key"""
+        mock_responses = {
+            "dimana lokasi textilindo": "Textilindo berkantor pusat di Jl. Raya Prancis No.39, Kosambi Tim., Kec. Kosambi, Kabupaten Tangerang, Banten 15213",
+            "jam berapa textilindo beroperasional": "Jam operasional Senin-Jumat 08:00-17:00, Sabtu 08:00-12:00.",
+            "berapa ketentuan pembelian": "Minimal order 1 roll per jenis kain",
+            "bagaimana dengan pembayarannya": "Pembayaran dapat dilakukan via transfer bank atau cash on delivery",
+            "apa ada gratis ongkir": "Gratis ongkir untuk order minimal 5 roll.",
+            "apa bisa dikirimkan sample": "hallo kak untuk sampel kita bisa kirimkan gratis ya kak 😊"
+        }
+        
+        # Simple keyword matching
+        user_lower = user_message.lower()
+        for key, response in mock_responses.items():
+            if any(word in user_lower for word in key.split()):
+                return response
+                
+        return "Halo! Saya adalah asisten AI Textilindo. Bagaimana saya bisa membantu Anda hari ini? 😊"
+
+# Initialize AI assistant
+ai_assistant = TextilindoAI()
+
+# Routes
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Serve the main chat interface"""
+    try:
+        with open("templates/chat.html", "r", encoding="utf-8") as f:
+            return HTMLResponse(content=f.read())
+    except FileNotFoundError:
+        return HTMLResponse(content="""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Textilindo AI Assistant</title>
+            <meta charset="utf-8">
+            <style>
+                body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+                .chat-container { border: 1px solid #ddd; border-radius: 10px; padding: 20px; margin: 20px 0; }
+                .message { margin: 10px 0; padding: 10px; border-radius: 5px; }
+                .user { background-color: #e3f2fd; text-align: right; }
+                .assistant { background-color: #f5f5f5; }
+                input[type="text"] { width: 70%; padding: 10px; border: 1px solid #ddd; border-radius: 5px; }
+                button { padding: 10px 20px; background-color: #2196f3; color: white; border: none; border-radius: 5px; cursor: pointer; }
+            </style>
+        </head>
+        <body>
+            <h1>🤖 Textilindo AI Assistant</h1>
+            <div class="chat-container">
+                <div id="chat-messages"></div>
+                <div style="margin-top: 20px;">
+                    <input type="text" id="message-input" placeholder="Tulis pesan Anda..." onkeypress="handleKeyPress(event)">
+                    <button onclick="sendMessage()">Kirim</button>
+                </div>
+            </div>
+            <script>
+                async function sendMessage() {
+                    const input = document.getElementById('message-input');
+                    const message = input.value.trim();
+                    if (!message) return;
+                    
+                    // Add user message
+                    addMessage(message, 'user');
+                    input.value = '';
+                    
+                    // Get AI response
+                    try {
+                        const response = await fetch('/chat', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ message: message })
+                        });
+                        const data = await response.json();
+                        addMessage(data.response, 'assistant');
+                    } catch (error) {
+                        addMessage('Maaf, terjadi kesalahan. Silakan coba lagi.', 'assistant');
+                    }
+                }
+                
+                function addMessage(text, sender) {
+                    const messages = document.getElementById('chat-messages');
+                    const div = document.createElement('div');
+                    div.className = `message ${sender}`;
+                    div.textContent = text;
+                    messages.appendChild(div);
+                    messages.scrollTop = messages.scrollHeight;
+                }
+                
+                function handleKeyPress(event) {
+                    if (event.key === 'Enter') {
+                        sendMessage();
+                    }
+                }
+            </script>
+        </body>
+        </html>
+        """)
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """Chat endpoint"""
+    try:
+        response = ai_assistant.generate_response(request.message)
+        return ChatResponse(
+            response=response,
+            conversation_id=request.conversation_id or "default",
+            status="success"
+        )
+    except Exception as e:
+        logger.error(f"Error in chat endpoint: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return HealthResponse(
+        status="healthy",
+        message="Textilindo AI Assistant is running",
+        version="1.0.0"
+    )
+
+@app.get("/info")
+async def get_info():
+    """Get application information"""
+    return {
+        "name": "Textilindo AI Assistant",
+        "version": "1.0.0",
+        "model": ai_assistant.model,
+        "has_api_key": bool(ai_assistant.api_key),
+        "client_initialized": bool(ai_assistant.client)
+    }
+
+# Import training API
+from training_api import (
+    TrainingRequest, TrainingResponse, training_status,
+    train_model_async, load_training_config, load_training_data, check_gpu_availability
+)
+
+# Training API endpoints
+@app.post("/api/train/start", response_model=TrainingResponse)
+async def start_training_api(request: TrainingRequest, background_tasks: BackgroundTasks):
+    """Start training process via API"""
+    if training_status["is_training"]:
+        raise HTTPException(status_code=400, detail="Training already in progress")
+    
+    # Validate inputs
+    if not Path(request.dataset_path).exists():
+        raise HTTPException(status_code=404, detail=f"Dataset not found: {request.dataset_path}")
+    
+    if not Path(request.config_path).exists():
+        raise HTTPException(status_code=404, detail=f"Config not found: {request.config_path}")
+    
+    # Start training in background
+    training_id = f"train_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    
+    background_tasks.add_task(
+        train_model_async,
+        request.model_name,
+        request.dataset_path,
+        request.config_path,
+        request.max_samples,
+        request.epochs,
+        request.batch_size,
+        request.learning_rate
+    )
+    
+    return TrainingResponse(
+        success=True,
+        message="Training started successfully",
+        training_id=training_id,
+        status="started"
+    )
+
+@app.get("/api/train/status")
+async def get_training_status_api():
+    """Get current training status"""
+    return training_status
+
+@app.get("/api/train/data")
+async def get_training_data_info_api():
+    """Get information about available training data"""
+    data_dir = Path("data")
+    if not data_dir.exists():
+        return {"files": [], "count": 0}
+    
+    jsonl_files = list(data_dir.glob("*.jsonl"))
+    files_info = []
+    
+    for file in jsonl_files:
+        try:
+            with open(file, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            files_info.append({
+                "name": file.name,
+                "size": file.stat().st_size,
+                "lines": len(lines)
+            })
+        except Exception as e:
+            files_info.append({
+                "name": file.name,
+                "error": str(e)
+            })
+    
+    return {
+        "files": files_info,
+        "count": len(jsonl_files)
+    }
+
+@app.get("/api/train/gpu")
+async def get_gpu_info_api():
+    """Get GPU information"""
+    try:
+        import torch
+        gpu_available = torch.cuda.is_available()
+        if gpu_available:
+            gpu_count = torch.cuda.device_count()
+            gpu_name = torch.cuda.get_device_name(0)
+            gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+            return {
+                "available": True,
+                "count": gpu_count,
+                "name": gpu_name,
+                "memory_gb": round(gpu_memory, 2)
+            }
+        else:
+            return {"available": False}
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.post("/api/train/test")
+async def test_trained_model_api():
+    """Test the trained model"""
+    model_path = "./models/textilindo-trained"
+    if not Path(model_path).exists():
+        return {"error": "No trained model found"}
+    
+    try:
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        import torch
+        
+        tokenizer = AutoTokenizer.from_pretrained(model_path)
+        model = AutoModelForCausalLM.from_pretrained(model_path)
+        
+        # Test prompt
+        test_prompt = "Question: dimana lokasi textilindo? Answer:"
+        inputs = tokenizer(test_prompt, return_tensors="pt")
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=inputs.input_ids.shape[1] + 30,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        return {
+            "success": True,
+            "test_prompt": test_prompt,
+            "response": response,
+            "model_path": model_path
+        }
+        
+    except Exception as e:
+        return {"error": str(e)}
+
+# Legacy training endpoints (for backward compatibility)
+@app.get("/train")
+async def training_interface():
+    """Training interface"""
+    try:
+        with open("templates/training.html", "r", encoding="utf-8") as f:
+            return HTMLResponse(content=f.read())
+    except FileNotFoundError:
+        return HTMLResponse(content="""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Textilindo AI Training</title>
+            <meta charset="utf-8">
+            <style>
+                body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+                .container { background: #f5f5f5; padding: 20px; border-radius: 10px; margin: 20px 0; }
+                button { background: #2196f3; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; }
+                button:hover { background: #1976d2; }
+                .log { background: #000; color: #0f0; padding: 10px; border-radius: 5px; font-family: monospace; height: 300px; overflow-y: auto; }
+            </style>
+        </head>
+        <body>
+            <h1>🤖 Textilindo AI Training Interface</h1>
+            
+            <div class="container">
+                <h2>Training Options</h2>
+                <p>Choose your training method:</p>
+                
+                <button onclick="startLightweightTraining()">Start Lightweight Training</button>
+                <button onclick="checkResources()">Check Resources</button>
+                <button onclick="viewData()">View Training Data</button>
+            </div>
+            
+            <div class="container">
+                <h2>Training Log</h2>
+                <div id="log" class="log">Ready to start training...</div>
+            </div>
+            
+            <script>
+                function addLog(message) {
+                    const log = document.getElementById('log');
+                    const timestamp = new Date().toLocaleTimeString();
+                    log.innerHTML += `[${timestamp}] ${message}\\n`;
+                    log.scrollTop = log.scrollHeight;
+                }
+                
+                async function startLightweightTraining() {
+                    addLog('Starting lightweight training...');
+                    try {
+                        const response = await fetch('/train/start', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' }
+                        });
+                        const result = await response.json();
+                        addLog(`Training result: ${result.message}`);
+                    } catch (error) {
+                        addLog(`Error: ${error.message}`);
+                    }
+                }
+                
+                async function checkResources() {
+                    addLog('Checking resources...');
+                    try {
+                        const response = await fetch('/train/status');
+                        const result = await response.json();
+                        addLog(`Resources: ${JSON.stringify(result, null, 2)}`);
+                    } catch (error) {
+                        addLog(`Error: ${error.message}`);
+                    }
+                }
+                
+                async function viewData() {
+                    addLog('Loading training data...');
+                    try {
+                        const response = await fetch('/train/data');
+                        const result = await response.json();
+                        addLog(`Data files: ${result.files.join(', ')}`);
+                    } catch (error) {
+                        addLog(`Error: ${error.message}`);
+                    }
+                }
+            </script>
+        </body>
+        </html>
+        """)
+
+@app.post("/train/start")
+async def start_training():
+    """Start lightweight training"""
+    try:
+        # Import training script
+        import subprocess
+        import sys
+        
+        # Run the training script
+        result = subprocess.run([
+            sys.executable, "train_on_space.py"
+        ], capture_output=True, text=True, timeout=300)  # 5 minute timeout
+        
+        if result.returncode == 0:
+            return {"message": "Training completed successfully!", "output": result.stdout}
+        else:
+            return {"message": "Training failed", "error": result.stderr}
+            
+    except subprocess.TimeoutExpired:
+        return {"message": "Training timed out (5 minutes limit)"}
+    except Exception as e:
+        return {"message": f"Training error: {str(e)}"}
+
+@app.get("/train/status")
+async def training_status():
+    """Get training status and resources"""
+    try:
+        import psutil
+        
+        return {
+            "status": "ready",
+            "cpu_count": psutil.cpu_count(),
+            "memory_total_gb": round(psutil.virtual_memory().total / (1024**3), 2),
+            "memory_available_gb": round(psutil.virtual_memory().available / (1024**3), 2),
+            "disk_free_gb": round(psutil.disk_usage('.').free / (1024**3), 2)
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.get("/train/data")
+async def training_data():
+    """Get training data information"""
+    try:
+        data_dir = Path("data")
+        if data_dir.exists():
+            jsonl_files = list(data_dir.glob("*.jsonl"))
+            return {
+                "files": [f.name for f in jsonl_files],
+                "count": len(jsonl_files)
+            }
+        else:
+            return {"files": [], "count": 0}
+    except Exception as e:
+        return {"error": str(e)}
+
+# Mount static files if they exist
+if Path("static").exists():
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+
+if __name__ == "__main__":
+    # Get port from environment variable (Hugging Face Spaces uses 7860)
+    port = int(os.getenv("PORT", 7860))
+    
+    # Run the application
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )