Add training API endpoints and production-ready files

README.md

@@ -1,10 +1,243 @@
+# Base LLM Setup - Llama 3.1 8B dengan LoRA
+
+Setup lengkap untuk fine-tuning model Llama 3.1 8B menggunakan LoRA (Low-Rank Adaptation).
+
+## 🚀 Fitur
+
+- **Base Model**: Llama 3.1 8B Instruct
+- **Fine-tuning**: LoRA untuk efisiensi memory
+- **Format Data**: JSONL (JSON Lines)
+- **Environment**: Virtual environment dengan Python
+- **Inference**: vLLM untuk serving model
+- **Monitoring**: Logs dan metrics
+
+## 📁 Struktur Direktori
+
+```
+base-llm-setup/
+├── models/                 # Model weights
+├── data/                   # Training datasets (JSONL)
+├── scripts/                # Python scripts
+│   ├── download_model.py   # Download base model
+│   ├── finetune_lora.py    # LoRA fine-tuning
+│   ├── test_model.py       # Test fine-tuned model
+│   └── create_sample_dataset.py # Create sample data
+├── configs/                # Configuration files
+├── logs/                   # Training logs
+├── venv/                   # Virtual environment
+├── requirements.txt         # Python dependencies
+├── setup.sh                # Setup script
+├── docker-compose.yml      # Docker services
+└── README.md               # This file
+```
+
+## 🛠️ Prerequisites
+
+- Python 3.8+
+- CUDA-compatible GPU (untuk training)
+- Docker & Docker Compose
+- HuggingFace account dan token
+
+## ⚡ Quick Start
+
+### 1. Setup Environment
+
+```bash
+# Clone atau buat folder
+cd base-llm-setup
+
+# Jalankan setup script
+chmod +x setup.sh
+./setup.sh
+```
+
+### 2. Aktifkan Virtual Environment
+
+```bash
+source venv/bin/activate
+```
+
+### 3. Set HuggingFace Token
+
+```bash
+export HUGGINGFACE_TOKEN="your_token_here"
+```
+
+### 4. Download Base Model
+
+```bash
+python scripts/download_model.py
+```
+
+### 5. Buat Dataset (JSONL)
+
+```bash
+python scripts/create_sample_dataset.py
+```
+
+### 6. Fine-tuning dengan LoRA
+
+```bash
+python scripts/finetune_lora.py
+```
+
+### 7. Test Model
+
+```bash
+python scripts/test_model.py
+```
+
+## 📊 Format Dataset JSONL
+
+Dataset harus dalam format JSONL (JSON Lines) dengan struktur:
+
+```jsonl
+{"text": "Apa itu machine learning?", "category": "education", "language": "id"}
+{"text": "Jelaskan tentang deep learning", "category": "education", "language": "id"}
+{"text": "Bagaimana cara kerja neural network?", "category": "education", "language": "id"}
+```
+
+**Field yang diperlukan:**
+- `text`: Teks untuk training (wajib)
+- `category`: Kategori data (opsional)
+- `language`: Bahasa (opsional, default: "id")
+
+## 🔧 Konfigurasi
+
+### Model Configuration (`configs/llama_config.yaml`)
+
+```yaml
+model_name: "meta-llama/Llama-3.1-8B-Instruct"
+model_path: "./models/llama-3.1-8b-instruct"
+max_length: 8192
+temperature: 0.7
+top_p: 0.9
+top_k: 40
+repetition_penalty: 1.1
+
+# LoRA Configuration
+lora_config:
+  r: 16
+  lora_alpha: 32
+  lora_dropout: 0.1
+  target_modules: ["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+  
+# Training Configuration
+training_config:
+  learning_rate: 2e-4
+  batch_size: 4
+  gradient_accumulation_steps: 4
+  num_epochs: 3
+  warmup_steps: 100
+  save_steps: 500
+  eval_steps: 500
+```
+
+### Docker Configuration
+
+```bash
+# Start vLLM service
+docker-compose up -d vllm
+
+# Check status
+docker-compose ps
+
+# View logs
+docker-compose logs -f vllm
+```
+
+## 🧪 Testing
+
+### Interactive Mode
+```bash
+python scripts/test_model.py
+# Pilih opsi 1 untuk interactive chat
+```
+
+### Batch Testing
+```bash
+python scripts/test_model.py
+# Pilih opsi 2 untuk batch testing
+```
+
+### Custom Prompt
+```bash
+python scripts/test_model.py
+# Pilih opsi 3 untuk custom prompt
+```
+
+## 📈 Monitoring
+
+### Training Logs
+- Logs tersimpan di folder `logs/`
+- Monitor GPU usage dengan `nvidia-smi`
+- Check training progress di console
+
+### Model Performance
+- Loss metrics selama training
+- Model checkpoints tersimpan setiap `save_steps`
+- Evaluation metrics setiap `eval_steps`
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+1. **CUDA Out of Memory**
+   - Kurangi `batch_size`
+   - Kurangi `max_length`
+   - Gunakan gradient accumulation
+
+2. **Model Download Failed**
+   - Check HuggingFace token
+   - Verify internet connection
+   - Check disk space
+
+3. **Training Slow**
+   - Increase `batch_size` jika memory cukup
+   - Optimize data loading
+   - Use mixed precision training
+
+### Performance Tips
+
+- Gunakan SSD untuk dataset besar
+- Monitor GPU temperature
+- Use appropriate learning rate scheduling
+- Regular checkpointing untuk recovery
+
+## 📚 Dependencies
+
+Lihat `requirements.txt` untuk daftar lengkap dependencies:
+
+- **Core**: torch, transformers, peft, datasets
+- **Inference**: vllm, openai
+- **Utils**: numpy, pandas, pyyaml
+- **Dev**: pytest, black, flake8
+
+## 🤝 Contributing
+
+1. Fork repository
+2. Create feature branch
+3. Commit changes
+4. Push to branch
+5. Create Pull Request
+
+## 📄 License
+
+MIT License - lihat LICENSE file untuk detail.
+
+## �� Support
+
+Jika ada masalah atau pertanyaan:
+
+1. Check troubleshooting section
+2. Review logs di folder `logs/`
+3. Open issue di repository
+4. Contact maintainer
+
 ---
-title: Textilindo AI
-emoji: 📚
-colorFrom: purple
-colorTo: gray
-sdk: docker
-pinned: false
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Happy Fine-tuning! 🚀**
+
+
+
+

app.py

@@ -1,56 +1,636 @@
 #!/usr/bin/env python3
 """
-Minimal working version to fix 503 error
+Textilindo AI Assistant - Hugging Face Spaces FastAPI Application
+Main application file for deployment on Hugging Face Spaces
 """
 
 import os
-from fastapi import FastAPI
+import json
+import logging
+from pathlib import Path
+from datetime import datetime
+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
 
-app = FastAPI(title="Textilindo AI API")
+# Import torch only when needed for training
+try:
+    import torch
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+    torch = None
 
+# 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"
 
-@app.get("/")
+class HealthResponse(BaseModel):
+    status: str
+    message: str
+    version: str = "1.0.0"
+
+# Training 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
+
+# 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
+}
+
+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()
+
+# Training functions
+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 training data: {e}")
+        return []
+
+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
+        if not TORCH_AVAILABLE:
+            raise Exception("PyTorch is required for training but not available")
+        
+        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()
+        })
+
+# Routes
+@app.get("/", response_class=HTMLResponse)
 async def root():
-    return {"message": "Textilindo AI API is running", "status": "ok"}
+    """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.get("/health")
-async def health():
-    return {"status": "healthy"}
+@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("/debug/env")
-async def debug_env():
-    api_key = os.getenv("HUGGINGFACE_API_KEY")
+@app.get("/info")
+async def get_info():
+    """Get application information"""
     return {
-        "api_key_present": bool(api_key),
-        "api_key_length": len(api_key) if api_key else 0
+        "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),
+        "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"
+            }
+        }
     }
 
-@app.post("/chat")
-async def chat(request: ChatRequest):
-    # Simple mock response for now
-    mock_responses = {
-        "jam berapa textilindo buka": "Jam operasional Senin-Jumat 08:00-17:00, Sabtu 08:00-12:00.",
-        "dimana lokasi textilindo": "Textilindo berkantor pusat di Jl. Raya Prancis No.39, Kosambi Tim., Kec. Kosambi, Kabupaten Tangerang, Banten 15213",
-        "apa ada gratis ongkir": "Gratis ongkir untuk order minimal 5 roll."
+# 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"""
+    if not TORCH_AVAILABLE:
+        return {"available": False, "error": "PyTorch not available"}
     
-    user_lower = request.message.lower()
-    response = "Halo! Saya adalah asisten AI Textilindo. Bagaimana saya bisa membantu Anda hari ini? 😊"
+    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"""
+    if not TORCH_AVAILABLE:
+        return {"error": "PyTorch is required for model testing but not available"}
     
-    for key, mock_response in mock_responses.items():
-        if any(word in user_lower for word in key.split()):
-            response = mock_response
-            break
+    model_path = "./models/textilindo-trained"
+    if not Path(model_path).exists():
+        return {"error": "No trained model found"}
     
-    return ChatResponse(response=response)
+    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)}
+
+# Mount static files if they exist
+if Path("static").exists():
+    app.mount("/static", StaticFiles(directory="static"), name="static")
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    # 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"
+    )
+# Updated Mon, Oct 27, 2025  9:53:55 AM

templates/chat.html

@@ -10,7 +10,7 @@
             padding: 0;
             box-sizing: border-box;
         }
-        
+
         body {
             font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
@@ -20,7 +20,7 @@
             align-items: center;
             padding: 20px;
         }
-        
+
         .chat-container {
             background: white;
             border-radius: 20px;
@@ -32,24 +32,24 @@
             flex-direction: column;
             overflow: hidden;
         }
-        
+
         .chat-header {
             background: linear-gradient(135deg, #2196f3, #21cbf3);
             color: white;
             padding: 20px;
             text-align: center;
         }
-        
+
         .chat-header h1 {
             font-size: 24px;
             margin-bottom: 5px;
         }
-        
+
         .chat-header p {
             opacity: 0.9;
             font-size: 14px;
         }
-        
+
         .chat-messages {
             flex: 1;
             padding: 20px;
@@ -58,7 +58,7 @@
             flex-direction: column;
             gap: 15px;
         }
-        
+
         .message {
             max-width: 80%;
             padding: 12px 16px;
@@ -66,14 +66,14 @@
             word-wrap: break-word;
             animation: fadeIn 0.3s ease-in;
         }
-        
+
         .user-message {
             background: #2196f3;
             color: white;
             align-self: flex-end;
             border-bottom-right-radius: 5px;
         }
-        
+
         .assistant-message {
             background: #f5f5f5;
             color: #333;
@@ -88,7 +88,7 @@
             display: flex;
             gap: 10px;
         }
-        
+
         .chat-input {
             flex: 1;
             padding: 12px 16px;
@@ -98,11 +98,11 @@
             font-size: 14px;
             transition: border-color 0.3s ease;
         }
-        
+
         .chat-input:focus {
             border-color: #2196f3;
         }
-        
+
         .send-button {
             background: #2196f3;
             color: white;
@@ -116,16 +116,16 @@
             justify-content: center;
             transition: background-color 0.3s ease;
         }
-        
+
         .send-button:hover {
             background: #1976d2;
         }
-        
+
         .send-button:disabled {
             background: #ccc;
             cursor: not-allowed;
         }
-        
+
         .typing-indicator {
             display: none;
             align-self: flex-start;
@@ -136,7 +136,7 @@
             color: #666;
             font-style: italic;
         }
-        
+
         @keyframes fadeIn {
             from { opacity: 0; transform: translateY(10px); }
             to { opacity: 1; transform: translateY(0); }
@@ -181,17 +181,17 @@
             <h1>🤖 Textilindo AI Assistant</h1>
             <p>Asisten AI untuk membantu pertanyaan tentang Textilindo</p>
         </div>
-        
+
         <div class="chat-messages" id="chatMessages">
             <div class="welcome-message">
                 👋 Halo! Saya adalah asisten AI Textilindo. Bagaimana saya bisa membantu Anda hari ini?
             </div>
         </div>
-        
+
         <div class="typing-indicator" id="typingIndicator">
             <span class="typing-dots">AI sedang mengetik</span>
         </div>
-        
+
         <div class="chat-input-container">
             <input 
                 type="text" 
@@ -202,7 +202,7 @@
             >
             <button id="sendButton" class="send-button" onclick="sendMessage()">
                 ➤
-            </button>
+                </button>
         </div>
     </div>
 
@@ -236,15 +236,15 @@
             // Disable input and button
             messageInput.disabled = true;
             sendButton.disabled = true;
-            
+
             // Add user message
             addMessage(message, 'user');
             messageInput.value = '';
             messageInput.style.height = 'auto';
-            
+
             // Show typing indicator
             showTypingIndicator();
-            
+
             try {
                 const response = await fetch('/chat', {
                     method: 'POST',
@@ -257,11 +257,11 @@
                 if (!response.ok) {
                     throw new Error(`HTTP error! status: ${response.status}`);
                 }
-                
+
                 const data = await response.json();
                 hideTypingIndicator();
                 addMessage(data.response, 'assistant');
-                
+
             } catch (error) {
                 console.error('Error:', error);
                 hideTypingIndicator();
@@ -346,4 +346,4 @@
         setTimeout(addSampleQuestions, 1000);
     </script>
 </body>
-</html>
+</html>