initial commit

.gitignore

@@ -0,0 +1,86 @@
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Model files (too large for git)
+models/
+*.bin
+*.safetensors
+*.ckpt
+*.pt
+*.pth
+
+# Data files
+data/*.jsonl
+data/*.json
+data/*.csv
+data/*.txt
+
+# Logs
+logs/
+*.log
+*.out
+
+# Environment variables
+.env
+.env.local
+.env.production
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# PyTorch
+*.pkl
+*.pickle
+
+# HuggingFace
+.cache/
+huggingface/
+
+# Docker
+.dockerignore
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+*.temp
+
+
+
+

README.md

@@ -0,0 +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
+
+---
+
+**Happy Fine-tuning! 🚀**
+
+
+
+

api_server.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Textilindo AI API Server
+Clean API-only implementation
+"""
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import os
+import json
+import requests
+from difflib import SequenceMatcher
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
+
+class TextilindoAI:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://api.novita.ai/openai"
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        self.model = "qwen/qwen3-235b-a22b-instruct-2507"
+        self.dataset = self.load_dataset()
+        
+    def load_dataset(self):
+        """Load the training dataset"""
+        dataset = []
+        dataset_path = "data/textilindo_training_data.jsonl"
+        
+        if os.path.exists(dataset_path):
+            try:
+                with open(dataset_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line:
+                            data = json.loads(line)
+                            dataset.append(data)
+                logger.info(f"Loaded {len(dataset)} examples from dataset")
+            except Exception as e:
+                logger.error(f"Error loading dataset: {e}")
+        
+        return dataset
+    
+    def find_relevant_context(self, user_query, top_k=3):
+        """Find most relevant examples from dataset"""
+        if not self.dataset:
+            return []
+        
+        scores = []
+        for i, example in enumerate(self.dataset):
+            instruction = example.get('instruction', '').lower()
+            output = example.get('output', '').lower()
+            query = user_query.lower()
+            
+            instruction_score = SequenceMatcher(None, query, instruction).ratio()
+            output_score = SequenceMatcher(None, query, output).ratio()
+            combined_score = (instruction_score * 0.7) + (output_score * 0.3)
+            scores.append((combined_score, i))
+        
+        scores.sort(reverse=True)
+        relevant_examples = []
+        
+        for score, idx in scores[:top_k]:
+            if score > 0.1:
+                relevant_examples.append(self.dataset[idx])
+        
+        return relevant_examples
+    
+    def create_context_prompt(self, user_query, relevant_examples):
+        """Create a prompt with relevant context"""
+        if not relevant_examples:
+            return user_query
+        
+        context_parts = []
+        context_parts.append("Berikut adalah beberapa contoh pertanyaan dan jawaban tentang Textilindo:")
+        context_parts.append("")
+        
+        for i, example in enumerate(relevant_examples, 1):
+            instruction = example.get('instruction', '')
+            output = example.get('output', '')
+            context_parts.append(f"Contoh {i}:")
+            context_parts.append(f"Pertanyaan: {instruction}")
+            context_parts.append(f"Jawaban: {output}")
+            context_parts.append("")
+        
+        context_parts.append("Berdasarkan contoh di atas, jawab pertanyaan berikut:")
+        context_parts.append(f"Pertanyaan: {user_query}")
+        context_parts.append("Jawaban:")
+        
+        return "\n".join(context_parts)
+    
+    def chat(self, message, max_tokens=300, temperature=0.7):
+        """Send message to Novita AI with RAG context"""
+        relevant_examples = self.find_relevant_context(message, 3)
+        
+        if relevant_examples:
+            enhanced_prompt = self.create_context_prompt(message, relevant_examples)
+            context_used = True
+        else:
+            enhanced_prompt = message
+            context_used = False
+        
+        payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": enhanced_prompt}],
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": 0.9
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/chat/completions", 
+                headers=self.headers, 
+                json=payload, 
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                ai_response = result.get('choices', [{}])[0].get('message', {}).get('content', '')
+                
+                return {
+                    "success": True,
+                    "response": ai_response,
+                    "context_used": context_used,
+                    "relevant_examples_count": len(relevant_examples),
+                    "model": self.model,
+                    "tokens_used": result.get('usage', {}).get('total_tokens', 0)
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"API Error: {response.status_code}",
+                    "details": response.text
+                }
+                
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Request Error: {str(e)}"
+            }
+
+# Initialize AI
+api_key = os.getenv('NOVITA_API_KEY')
+if not api_key:
+    logger.error("NOVITA_API_KEY not found in environment variables")
+    exit(1)
+
+ai = TextilindoAI(api_key)
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        "status": "healthy",
+        "service": "Textilindo AI API",
+        "model": ai.model,
+        "dataset_loaded": len(ai.dataset) > 0,
+        "dataset_size": len(ai.dataset)
+    })
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    """Main chat endpoint"""
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                "success": False,
+                "error": "No JSON data provided"
+            }), 400
+        
+        message = data.get('message', '').strip()
+        if not message:
+            return jsonify({
+                "success": False,
+                "error": "Message is required"
+            }), 400
+        
+        # Optional parameters
+        max_tokens = data.get('max_tokens', 300)
+        temperature = data.get('temperature', 0.7)
+        
+        # Validate parameters
+        if not isinstance(max_tokens, int) or max_tokens < 1 or max_tokens > 1000:
+            return jsonify({
+                "success": False,
+                "error": "max_tokens must be between 1 and 1000"
+            }), 400
+        
+        if not isinstance(temperature, (int, float)) or temperature < 0 or temperature > 2:
+            return jsonify({
+                "success": False,
+                "error": "temperature must be between 0 and 2"
+            }), 400
+        
+        # Process chat
+        result = ai.chat(message, max_tokens, temperature)
+        
+        if result["success"]:
+            return jsonify(result)
+        else:
+            return jsonify(result), 500
+            
+    except Exception as e:
+        logger.error(f"Error in chat endpoint: {e}")
+        return jsonify({
+            "success": False,
+            "error": f"Internal server error: {str(e)}"
+        }), 500
+
+@app.route('/stats', methods=['GET'])
+def get_stats():
+    """Get dataset and system statistics"""
+    try:
+        topics = {}
+        for example in ai.dataset:
+            metadata = example.get('metadata', {})
+            topic = metadata.get('topic', 'unknown')
+            topics[topic] = topics.get(topic, 0) + 1
+        
+        return jsonify({
+            "success": True,
+            "dataset": {
+                "total_examples": len(ai.dataset),
+                "topics": topics,
+                "topics_count": len(topics)
+            },
+            "model": {
+                "name": ai.model,
+                "provider": "Novita AI"
+            },
+            "system": {
+                "api_version": "1.0.0",
+                "status": "operational"
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in stats endpoint: {e}")
+        return jsonify({
+            "success": False,
+            "error": f"Internal server error: {str(e)}"
+        }), 500
+
+@app.route('/examples', methods=['GET'])
+def get_examples():
+    """Get sample questions from dataset"""
+    try:
+        limit = request.args.get('limit', 10, type=int)
+        limit = min(limit, 50)  # Max 50 examples
+        
+        examples = []
+        for example in ai.dataset[:limit]:
+            examples.append({
+                "instruction": example.get('instruction', ''),
+                "output": example.get('output', ''),
+                "topic": example.get('metadata', {}).get('topic', 'unknown')
+            })
+        
+        return jsonify({
+            "success": True,
+            "examples": examples,
+            "total_returned": len(examples),
+            "total_available": len(ai.dataset)
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in examples endpoint: {e}")
+        return jsonify({
+            "success": False,
+            "error": f"Internal server error: {str(e)}"
+        }), 500
+
+@app.route('/', methods=['GET'])
+def root():
+    """API root endpoint with documentation"""
+    return jsonify({
+        "service": "Textilindo AI API",
+        "version": "1.0.0",
+        "description": "AI-powered customer service for Textilindo",
+        "endpoints": {
+            "GET /": "API documentation (this endpoint)",
+            "GET /health": "Health check",
+            "POST /chat": "Chat with AI",
+            "GET /stats": "Dataset and system statistics",
+            "GET /examples": "Sample questions from dataset"
+        },
+        "usage": {
+            "chat": {
+                "method": "POST",
+                "url": "/chat",
+                "body": {
+                    "message": "string (required)",
+                    "max_tokens": "integer (optional, default: 300)",
+                    "temperature": "float (optional, default: 0.7)"
+                }
+            }
+        },
+        "model": ai.model,
+        "dataset_size": len(ai.dataset)
+    })
+
+if __name__ == '__main__':
+    logger.info("Starting Textilindo AI API Server...")
+    logger.info(f"Model: {ai.model}")
+    logger.info(f"Dataset loaded: {len(ai.dataset)} examples")
+    
+    app.run(
+        debug=False,  # Set to False for production
+        host='0.0.0.0',
+        port=5001
+    )

configs/training_config.yaml

@@ -0,0 +1,28 @@
+dataset_path: data/textilindo_training_data.jsonl
+lora_config:
+  lora_alpha: 32
+  lora_dropout: 0.1
+  r: 16
+  target_modules:
+  - q_proj
+  - v_proj
+  - k_proj
+  - o_proj
+  - gate_proj
+  - up_proj
+  - down_proj
+max_length: 2048
+model_name: meta-llama/llama-3.2-1b-instruct
+model_path: ./models/llama-3.2-1b-instruct
+repetition_penalty: 1.1
+temperature: 0.7
+top_k: 40
+top_p: 0.9
+training_config:
+  batch_size: 4
+  eval_steps: 500
+  gradient_accumulation_steps: 4
+  learning_rate: 0.0002
+  num_epochs: 3
+  save_steps: 500
+  warmup_steps: 100

convert_dataset.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+Convert dataset from instruction/input/output format to text format for fine-tuning
+"""
+
+import json
+import os
+from pathlib import Path
+
+def convert_dataset(input_file, output_file):
+    """Convert dataset from instruction format to text format"""
+    
+    print(f"🔄 Converting dataset from {input_file} to {output_file}")
+    
+    # Read input dataset
+    with open(input_file, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+    
+    converted_data = []
+    
+    for i, line in enumerate(lines, 1):
+        try:
+            data = json.loads(line.strip())
+            
+            # Extract fields
+            instruction = data.get('instruction', '')
+            input_text = data.get('input', '')
+            output = data.get('output', '')
+            metadata = data.get('metadata', {})
+            
+            # Create training text in instruction-following format
+            if input_text.strip():
+                # If there's input, use instruction + input format
+                training_text = f"### Instruction:\n{instruction}\n\n### Input:\n{input_text}\n\n### Response:\n{output}"
+            else:
+                # If no input, use simple instruction format
+                training_text = f"### Instruction:\n{instruction}\n\n### Response:\n{output}"
+            
+            # Add to converted data
+            converted_data.append({
+                "text": training_text,
+                "instruction": instruction,
+                "input": input_text,
+                "output": output,
+                "metadata": metadata
+            })
+            
+        except json.JSONDecodeError as e:
+            print(f"⚠️  Warning: Invalid JSON at line {i}: {e}")
+            continue
+    
+    # Save converted dataset
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item in converted_data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+    
+    print(f"✅ Converted {len(converted_data)} samples")
+    print(f"📁 Saved to: {output_file}")
+    
+    return output_file
+
+def create_training_config(model_name, dataset_path):
+    """Create training configuration file"""
+    
+    config = {
+        "model_name": model_name,
+        "model_path": f"./models/{model_name.split('/')[-1]}",
+        "dataset_path": dataset_path,
+        "max_length": 2048,
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "top_k": 40,
+        "repetition_penalty": 1.1,
+        
+        "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_config": {
+            "learning_rate": 2e-4,
+            "batch_size": 4,
+            "gradient_accumulation_steps": 4,
+            "num_epochs": 3,
+            "warmup_steps": 100,
+            "save_steps": 500,
+            "eval_steps": 500
+        }
+    }
+    
+    config_path = "configs/training_config.yaml"
+    os.makedirs("configs", exist_ok=True)
+    
+    import yaml
+    with open(config_path, 'w', encoding='utf-8') as f:
+        yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
+    
+    print(f"✅ Created training config: {config_path}")
+    return config_path
+
+def main():
+    print("🚀 Dataset Converter for Textilindo AI")
+    print("=" * 50)
+    
+    # Input and output files
+    input_file = "data/lora_dataset_20250829_113330.jsonl"
+    output_file = "data/textilindo_training_data.jsonl"
+    
+    # Check if input file exists
+    if not os.path.exists(input_file):
+        print(f"❌ Input file not found: {input_file}")
+        return
+    
+    # Convert dataset
+    converted_file = convert_dataset(input_file, output_file)
+    
+    # Create training config
+    model_name = "meta-llama/llama-3.2-1b-instruct"  # Lightweight model for testing
+    config_path = create_training_config(model_name, converted_file)
+    
+    print("\n🎉 Dataset conversion complete!")
+    print("\n📋 Next steps:")
+    print("1. Run fine-tuning: python scripts/finetune_lora.py")
+    print("2. Test the model: python scripts/test_model.py")
+    print("3. Deploy to Novita AI (manual process for now)")
+    
+    # Show sample of converted data
+    print(f"\n📄 Sample converted data:")
+    with open(output_file, 'r', encoding='utf-8') as f:
+        sample = json.loads(f.readline())
+        print(f"Text length: {len(sample['text'])} characters")
+        print(f"Instruction: {sample['instruction'][:100]}...")
+        print(f"Output: {sample['output'][:100]}...")
+
+if __name__ == "__main__":
+    main()

deploy_to_novita.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""
+Deploy fine-tuned model to Novita AI serverless GPU
+"""
+
+import os
+import json
+import requests
+import time
+from pathlib import Path
+
+class NovitaAIDeployer:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://api.novita.ai/openai"
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    def test_connection(self):
+        """Test connection to Novita AI"""
+        try:
+            response = requests.get(f"{self.base_url}/models", headers=self.headers, timeout=10)
+            return response.status_code == 200
+        except Exception as e:
+            print(f"❌ Connection error: {e}")
+            return False
+    
+    def get_available_models(self):
+        """Get list of available models"""
+        try:
+            response = requests.get(f"{self.base_url}/models", headers=self.headers, timeout=10)
+            if response.status_code == 200:
+                return response.json().get('data', [])
+            return []
+        except Exception as e:
+            print(f"❌ Error getting models: {e}")
+            return []
+    
+    def create_deployment(self, model_name, deployment_name=None):
+        """Create a deployment for the model"""
+        if not deployment_name:
+            deployment_name = f"textilindo-{model_name.split('/')[-1]}"
+        
+        # Note: This is a placeholder for the actual deployment API
+        # Novita AI might not have a public deployment API yet
+        print(f"🔧 Creating deployment: {deployment_name}")
+        print(f"📋 Model: {model_name}")
+        
+        # For now, we'll create a configuration file for manual deployment
+        deployment_config = {
+            "deployment_name": deployment_name,
+            "model_name": model_name,
+            "base_url": self.base_url,
+            "api_key": self.api_key[:10] + "..." + self.api_key[-10:],
+            "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "status": "ready_for_deployment"
+        }
+        
+        config_path = f"configs/{deployment_name}_deployment.json"
+        os.makedirs("configs", exist_ok=True)
+        
+        with open(config_path, 'w', encoding='utf-8') as f:
+            json.dump(deployment_config, f, indent=2, ensure_ascii=False)
+        
+        print(f"✅ Deployment config saved: {config_path}")
+        return config_path
+    
+    def test_model_inference(self, model_name, test_prompt="Halo, apa kabar?"):
+        """Test model inference"""
+        print(f"🧪 Testing inference with model: {model_name}")
+        
+        payload = {
+            "model": model_name,
+            "messages": [
+                {"role": "user", "content": test_prompt}
+            ],
+            "max_tokens": 100,
+            "temperature": 0.7
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                assistant_message = result.get('choices', [{}])[0].get('message', {}).get('content', '')
+                print(f"✅ Inference successful!")
+                print(f"📝 Response: {assistant_message}")
+                return True
+            else:
+                print(f"❌ Inference failed: {response.status_code} - {response.text}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Inference error: {e}")
+            return False
+
+def create_deployment_guide():
+    """Create a deployment guide for Novita AI"""
+    guide_content = """
+# Novita AI Deployment Guide
+
+## Current Status
+Your fine-tuned model is ready for deployment to Novita AI serverless GPU.
+
+## Manual Deployment Steps
+
+### 1. Prepare Your Model
+- Ensure your fine-tuned model is saved in the `models/` directory
+- Verify the model weights and configuration files are complete
+
+### 2. Upload to Novita AI
+1. Log in to your Novita AI dashboard: https://novita.ai/
+2. Navigate to "Custom Models" or "Model Library"
+3. Click "Upload Model" or "Deploy Custom Model"
+4. Upload your model files (weights, config, tokenizer)
+5. Set the model name (e.g., "textilindo-llama-3.2-1b")
+6. Configure serverless GPU settings
+
+### 3. Configure API Access
+1. Get your deployment API endpoint
+2. Update your application to use the new endpoint
+3. Test the deployment with sample queries
+
+### 4. Monitor Usage
+- Track API calls and costs in the Novita AI dashboard
+- Monitor model performance and response times
+- Set up alerts for any issues
+
+## API Usage Example
+
+```python
+import requests
+
+# Your deployment endpoint
+endpoint = "https://api.novita.ai/openai"
+api_key = "your_api_key"
+
+headers = {
+    "Authorization": f"Bearer {api_key}",
+    "Content-Type": "application/json"
+}
+
+payload = {
+    "model": "your-deployed-model-name",
+    "messages": [
+        {"role": "user", "content": "dimana lokasi textilindo?"}
+    ],
+    "max_tokens": 200,
+    "temperature": 0.7
+}
+
+response = requests.post(f"{endpoint}/chat/completions", headers=headers, json=payload)
+result = response.json()
+print(result['choices'][0]['message']['content'])
+```
+
+## Next Steps
+1. Contact Novita AI support for custom model deployment
+2. Consider using their Model API for easier integration
+3. Set up monitoring and logging for production use
+"""
+    
+    guide_path = "DEPLOYMENT_GUIDE.md"
+    with open(guide_path, 'w', encoding='utf-8') as f:
+        f.write(guide_content)
+    
+    print(f"✅ Deployment guide created: {guide_path}")
+
+def main():
+    print("🚀 Novita AI Deployment Setup")
+    print("=" * 50)
+    
+    # Check API key
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY not found")
+        api_key = input("Enter your Novita AI API key: ").strip()
+        if not api_key:
+            print("❌ API key required")
+            return
+        os.environ['NOVITA_API_KEY'] = api_key
+    
+    # Initialize deployer
+    deployer = NovitaAIDeployer(api_key)
+    
+    # Test connection
+    print("🔍 Testing connection...")
+    if not deployer.test_connection():
+        print("❌ Could not connect to Novita AI")
+        return
+    
+    print("✅ Connected to Novita AI!")
+    
+    # Get available models
+    models = deployer.get_available_models()
+    print(f"📋 Found {len(models)} available models")
+    
+    # Select model for deployment
+    print("\n🎯 Select model for deployment:")
+    lightweight_models = [
+        "meta-llama/llama-3.2-1b-instruct",
+        "meta-llama/llama-3.2-3b-instruct",
+        "qwen/qwen3-4b-fp8",
+        "qwen/qwen3-8b-fp8"
+    ]
+    
+    for i, model in enumerate(lightweight_models, 1):
+        print(f"{i}. {model}")
+    
+    try:
+        choice = int(input("\nSelect model (1-4): ").strip())
+        if 1 <= choice <= len(lightweight_models):
+            selected_model = lightweight_models[choice - 1]
+        else:
+            print("❌ Invalid choice, using default")
+            selected_model = lightweight_models[0]
+    except ValueError:
+        print("❌ Invalid input, using default")
+        selected_model = lightweight_models[0]
+    
+    print(f"✅ Selected: {selected_model}")
+    
+    # Test model inference
+    print(f"\n🧪 Testing model inference...")
+    if deployer.test_model_inference(selected_model):
+        print("✅ Model inference working!")
+    else:
+        print("❌ Model inference failed")
+        return
+    
+    # Create deployment config
+    print(f"\n🔧 Creating deployment configuration...")
+    config_path = deployer.create_deployment(selected_model)
+    
+    # Create deployment guide
+    create_deployment_guide()
+    
+    print(f"\n🎉 Deployment setup complete!")
+    print(f"\n📋 Next steps:")
+    print(f"1. Check deployment config: {config_path}")
+    print(f"2. Read deployment guide: DEPLOYMENT_GUIDE.md")
+    print(f"3. Contact Novita AI support for custom model deployment")
+    print(f"4. Monitor your usage in the Novita AI dashboard")
+
+if __name__ == "__main__":
+    main()

novita_chat_app.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+Simple Novita AI Chat Application
+"""
+
+import os
+import requests
+import json
+import time
+
+class NovitaAIChat:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://api.novita.ai/openai"
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        self.conversation_history = []
+        self.current_model = "meta-llama/llama-3.2-1b-instruct"
+    
+    def get_available_models(self):
+        """Get list of available models"""
+        try:
+            response = requests.get(f"{self.base_url}/models", headers=self.headers, timeout=10)
+            if response.status_code == 200:
+                models = response.json()
+                return models.get('data', [])
+            else:
+                print(f"❌ Error getting models: {response.status_code}")
+                return []
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            return []
+    
+    def chat_completion(self, message, model=None):
+        """Send message to Novita AI and get response"""
+        if model is None:
+            model = self.current_model
+        
+        # Add user message to history
+        self.conversation_history.append({"role": "user", "content": message})
+        
+        # Prepare payload
+        payload = {
+            "model": model,
+            "messages": self.conversation_history,
+            "max_tokens": 500,
+            "temperature": 0.7,
+            "top_p": 0.9
+        }
+        
+        try:
+            print("🤖 Thinking...", end="", flush=True)
+            response = requests.post(
+                f"{self.base_url}/chat/completions", 
+                headers=self.headers, 
+                json=payload, 
+                timeout=60
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                assistant_message = result.get('choices', [{}])[0].get('message', {}).get('content', '')
+                
+                # Add assistant response to history
+                self.conversation_history.append({"role": "assistant", "content": assistant_message})
+                
+                print("\r" + " " * 20 + "\r", end="")  # Clear "Thinking..." message
+                return assistant_message
+            else:
+                print(f"\r❌ Error: {response.status_code} - {response.text}")
+                return None
+                
+        except Exception as e:
+            print(f"\r❌ Error: {e}")
+            return None
+    
+    def change_model(self, model_id):
+        """Change the current model"""
+        self.current_model = model_id
+        print(f"✅ Model changed to: {model_id}")
+    
+    def clear_history(self):
+        """Clear conversation history"""
+        self.conversation_history = []
+        print("✅ Conversation history cleared")
+    
+    def show_models(self):
+        """Show available models"""
+        models = self.get_available_models()
+        if models:
+            print("\n📋 Available Models:")
+            print("-" * 50)
+            for i, model in enumerate(models[:20], 1):  # Show first 20 models
+                model_id = model.get('id', 'Unknown')
+                print(f"{i:2d}. {model_id}")
+            print("-" * 50)
+            print(f"Current model: {self.current_model}")
+        else:
+            print("❌ Could not fetch models")
+
+def main():
+    print("🚀 Novita AI Chat Application")
+    print("=" * 50)
+    
+    # Check API key
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY not found")
+        api_key = input("Enter your Novita AI API key: ").strip()
+        if not api_key:
+            print("❌ API key required")
+            return
+        os.environ['NOVITA_API_KEY'] = api_key
+    
+    # Initialize chat
+    chat = NovitaAIChat(api_key)
+    
+    # Test connection
+    print("🔍 Testing connection...")
+    models = chat.get_available_models()
+    if not models:
+        print("❌ Could not connect to Novita AI")
+        return
+    
+    print(f"✅ Connected! Found {len(models)} models")
+    
+    # Show current model
+    print(f"🤖 Current model: {chat.current_model}")
+    
+    # Main chat loop
+    print("\n💬 Start chatting! Type 'help' for commands, 'quit' to exit")
+    print("-" * 50)
+    
+    while True:
+        try:
+            user_input = input("\n👤 You: ").strip()
+            
+            if not user_input:
+                continue
+            
+            # Handle commands
+            if user_input.lower() in ['quit', 'exit', 'q']:
+                print("👋 Goodbye!")
+                break
+            elif user_input.lower() == 'help':
+                print("\n📋 Available Commands:")
+                print("  help          - Show this help")
+                print("  models        - Show available models")
+                print("  change <id>   - Change model (e.g., change 5)")
+                print("  clear         - Clear conversation history")
+                print("  quit/exit/q   - Exit the application")
+                print("  <any text>    - Send message to AI")
+                continue
+            elif user_input.lower() == 'models':
+                chat.show_models()
+                continue
+            elif user_input.lower() == 'clear':
+                chat.clear_history()
+                continue
+            elif user_input.lower().startswith('change '):
+                try:
+                    model_num = int(user_input.split()[1])
+                    models = chat.get_available_models()
+                    if 1 <= model_num <= len(models):
+                        new_model = models[model_num - 1].get('id')
+                        chat.change_model(new_model)
+                    else:
+                        print(f"❌ Invalid model number. Use 1-{len(models)}")
+                except (ValueError, IndexError):
+                    print("❌ Usage: change <number>")
+                continue
+            
+            # Send message to AI
+            response = chat.chat_completion(user_input)
+            if response:
+                print(f"\n🤖 Assistant: {response}")
+            
+        except KeyboardInterrupt:
+            print("\n👋 Goodbye!")
+            break
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

novita_rag_chat.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+Novita AI RAG Chat Application - Uses your dataset as context
+No fine-tuning required!
+"""
+
+import os
+import json
+import requests
+import time
+from pathlib import Path
+from difflib import SequenceMatcher
+
+class NovitaAIRAGChat:
+    def __init__(self, api_key, dataset_path="data/textilindo_training_data.jsonl"):
+        self.api_key = api_key
+        self.base_url = "https://api.novita.ai/openai"
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        self.conversation_history = []
+        self.current_model = "qwen/qwen3-235b-a22b-instruct-2507"  # High-quality model
+        self.dataset = self.load_dataset(dataset_path)
+        self.context_window = 5  # Number of most relevant examples to include
+        
+    def load_dataset(self, dataset_path):
+        """Load the training dataset"""
+        print(f"📚 Loading dataset from {dataset_path}...")
+        dataset = []
+        
+        if not os.path.exists(dataset_path):
+            print(f"⚠️  Dataset not found: {dataset_path}")
+            return dataset
+        
+        try:
+            with open(dataset_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        data = json.loads(line)
+                        dataset.append(data)
+            print(f"✅ Loaded {len(dataset)} examples from dataset")
+        except Exception as e:
+            print(f"❌ Error loading dataset: {e}")
+        
+        return dataset
+    
+    def find_relevant_context(self, user_query, top_k=5):
+        """Find most relevant examples from dataset"""
+        if not self.dataset:
+            return []
+        
+        # Simple similarity scoring
+        scores = []
+        for i, example in enumerate(self.dataset):
+            instruction = example.get('instruction', '').lower()
+            output = example.get('output', '').lower()
+            query = user_query.lower()
+            
+            # Calculate similarity scores
+            instruction_score = SequenceMatcher(None, query, instruction).ratio()
+            output_score = SequenceMatcher(None, query, output).ratio()
+            
+            # Combined score (weight instruction more heavily)
+            combined_score = (instruction_score * 0.7) + (output_score * 0.3)
+            scores.append((combined_score, i))
+        
+        # Sort by score and get top_k
+        scores.sort(reverse=True)
+        relevant_examples = []
+        
+        for score, idx in scores[:top_k]:
+            if score > 0.1:  # Only include if similarity > 10%
+                relevant_examples.append(self.dataset[idx])
+        
+        return relevant_examples
+    
+    def create_context_prompt(self, user_query, relevant_examples):
+        """Create a prompt with relevant context"""
+        if not relevant_examples:
+            return user_query
+        
+        context_parts = []
+        context_parts.append("Berikut adalah beberapa contoh pertanyaan dan jawaban tentang Textilindo:")
+        context_parts.append("")
+        
+        for i, example in enumerate(relevant_examples, 1):
+            instruction = example.get('instruction', '')
+            output = example.get('output', '')
+            context_parts.append(f"Contoh {i}:")
+            context_parts.append(f"Pertanyaan: {instruction}")
+            context_parts.append(f"Jawaban: {output}")
+            context_parts.append("")
+        
+        context_parts.append("Berdasarkan contoh di atas, jawab pertanyaan berikut:")
+        context_parts.append(f"Pertanyaan: {user_query}")
+        context_parts.append("Jawaban:")
+        
+        return "\n".join(context_parts)
+    
+    def chat_completion(self, message, model=None):
+        """Send message to Novita AI with RAG context"""
+        if model is None:
+            model = self.current_model
+        
+        # Find relevant context
+        relevant_examples = self.find_relevant_context(message, self.context_window)
+        
+        # Create context-aware prompt
+        if relevant_examples:
+            enhanced_prompt = self.create_context_prompt(message, relevant_examples)
+            print(f"🔍 Found {len(relevant_examples)} relevant examples from dataset")
+        else:
+            enhanced_prompt = message
+            print("🔍 No relevant examples found, using direct query")
+        
+        # Add to conversation history
+        self.conversation_history.append({"role": "user", "content": enhanced_prompt})
+        
+        # Prepare payload
+        payload = {
+            "model": model,
+            "messages": self.conversation_history,
+            "max_tokens": 500,
+            "temperature": 0.7,
+            "top_p": 0.9
+        }
+        
+        try:
+            print("🤖 Thinking...", end="", flush=True)
+            response = requests.post(
+                f"{self.base_url}/chat/completions", 
+                headers=self.headers, 
+                json=payload, 
+                timeout=60
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                assistant_message = result.get('choices', [{}])[0].get('message', {}).get('content', '')
+                
+                # Add assistant response to history
+                self.conversation_history.append({"role": "assistant", "content": assistant_message})
+                
+                print("\r" + " " * 20 + "\r", end="")  # Clear "Thinking..." message
+                return assistant_message
+            else:
+                print(f"\r❌ Error: {response.status_code} - {response.text}")
+                return None
+                
+        except Exception as e:
+            print(f"\r❌ Error: {e}")
+            return None
+    
+    def change_model(self, model_id):
+        """Change the current model"""
+        self.current_model = model_id
+        print(f"✅ Model changed to: {model_id}")
+    
+    def clear_history(self):
+        """Clear conversation history"""
+        self.conversation_history = []
+        print("✅ Conversation history cleared")
+    
+    def show_models(self):
+        """Show available models"""
+        try:
+            response = requests.get(f"{self.base_url}/models", headers=self.headers, timeout=10)
+            if response.status_code == 200:
+                models = response.json().get('data', [])
+                print("\n📋 Available Models:")
+                print("-" * 50)
+                for i, model in enumerate(models[:20], 1):  # Show first 20 models
+                    model_id = model.get('id', 'Unknown')
+                    print(f"{i:2d}. {model_id}")
+                print("-" * 50)
+                print(f"Current model: {self.current_model}")
+            else:
+                print("❌ Could not fetch models")
+        except Exception as e:
+            print(f"❌ Error: {e}")
+    
+    def show_dataset_stats(self):
+        """Show dataset statistics"""
+        if not self.dataset:
+            print("❌ No dataset loaded")
+            return
+        
+        print(f"\n📊 Dataset Statistics:")
+        print(f"Total examples: {len(self.dataset)}")
+        
+        # Count by topic
+        topics = {}
+        for example in self.dataset:
+            metadata = example.get('metadata', {})
+            topic = metadata.get('topic', 'unknown')
+            topics[topic] = topics.get(topic, 0) + 1
+        
+        print(f"Topics: {dict(topics)}")
+        
+        # Show sample questions
+        print(f"\n📝 Sample questions:")
+        for i, example in enumerate(self.dataset[:5], 1):
+            instruction = example.get('instruction', '')
+            print(f"{i}. {instruction}")
+
+def main():
+    print("🚀 Novita AI RAG Chat - Textilindo AI")
+    print("=" * 60)
+    print("This application uses your dataset as context with Novita AI models")
+    print("No fine-tuning required - RAG approach!")
+    print("=" * 60)
+    
+    # Check API key
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY not found")
+        api_key = input("Enter your Novita AI API key: ").strip()
+        if not api_key:
+            print("❌ API key required")
+            return
+        os.environ['NOVITA_API_KEY'] = api_key
+    
+    # Initialize RAG chat
+    chat = NovitaAIRAGChat(api_key)
+    
+    # Test connection
+    print("🔍 Testing connection...")
+    try:
+        response = requests.get(f"{chat.base_url}/models", headers=chat.headers, timeout=10)
+        if response.status_code != 200:
+            print("❌ Could not connect to Novita AI")
+            return
+    except Exception as e:
+        print(f"❌ Connection error: {e}")
+        return
+    
+    print("✅ Connected to Novita AI!")
+    
+    # Show dataset stats
+    chat.show_dataset_stats()
+    
+    # Show current model
+    print(f"\n🤖 Current model: {chat.current_model}")
+    
+    # Main chat loop
+    print("\n💬 Start chatting! Type 'help' for commands, 'quit' to exit")
+    print("-" * 60)
+    
+    while True:
+        try:
+            user_input = input("\n👤 You: ").strip()
+            
+            if not user_input:
+                continue
+            
+            # Handle commands
+            if user_input.lower() in ['quit', 'exit', 'q']:
+                print("👋 Goodbye!")
+                break
+            elif user_input.lower() == 'help':
+                print("\n📋 Available Commands:")
+                print("  help          - Show this help")
+                print("  models        - Show available models")
+                print("  change <id>   - Change model (e.g., change 5)")
+                print("  clear         - Clear conversation history")
+                print("  stats         - Show dataset statistics")
+                print("  quit/exit/q   - Exit the application")
+                print("  <any text>    - Send message to AI (with RAG context)")
+                continue
+            elif user_input.lower() == 'models':
+                chat.show_models()
+                continue
+            elif user_input.lower() == 'clear':
+                chat.clear_history()
+                continue
+            elif user_input.lower() == 'stats':
+                chat.show_dataset_stats()
+                continue
+            elif user_input.lower().startswith('change '):
+                try:
+                    model_num = int(user_input.split()[1])
+                    # This would need to be implemented to get model list
+                    print("⚠️  Model changing not implemented yet")
+                except (ValueError, IndexError):
+                    print("❌ Usage: change <number>")
+                continue
+            
+            # Send message to AI with RAG context
+            response = chat.chat_completion(user_input)
+            if response:
+                print(f"\n🤖 Assistant: {response}")
+            
+        except KeyboardInterrupt:
+            print("\n👋 Goodbye!")
+            break
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,38 @@
+# Core ML libraries
+torch>=2.0.0
+transformers>=4.35.0
+accelerate>=0.24.0
+peft>=0.6.0
+datasets>=2.14.0
+
+# vLLM and inference
+vllm>=0.2.0
+openai>=1.0.0
+
+# Data processing
+numpy>=1.24.0
+pandas>=2.0.0
+pyyaml>=6.0
+
+# HuggingFace tools
+huggingface-hub>=0.17.0
+tokenizers>=0.14.0
+
+# Utilities
+tqdm>=4.65.0
+requests>=2.31.0
+python-dotenv>=1.0.0
+
+# Monitoring and system info
+psutil>=5.9.0
+GPUtil>=1.4.0
+
+# Optional: For better performance
+bitsandbytes>=0.41.0
+scipy>=1.10.0
+scikit-learn>=1.3.0
+
+# Development and testing
+pytest>=7.4.0
+black>=23.0.0
+flake8>=6.0.0

run_all.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+echo "🚀 Complete Base LLM Setup"
+echo "=========================="
+
+# Check if virtual environment exists
+if [ ! -d "venv" ]; then
+    echo "📦 Virtual environment not found. Creating..."
+    chmod +x setup.sh
+    ./setup.sh
+else
+    echo "✅ Virtual environment found"
+fi
+
+# Activate virtual environment
+echo "🔧 Activating virtual environment..."
+source venv/bin/activate
+
+# Check HuggingFace token
+if [ -z "$HUGGINGFACE_TOKEN" ]; then
+    echo "⚠️  HUGGINGFACE_TOKEN not set"
+    echo "Please set your token:"
+    echo "export HUGGINGFACE_TOKEN='your_token_here'"
+    echo ""
+    read -p "Enter your HuggingFace token: " token
+    if [ ! -z "$token" ]; then
+        export HUGGINGFACE_TOKEN="$token"
+        echo "✅ Token set"
+    else
+        echo "❌ No token provided. Exiting..."
+        exit 1
+    fi
+else
+    echo "✅ HuggingFace token found"
+fi
+
+# Check if model exists
+if [ ! -d "models/llama-3.1-8b-instruct" ]; then
+    echo "📥 Downloading base model..."
+    python scripts/download_model.py
+else
+    echo "✅ Base model found"
+fi
+
+# Check if dataset exists
+if [ ! -f "data/training_data.jsonl" ]; then
+    echo "📊 Creating sample dataset..."
+    python scripts/create_sample_dataset.py
+    # Choose option 1 (create sample dataset)
+    echo "1" | python scripts/create_sample_dataset.py
+else
+    echo "✅ Training dataset found"
+fi
+
+# Check if config exists
+if [ ! -f "configs/llama_config.yaml" ]; then
+    echo "⚙️  Creating model configuration..."
+    python scripts/download_model.py
+else
+    echo "✅ Model configuration found"
+fi
+
+echo ""
+echo "🎉 Setup Complete!"
+echo "=================="
+echo ""
+echo "📋 Next steps:"
+echo "1. Review configuration: cat configs/llama_config.yaml"
+echo "2. Start fine-tuning: python scripts/finetune_lora.py"
+echo "3. Test model: python scripts/test_model.py"
+echo "4. Start vLLM service: docker-compose up -d vllm"
+echo ""
+echo "💡 Tips:"
+echo "- Always activate venv: source venv/bin/activate"
+echo "- Monitor GPU usage: nvidia-smi"
+echo "- Check logs: tail -f logs/training.log"
+echo ""
+echo "🚀 Ready to start fine-tuning!"
+
+
+
+

run_alternative_models.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+echo "🚀 Alternative Models Setup"
+echo "==========================="
+
+# Check if virtual environment exists
+if [ ! -d "venv" ]; then
+    echo "📦 Virtual environment not found. Creating..."
+    chmod +x setup.sh
+    ./setup.sh
+else
+    echo "✅ Virtual environment found"
+fi
+
+# Activate virtual environment
+echo "🔧 Activating virtual environment..."
+source venv/bin/activate
+
+# Check HuggingFace token
+if [ -z "$HUGGINGFACE_TOKEN" ]; then
+    echo "⚠️  HUGGINGFACE_TOKEN not set"
+    echo "Please set your token:"
+    echo "export HUGGINGFACE_TOKEN='your_token_here'"
+    echo ""
+    read -p "Enter your HuggingFace token: " token
+    if [ ! -z "$token" ]; then
+        export HUGGINGFACE_TOKEN="$token"
+        echo "✅ Token set"
+    else
+        echo "❌ No token provided. Exiting..."
+        exit 1
+    fi
+else
+    echo "✅ HuggingFace token found"
+fi
+
+# Create directories
+echo "📁 Creating directories..."
+mkdir -p models data configs logs
+
+# Show model options
+echo ""
+echo "📋 Model Options Available:"
+echo "1. Llama 3.2 1B Instruct - Lightweight and fast"
+echo "2. Qwen3 4B Instruct - Good performance, reasonable size"
+echo "3. DialoGPT Medium - Conversational AI model"
+echo ""
+
+# Ask user preference
+read -p "Which model would you like to use? (1-3): " model_choice
+
+case $model_choice in
+    1)
+        echo "🎯 Selected: Llama 3.2 1B Instruct"
+        ;;
+    2)
+        echo "🎯 Selected: Qwen3 4B Instruct"
+        ;;
+    3)
+        echo "🎯 Selected: DialoGPT Medium"
+        ;;
+    *)
+        echo "❌ Invalid choice. Using default: Llama 3.2 1B Instruct"
+        model_choice=1
+        ;;
+esac
+
+echo ""
+echo "🚀 Starting model download..."
+python scripts/download_alternative_models.py
+
+echo ""
+echo "🎉 Setup Complete!"
+echo "=================="
+echo ""
+echo "📋 Next steps:"
+echo "1. Review configuration: ls configs/"
+echo "2. Start fine-tuning: python scripts/finetune_lora.py"
+echo "3. Test model: python scripts/test_model.py"
+echo "4. Or use Novita AI: python scripts/novita_ai_setup.py"
+echo ""
+echo "💡 Tips:"
+echo "- Always activate venv: source venv/bin/activate"
+echo "- Monitor GPU usage: nvidia-smi"
+echo "- Check logs: tail -f logs/training.log"
+echo ""
+echo "🚀 Ready to start fine-tuning!"
+
+
+

run_complete_workflow.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Complete workflow for Textilindo AI: Dataset → Fine-tuning → Deployment
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+def run_command(command, description):
+    """Run a command and handle errors"""
+    print(f"\n🔄 {description}")
+    print(f"Command: {command}")
+    
+    try:
+        result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+        print(f"✅ {description} completed successfully")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ {description} failed")
+        print(f"Error: {e.stderr}")
+        return False
+
+def check_requirements():
+    """Check if all requirements are met"""
+    print("🔍 Checking requirements...")
+    
+    # Check if virtual environment is activated
+    if not hasattr(sys, 'real_prefix') and not (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+        print("⚠️  Virtual environment not detected")
+        print("Please activate the virtual environment first:")
+        print("source venv/bin/activate")
+        return False
+    
+    # Check if API key is set
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("⚠️  NOVITA_API_KEY not set")
+        print("Please set your Novita AI API key:")
+        print("export NOVITA_API_KEY='your_api_key'")
+        return False
+    
+    # Check if dataset exists
+    dataset_path = "data/lora_dataset_20250829_113330.jsonl"
+    if not os.path.exists(dataset_path):
+        print(f"❌ Dataset not found: {dataset_path}")
+        return False
+    
+    print("✅ All requirements met")
+    return True
+
+def step1_convert_dataset():
+    """Step 1: Convert dataset format"""
+    print("\n" + "="*60)
+    print("STEP 1: CONVERT DATASET FORMAT")
+    print("="*60)
+    
+    return run_command(
+        "python convert_dataset.py",
+        "Converting dataset from instruction format to training format"
+    )
+
+def step2_download_model():
+    """Step 2: Download base model"""
+    print("\n" + "="*60)
+    print("STEP 2: DOWNLOAD BASE MODEL")
+    print("="*60)
+    
+    # Check if model already exists
+    model_path = "models/llama-3.2-1b-instruct"
+    if os.path.exists(model_path):
+        print(f"✅ Model already exists: {model_path}")
+        return True
+    
+    return run_command(
+        "python scripts/download_open_models.py",
+        "Downloading base model (Llama 3.2 1B Instruct)"
+    )
+
+def step3_fine_tune():
+    """Step 3: Fine-tune the model"""
+    print("\n" + "="*60)
+    print("STEP 3: FINE-TUNE MODEL")
+    print("="*60)
+    
+    # Check if training config exists
+    config_path = "configs/training_config.yaml"
+    if not os.path.exists(config_path):
+        print(f"❌ Training config not found: {config_path}")
+        print("Please run Step 1 first to create the config")
+        return False
+    
+    return run_command(
+        "python scripts/finetune_lora.py",
+        "Fine-tuning model with LoRA"
+    )
+
+def step4_test_model():
+    """Step 4: Test the fine-tuned model"""
+    print("\n" + "="*60)
+    print("STEP 4: TEST FINE-TUNED MODEL")
+    print("="*60)
+    
+    # Check if fine-tuned model exists
+    lora_path = "models/textilindo-lora-weights"
+    if not os.path.exists(lora_path):
+        print(f"⚠️  Fine-tuned model not found: {lora_path}")
+        print("This step will be skipped")
+        return True
+    
+    return run_command(
+        "python scripts/test_model.py",
+        "Testing fine-tuned model"
+    )
+
+def step5_deploy_preparation():
+    """Step 5: Prepare for deployment"""
+    print("\n" + "="*60)
+    print("STEP 5: PREPARE FOR DEPLOYMENT")
+    print("="*60)
+    
+    return run_command(
+        "python deploy_to_novita.py",
+        "Preparing deployment configuration"
+    )
+
+def main():
+    print("🚀 Textilindo AI Complete Workflow")
+    print("="*60)
+    print("This script will:")
+    print("1. Convert your dataset to training format")
+    print("2. Download a base model")
+    print("3. Fine-tune the model with your data")
+    print("4. Test the fine-tuned model")
+    print("5. Prepare for deployment to Novita AI")
+    print("="*60)
+    
+    # Check requirements
+    if not check_requirements():
+        print("\n❌ Requirements not met. Please fix the issues above.")
+        return
+    
+    # Ask for confirmation
+    response = input("\nDo you want to continue? (y/n): ").strip().lower()
+    if response not in ['y', 'yes']:
+        print("👋 Workflow cancelled")
+        return
+    
+    # Execute steps
+    steps = [
+        ("Dataset Conversion", step1_convert_dataset),
+        ("Model Download", step2_download_model),
+        ("Fine-tuning", step3_fine_tune),
+        ("Model Testing", step4_test_model),
+        ("Deployment Preparation", step5_deploy_preparation)
+    ]
+    
+    successful_steps = 0
+    total_steps = len(steps)
+    
+    for step_name, step_func in steps:
+        print(f"\n🎯 Starting: {step_name}")
+        if step_func():
+            successful_steps += 1
+        else:
+            print(f"❌ {step_name} failed. You can:")
+            print("1. Fix the issue and run this step manually")
+            print("2. Continue with the next step")
+            print("3. Stop the workflow")
+            
+            response = input("Continue to next step? (y/n): ").strip().lower()
+            if response not in ['y', 'yes']:
+                break
+    
+    # Summary
+    print("\n" + "="*60)
+    print("WORKFLOW SUMMARY")
+    print("="*60)
+    print(f"✅ Completed: {successful_steps}/{total_steps} steps")
+    
+    if successful_steps == total_steps:
+        print("\n🎉 All steps completed successfully!")
+        print("\n📋 Next steps:")
+        print("1. Check your fine-tuned model in the models/ directory")
+        print("2. Read DEPLOYMENT_GUIDE.md for deployment instructions")
+        print("3. Contact Novita AI support for custom model deployment")
+        print("4. Test your deployed model with the chat application")
+    else:
+        print(f"\n⚠️  {total_steps - successful_steps} steps failed")
+        print("Please check the error messages above and run the failed steps manually")
+    
+    print("\n📁 Generated files:")
+    files_to_check = [
+        "data/textilindo_training_data.jsonl",
+        "configs/training_config.yaml",
+        "models/textilindo-lora-weights/",
+        "DEPLOYMENT_GUIDE.md"
+    ]
+    
+    for file_path in files_to_check:
+        if os.path.exists(file_path):
+            print(f"  ✅ {file_path}")
+        else:
+            print(f"  ❌ {file_path} (not found)")
+
+if __name__ == "__main__":
+    main()

run_novita.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+echo "🚀 Complete Novita AI Setup"
+echo "==========================="
+
+# Check if virtual environment exists
+if [ ! -d "venv" ]; then
+    echo "📦 Virtual environment not found. Creating..."
+    chmod +x setup_novita.sh
+    ./setup_novita.sh
+else
+    echo "✅ Virtual environment found"
+fi
+
+# Activate virtual environment
+echo "🔧 Activating virtual environment..."
+source venv/bin/activate
+
+# Check Novita AI API key
+if [ -z "$NOVITA_API_KEY" ]; then
+    echo "⚠️  NOVITA_API_KEY not set"
+    echo "Please set your key:"
+    echo "export NOVITA_API_KEY='your_key_here'"
+    echo ""
+    read -p "Enter your Novita AI API key: " key
+    if [ ! -z "$key" ]; then
+        export NOVITA_API_KEY="$key"
+        echo "✅ API key set"
+    else
+        echo "❌ No API key provided. Exiting..."
+        exit 1
+    fi
+else
+    echo "✅ Novita AI API key found"
+fi
+
+# Create data directory if not exists
+if [ ! -d "data" ]; then
+    echo "📁 Creating data directory..."
+    mkdir -p data
+fi
+
+echo ""
+echo "🎉 Setup Complete!"
+echo "=================="
+echo ""
+echo "📋 Next steps:"
+echo "1. Review available models: python scripts/novita_ai_setup.py"
+echo "2. Create fine-tuning job"
+echo "3. Monitor training progress"
+echo ""
+echo "💡 Tips:"
+echo "- Always activate venv: source venv/bin/activate"
+echo "- Check API documentation: https://docs.novita.ai"
+echo "- Monitor your usage in Novita AI dashboard"
+echo ""
+echo "🚀 Ready to start with Novita AI!"
+
+
+

scripts/create_sample_dataset.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Script untuk membuat sample dataset JSONL untuk training
+"""
+
+import json
+import os
+from pathlib import Path
+
+def create_sample_dataset():
+    """Create sample JSONL dataset"""
+    
+    # Sample training data
+    sample_data = [
+        {
+            "text": "Apa itu machine learning? Machine learning adalah cabang dari artificial intelligence yang memungkinkan komputer belajar dari data tanpa diprogram secara eksplisit.",
+            "category": "education",
+            "language": "id"
+        },
+        {
+            "text": "Jelaskan tentang deep learning. Deep learning adalah subset dari machine learning yang menggunakan neural network dengan banyak layer untuk memproses data kompleks.",
+            "category": "education", 
+            "language": "id"
+        },
+        {
+            "text": "Bagaimana cara kerja neural network? Neural network bekerja dengan menerima input, memproses melalui hidden layers, dan menghasilkan output berdasarkan weights yang telah dilatih.",
+            "category": "education",
+            "language": "id"
+        },
+        {
+            "text": "Apa keuntungan menggunakan Python untuk AI? Python memiliki library yang lengkap seperti TensorFlow, PyTorch, dan scikit-learn yang memudahkan development AI.",
+            "category": "programming",
+            "language": "id"
+        },
+        {
+            "text": "Jelaskan tentang transfer learning. Transfer learning adalah teknik menggunakan model yang sudah dilatih pada dataset besar dan mengadaptasinya untuk task yang lebih spesifik.",
+            "category": "education",
+            "language": "id"
+        },
+        {
+            "text": "Bagaimana cara optimize model machine learning? Optimasi dapat dilakukan dengan hyperparameter tuning, feature engineering, dan menggunakan teknik seperti cross-validation.",
+            "category": "optimization",
+            "language": "id"
+        },
+        {
+            "text": "Apa itu overfitting? Overfitting terjadi ketika model belajar terlalu detail dari training data sehingga performa pada data baru menurun.",
+            "category": "education",
+            "language": "id"
+        },
+        {
+            "text": "Jelaskan tentang regularization. Regularization adalah teknik untuk mencegah overfitting dengan menambahkan penalty pada model complexity.",
+            "category": "education",
+            "language": "id"
+        },
+        {
+            "text": "Bagaimana cara handle imbalanced dataset? Dataset tidak seimbang dapat diatasi dengan teknik sampling, class weights, atau menggunakan metrics yang tepat seperti F1-score.",
+            "category": "data_handling",
+            "language": "id"
+        },
+        {
+            "text": "Apa itu ensemble learning? Ensemble learning menggabungkan multiple model untuk meningkatkan performa prediksi dan mengurangi variance.",
+            "category": "education",
+            "language": "id"
+        }
+    ]
+    
+    # Create data directory
+    data_dir = Path("data")
+    data_dir.mkdir(exist_ok=True)
+    
+    # Write to JSONL file
+    output_file = data_dir / "training_data.jsonl"
+    
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item in sample_data:
+            json.dump(item, f, ensure_ascii=False)
+            f.write('\n')
+    
+    print(f"✅ Sample dataset created: {output_file}")
+    print(f"📊 Total samples: {len(sample_data)}")
+    print(f"📁 File size: {output_file.stat().st_size / 1024:.2f} KB")
+    
+    # Show sample content
+    print("\n📝 Sample content:")
+    print("-" * 50)
+    for i, item in enumerate(sample_data[:3], 1):
+        print(f"Sample {i}:")
+        print(f"  Text: {item['text'][:100]}...")
+        print(f"  Category: {item['category']}")
+        print(f"  Language: {item['language']}")
+        print()
+
+def create_custom_dataset():
+    """Create custom dataset from user input"""
+    
+    print("🔧 Create Custom Dataset")
+    print("=" * 40)
+    
+    # Get dataset info
+    dataset_name = input("Dataset name (without extension): ").strip()
+    if not dataset_name:
+        dataset_name = "custom_dataset"
+    
+    num_samples = input("Number of samples (default 10): ").strip()
+    try:
+        num_samples = int(num_samples) if num_samples else 10
+    except ValueError:
+        num_samples = 10
+    
+    print(f"\n📝 Creating {num_samples} samples...")
+    print("Format: Enter text for each sample (empty line to finish early)")
+    
+    custom_data = []
+    
+    for i in range(num_samples):
+        print(f"\nSample {i+1}/{num_samples}:")
+        text = input("Text: ").strip()
+        
+        if not text:
+            print("Empty text, finishing...")
+            break
+        
+        category = input("Category (optional): ").strip() or "general"
+        language = input("Language (optional, default 'id'): ").strip() or "id"
+        
+        sample = {
+            "text": text,
+            "category": category,
+            "language": language
+        }
+        
+        custom_data.append(sample)
+        
+        # Ask if user wants to continue
+        if i < num_samples - 1:
+            continue_input = input("Continue? (y/n, default y): ").strip().lower()
+            if continue_input in ['n', 'no']:
+                break
+    
+    if not custom_data:
+        print("❌ No data entered, dataset not created")
+        return
+    
+    # Create data directory
+    data_dir = Path("data")
+    data_dir.mkdir(exist_ok=True)
+    
+    # Write to JSONL file
+    output_file = data_dir / f"{dataset_name}.jsonl"
+    
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item in custom_data:
+            json.dump(item, f, ensure_ascii=False)
+            f.write('\n')
+    
+    print(f"\n✅ Custom dataset created: {output_file}")
+    print(f"📊 Total samples: {len(custom_data)}")
+
+def main():
+    print("📊 Dataset Creator for LLM Training")
+    print("=" * 50)
+    
+    print("Pilih opsi:")
+    print("1. Create sample dataset (10 samples)")
+    print("2. Create custom dataset")
+    print("3. View existing datasets")
+    
+    choice = input("\nPilihan (1-3): ").strip()
+    
+    if choice == "1":
+        create_sample_dataset()
+    elif choice == "2":
+        create_custom_dataset()
+    elif choice == "3":
+        data_dir = Path("data")
+        if data_dir.exists():
+            jsonl_files = list(data_dir.glob("*.jsonl"))
+            if jsonl_files:
+                print(f"\n📁 Found {len(jsonl_files)} JSONL files:")
+                for file in jsonl_files:
+                    size = file.stat().st_size / 1024
+                    print(f"  - {file.name} ({size:.2f} KB)")
+            else:
+                print("\n📁 No JSONL files found in data/ directory")
+        else:
+            print("\n📁 Data directory does not exist")
+    else:
+        print("❌ Pilihan tidak valid")
+
+if __name__ == "__main__":
+    main()
+
+
+
+

scripts/download_alternative_models.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+Script untuk download model alternatif yang lebih mudah diakses
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+def check_huggingface_token():
+    """Check if HuggingFace token is available"""
+    token = os.getenv('HUGGINGFACE_TOKEN')
+    if not token:
+        print("❌ HUGGINGFACE_TOKEN tidak ditemukan!")
+        print("Silakan set environment variable:")
+        print("export HUGGINGFACE_TOKEN='your_token_here'")
+        return False
+    return True
+
+def download_model(model_name, model_path):
+    """Download model menggunakan huggingface-cli"""
+    print(f"📥 Downloading model: {model_name}")
+    print(f"📁 Target directory: {model_path}")
+    
+    try:
+        cmd = [
+            "huggingface-cli", "download",
+            model_name,
+            "--local-dir", str(model_path),
+            "--local-dir-use-symlinks", "False"
+        ]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            print("✅ Model berhasil didownload!")
+            return True
+        else:
+            print(f"❌ Error downloading model: {result.stderr}")
+            return False
+            
+    except FileNotFoundError:
+        print("❌ huggingface-cli tidak ditemukan!")
+        print("Silakan install dengan: pip install huggingface_hub")
+        return False
+
+def create_model_config(model_name, model_path):
+    """Create model configuration file"""
+    config_dir = Path("configs")
+    config_dir.mkdir(exist_ok=True)
+    
+    if "llama" in model_name.lower():
+        config_content = f"""# Model Configuration for {model_name}
+model_name: "{model_name}"
+model_path: "{model_path}"
+max_length: 4096
+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
+"""
+    else:
+        config_content = f"""# Model Configuration for {model_name}
+model_name: "{model_name}"
+model_path: "{model_path}"
+max_length: 4096
+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
+"""
+    
+    config_file = config_dir / f"{model_name.split('/')[-1].lower().replace('-', '_')}_config.yaml"
+    with open(config_file, 'w') as f:
+        f.write(config_content)
+    
+    print(f"✅ Model config created: {config_file}")
+    return str(config_file)
+
+def main():
+    print("🚀 Download Alternative Models")
+    print("=" * 50)
+    
+    if not check_huggingface_token():
+        sys.exit(1)
+    
+    # Model options
+    models = [
+        {
+            "name": "meta-llama/Llama-3.2-1B-Instruct",
+            "path": "models/llama-3.2-1b-instruct",
+            "description": "Llama 3.2 1B Instruct - Lightweight and fast"
+        },
+        {
+            "name": "Qwen/Qwen3-4B-Instruct",
+            "path": "models/qwen3-4b-instruct", 
+            "description": "Qwen3 4B Instruct - Good performance, reasonable size"
+        },
+        {
+            "name": "microsoft/DialoGPT-medium",
+            "path": "models/dialogpt-medium",
+            "description": "DialoGPT Medium - Conversational AI model"
+        }
+    ]
+    
+    print("📋 Pilih model yang ingin didownload:")
+    for i, model in enumerate(models, 1):
+        print(f"{i}. {model['name']}")
+        print(f"   {model['description']}")
+        print()
+    
+    try:
+        choice = int(input("Pilihan (1-3): ").strip())
+        if choice < 1 or choice > len(models):
+            print("❌ Pilihan tidak valid")
+            return
+        
+        selected_model = models[choice - 1]
+        
+        print(f"\n🎯 Model yang dipilih: {selected_model['name']}")
+        print(f"📝 Deskripsi: {selected_model['description']}")
+        
+        # Confirm download
+        confirm = input("\nLanjutkan download? (y/n): ").strip().lower()
+        if confirm not in ['y', 'yes']:
+            print("❌ Download dibatalkan")
+            return
+        
+        # Download model
+        print(f"\n1️⃣ Downloading model...")
+        if download_model(selected_model['name'], selected_model['path']):
+            print(f"\n2️⃣ Creating model configuration...")
+            config_file = create_model_config(selected_model['name'], selected_model['path'])
+            
+            print("\n3️�� Setup selesai!")
+            print(f"\n📋 Langkah selanjutnya:")
+            print(f"1. Model tersimpan di: {selected_model['path']}")
+            print(f"2. Config tersimpan di: {config_file}")
+            print("3. Jalankan: python scripts/finetune_lora.py")
+            print("4. Atau gunakan Novita AI: python scripts/novita_ai_setup.py")
+        
+    except ValueError:
+        print("❌ Input tidak valid")
+    except KeyboardInterrupt:
+        print("\n👋 Download dibatalkan")
+
+if __name__ == "__main__":
+    main()
+
+
+

scripts/download_model.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Script untuk download dan setup model Llama 3.1 8B
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+def check_huggingface_token():
+    """Check if HuggingFace token is available"""
+    token = os.getenv('HUGGINGFACE_TOKEN')
+    if not token:
+        print("❌ HUGGINGFACE_TOKEN tidak ditemukan!")
+        print("Silakan set environment variable:")
+        print("export HUGGINGFACE_TOKEN='your_token_here'")
+        print("\nAtau buat file .env dengan isi:")
+        print("HUGGINGFACE_TOKEN=your_token_here")
+        return False
+    return True
+
+def download_model():
+    """Download model menggunakan huggingface-cli"""
+    model_name = "meta-llama/Llama-3.1-8B-Instruct"
+    models_dir = Path("models")
+    
+    if not models_dir.exists():
+        models_dir.mkdir(parents=True)
+    
+    print(f"📥 Downloading model: {model_name}")
+    print(f"📁 Target directory: {models_dir.absolute()}")
+    
+    try:
+        cmd = [
+            "huggingface-cli", "download",
+            model_name,
+            "--local-dir", str(models_dir / "llama-3.1-8b-instruct"),
+            "--local-dir-use-symlinks", "False"
+        ]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            print("✅ Model berhasil didownload!")
+        else:
+            print(f"❌ Error downloading model: {result.stderr}")
+            return False
+            
+    except FileNotFoundError:
+        print("❌ huggingface-cli tidak ditemukan!")
+        print("Silakan install dengan: pip install huggingface_hub")
+        return False
+    
+    return True
+
+def create_model_config():
+    """Create model configuration file"""
+    config_dir = Path("configs")
+    config_dir.mkdir(exist_ok=True)
+    
+    config_content = """# Model Configuration for Llama 3.1 8B
+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
+"""
+    
+    config_file = config_dir / "llama_config.yaml"
+    with open(config_file, 'w') as f:
+        f.write(config_content)
+    
+    print(f"✅ Model config created: {config_file}")
+
+def main():
+    print("🚀 Setup Base LLM - Llama 3.1 8B")
+    print("=" * 50)
+    
+    if not check_huggingface_token():
+        sys.exit(1)
+    
+    print("\n1️⃣ Downloading model...")
+    if not download_model():
+        sys.exit(1)
+    
+    print("\n2️⃣ Creating model configuration...")
+    create_model_config()
+    
+    print("\n3️⃣ Setup selesai!")
+    print("\n📋 Langkah selanjutnya:")
+    print("1. Jalankan: docker-compose up -d")
+    print("2. Test API: curl http://localhost:8000/health")
+    print("3. Mulai fine-tuning dengan LoRA")
+
+if __name__ == "__main__":
+    main()
+
+
+
+

scripts/download_open_models.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Script untuk download model yang benar-benar open source dan mudah diakses
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+def check_huggingface_token():
+    """Check if HuggingFace token is available"""
+    token = os.getenv('HUGGINGFACE_TOKEN')
+    if not token:
+        print("❌ HUGGINGFACE_TOKEN tidak ditemukan!")
+        print("Silakan set environment variable:")
+        print("export HUGGINGFACE_TOKEN='your_token_here'")
+        return False
+    return True
+
+def download_model(model_name, model_path):
+    """Download model menggunakan huggingface-cli"""
+    print(f"📥 Downloading model: {model_name}")
+    print(f"📁 Target directory: {model_path}")
+    
+    try:
+        cmd = [
+            "huggingface-cli", "download",
+            model_name,
+            "--local-dir", str(model_path),
+            "--local-dir-use-symlinks", "False"
+        ]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            print("✅ Model berhasil didownload!")
+            return True
+        else:
+            print(f"❌ Error downloading model: {result.stderr}")
+            return False
+            
+    except FileNotFoundError:
+        print("❌ huggingface-cli tidak ditemukan!")
+        print("Silakan install dengan: pip install huggingface_hub")
+        return False
+
+def create_model_config(model_name, model_path):
+    """Create model configuration file"""
+    config_dir = Path("configs")
+    config_dir.mkdir(exist_ok=True)
+    
+    config_content = f"""# Model Configuration for {model_name}
+model_name: "{model_name}"
+model_path: "{model_path}"
+max_length: 2048
+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
+"""
+    
+    config_file = config_dir / f"{model_name.split('/')[-1].lower().replace('-', '_')}_config.yaml"
+    with open(config_file, 'w') as f:
+        f.write(config_content)
+    
+    print(f"✅ Model config created: {config_file}")
+    return str(config_file)
+
+def main():
+    print("🚀 Download Open Source Models")
+    print("=" * 50)
+    
+    if not check_huggingface_token():
+        sys.exit(1)
+    
+    # Model options - truly open source
+    models = [
+        {
+            "name": "microsoft/DialoGPT-medium",
+            "path": "models/dialogpt-medium",
+            "description": "DialoGPT Medium - Conversational AI model (355M parameters)"
+        },
+        {
+            "name": "distilgpt2",
+            "path": "models/distilgpt2",
+            "description": "DistilGPT2 - Lightweight GPT-2 model (82M parameters)"
+        },
+        {
+            "name": "gpt2",
+            "path": "models/gpt2",
+            "description": "GPT-2 - Original GPT-2 model (124M parameters)"
+        },
+        {
+            "name": "EleutherAI/gpt-neo-125M",
+            "path": "models/gpt-neo-125m",
+            "description": "GPT-Neo 125M - Small but capable model (125M parameters)"
+        }
+    ]
+    
+    print("📋 Pilih model yang ingin didownload:")
+    for i, model in enumerate(models, 1):
+        print(f"{i}. {model['name']}")
+        print(f"   {model['description']}")
+        print()
+    
+    try:
+        choice = int(input("Pilihan (1-4): ").strip())
+        if choice < 1 or choice > len(models):
+            print("❌ Pilihan tidak valid")
+            return
+        
+        selected_model = models[choice - 1]
+        
+        print(f"\n🎯 Model yang dipilih: {selected_model['name']}")
+        print(f"📝 Deskripsi: {selected_model['description']}")
+        
+        # Confirm download
+        confirm = input("\nLanjutkan download? (y/n): ").strip().lower()
+        if confirm not in ['y', 'yes']:
+            print("❌ Download dibatalkan")
+            return
+        
+        # Download model
+        print(f"\n1️⃣ Downloading model...")
+        if download_model(selected_model['name'], selected_model['path']):
+            print(f"\n2️⃣ Creating model configuration...")
+            config_file = create_model_config(selected_model['name'], selected_model['path'])
+            
+            print("\n3️⃣ Setup selesai!")
+            print(f"\n📋 Langkah selanjutnya:")
+            print(f"1. Model tersimpan di: {selected_model['path']}")
+            print(f"2. Config tersimpan di: {config_file}")
+            print("3. Jalankan: python scripts/finetune_lora.py")
+            print("4. Atau gunakan Novita AI: python scripts/novita_ai_setup.py")
+        
+    except ValueError:
+        print("❌ Input tidak valid")
+    except KeyboardInterrupt:
+        print("\n👋 Download dibatalkan")
+
+if __name__ == "__main__":
+    main()
+
+
+

scripts/finetune_lora.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""
+Script untuk fine-tuning model Llama 3.1 8B dengan LoRA
+"""
+
+import os
+import sys
+import yaml
+import json
+import torch
+from pathlib import Path
+from transformers import (
+    AutoTokenizer, 
+    AutoModelForCausalLM,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForLanguageModeling
+)
+from peft import (
+    LoraConfig,
+    get_peft_model,
+    TaskType,
+    prepare_model_for_kbit_training
+)
+from datasets import Dataset
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def load_config(config_path):
+    """Load configuration from YAML file"""
+    try:
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+        return config
+    except Exception as e:
+        logger.error(f"Error loading config: {e}")
+        return None
+
+def load_model_and_tokenizer(config):
+    """Load base model and tokenizer"""
+    model_path = config['model_path']
+    
+    logger.info(f"Loading model from: {model_path}")
+    
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_path,
+        trust_remote_code=True,
+        padding_side="right"
+    )
+    
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    
+    # Load model
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    
+    # Prepare model for k-bit training
+    model = prepare_model_for_kbit_training(model)
+    
+    return model, tokenizer
+
+def setup_lora_config(config):
+    """Setup LoRA configuration"""
+    lora_config = config['lora_config']
+    
+    peft_config = LoraConfig(
+        task_type=TaskType.CAUSAL_LM,
+        r=lora_config['r'],
+        lora_alpha=lora_config['lora_alpha'],
+        lora_dropout=lora_config['lora_dropout'],
+        target_modules=lora_config['target_modules'],
+        bias="none",
+    )
+    
+    return peft_config
+
+def prepare_dataset(data_path, tokenizer, max_length=512):
+    """Prepare dataset for training"""
+    logger.info(f"Loading dataset from: {data_path}")
+    
+    # Load your dataset here
+    # Support for JSONL format (one JSON object per line)
+    if data_path.endswith('.jsonl'):
+        # Read JSONL file line by line
+        data = []
+        with open(data_path, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, 1):
+                line = line.strip()
+                if line:
+                    try:
+                        json_obj = json.loads(line)
+                        data.append(json_obj)
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"Invalid JSON at line {line_num}: {e}")
+                        continue
+        
+        if not data:
+            raise ValueError("No valid JSON objects found in JSONL file")
+        
+        # Convert to Dataset
+        dataset = Dataset.from_list(data)
+        logger.info(f"Loaded {len(dataset)} samples from JSONL file")
+        
+    elif data_path.endswith('.json'):
+        dataset = Dataset.from_json(data_path)
+    elif data_path.endswith('.csv'):
+        dataset = Dataset.from_csv(data_path)
+    else:
+        raise ValueError("Unsupported data format. Use .jsonl, .json, or .csv")
+    
+    # Validate dataset structure
+    if 'text' not in dataset.column_names:
+        logger.warning("Column 'text' not found in dataset")
+        logger.info(f"Available columns: {dataset.column_names}")
+        # Try to find alternative text column
+        text_columns = [col for col in dataset.column_names if 'text' in col.lower() or 'content' in col.lower()]
+        if text_columns:
+            logger.info(f"Found potential text columns: {text_columns}")
+            # Use first found text column
+            text_column = text_columns[0]
+        else:
+            raise ValueError("No text column found. Dataset must contain a 'text' column or similar")
+    else:
+        text_column = 'text'
+    
+    def tokenize_function(examples):
+        # Tokenize the texts
+        tokenized = tokenizer(
+            examples[text_column],
+            truncation=True,
+            padding=True,
+            max_length=max_length,
+            return_tensors="pt"
+        )
+        return tokenized
+    
+    # Tokenize dataset
+    tokenized_dataset = dataset.map(
+        tokenize_function,
+        batched=True,
+        remove_columns=dataset.column_names
+    )
+    
+    return tokenized_dataset
+
+def train_model(model, tokenizer, dataset, config, output_dir):
+    """Train the model with LoRA"""
+    training_config = config['training_config']
+    
+    # Setup training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=training_config['num_epochs'],
+        per_device_train_batch_size=training_config['batch_size'],
+        gradient_accumulation_steps=training_config['gradient_accumulation_steps'],
+        learning_rate=training_config['learning_rate'],
+        warmup_steps=training_config['warmup_steps'],
+        save_steps=training_config['save_steps'],
+        eval_steps=training_config['eval_steps'],
+        logging_steps=10,
+        save_total_limit=3,
+        prediction_loss_only=True,
+        remove_unused_columns=False,
+        push_to_hub=False,
+        report_to=None,
+    )
+    
+    # Setup data collator
+    data_collator = DataCollatorForLanguageModeling(
+        tokenizer=tokenizer,
+        mlm=False,
+    )
+    
+    # Setup trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset,
+        data_collator=data_collator,
+        tokenizer=tokenizer,
+    )
+    
+    # Start training
+    logger.info("Starting training...")
+    trainer.train()
+    
+    # Save the model
+    trainer.save_model()
+    logger.info(f"Model saved to: {output_dir}")
+
+def main():
+    print("🚀 LoRA Fine-tuning - Llama 3.1 8B")
+    print("=" * 50)
+    
+    # Load configuration
+    config_path = "configs/llama_config.yaml"
+    if not os.path.exists(config_path):
+        print(f"❌ Config file tidak ditemukan: {config_path}")
+        print("Jalankan download_model.py terlebih dahulu")
+        sys.exit(1)
+    
+    config = load_config(config_path)
+    if not config:
+        sys.exit(1)
+    
+    # Setup paths
+    output_dir = Path("models/finetuned-llama-lora")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Load model and tokenizer
+    print("1️⃣ Loading model and tokenizer...")
+    model, tokenizer = load_model_and_tokenizer(config)
+    
+    # Setup LoRA
+    print("2️⃣ Setting up LoRA configuration...")
+    peft_config = setup_lora_config(config)
+    model = get_peft_model(model, peft_config)
+    
+    # Print trainable parameters
+    model.print_trainable_parameters()
+    
+    # Prepare dataset (placeholder - replace with your data)
+    print("3️⃣ Preparing dataset...")
+    data_path = "data/training_data.jsonl"  # Default to JSONL format
+    
+    if not os.path.exists(data_path):
+        print(f"⚠️  Data file tidak ditemukan: {data_path}")
+        print("Buat dataset terlebih dahulu atau update path di script")
+        print("Skipping training...")
+        return
+    
+    dataset = prepare_dataset(data_path, tokenizer)
+    
+    # Train model
+    print("4️⃣ Starting training...")
+    train_model(model, tokenizer, dataset, config, output_dir)
+    
+    print("✅ Training selesai!")
+    print(f"📁 Model tersimpan di: {output_dir}")
+
+if __name__ == "__main__":
+    main()

scripts/local_training_setup.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+Script untuk setup training lokal dengan model yang lebih kecil
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def check_system_requirements():
+    """Check system requirements untuk training lokal"""
+    print("🔍 Checking System Requirements...")
+    print("=" * 50)
+    
+    # Check Python version
+    python_version = sys.version_info
+    print(f"🐍 Python: {python_version.major}.{python_version.minor}.{python_version.micro}")
+    
+    if python_version < (3, 8):
+        print("❌ Python 3.8+ required")
+        return False
+    else:
+        print("✅ Python version OK")
+    
+    # Check available memory
+    try:
+        import psutil
+        memory = psutil.virtual_memory()
+        memory_gb = memory.total / (1024**3)
+        print(f"💾 RAM: {memory_gb:.1f} GB")
+        
+        if memory_gb < 8:
+            print("⚠️  Warning: Less than 8GB RAM may cause issues")
+        else:
+            print("✅ RAM sufficient")
+    except ImportError:
+        print("⚠️  psutil not available, cannot check memory")
+    
+    # Check disk space
+    try:
+        disk = psutil.disk_usage('.')
+        disk_gb = disk.free / (1024**3)
+        print(f"💿 Free Disk: {disk_gb:.1f} GB")
+        
+        if disk_gb < 10:
+            print("⚠️  Warning: Less than 10GB free space")
+        else:
+            print("✅ Disk space sufficient")
+    except:
+        print("⚠️  Cannot check disk space")
+    
+    # Check CUDA (optional)
+    try:
+        import torch
+        if torch.cuda.is_available():
+            gpu_count = torch.cuda.device_count()
+            print(f"🎮 CUDA GPUs: {gpu_count}")
+            for i in range(gpu_count):
+                gpu_name = torch.cuda.get_device_name(i)
+                gpu_memory = torch.cuda.get_device_properties(i).total_memory / (1024**3)
+                print(f"   GPU {i}: {gpu_name} ({gpu_memory:.1f} GB)")
+            print("✅ CUDA available - Fast training possible")
+        else:
+            print("⚠️  CUDA not available - Training will be slower (CPU only)")
+    except ImportError:
+        print("⚠️  PyTorch not available")
+    
+    return True
+
+def download_small_model():
+    """Download model yang cocok untuk training lokal"""
+    print("\n📥 Downloading Small Model for Local Training...")
+    print("=" * 50)
+    
+    # Model options yang cocok untuk training lokal
+    small_models = [
+        {
+            "name": "distilgpt2",
+            "path": "models/distilgpt2",
+            "size_mb": 82,
+            "description": "DistilGPT2 - Very lightweight (82M parameters)"
+        },
+        {
+            "name": "microsoft/DialoGPT-small",
+            "path": "models/dialogpt-small", 
+            "size_mb": 117,
+            "description": "DialoGPT Small - Conversational (117M parameters)"
+        },
+        {
+            "name": "EleutherAI/gpt-neo-125M",
+            "path": "models/gpt-neo-125m",
+            "size_mb": 125,
+            "description": "GPT-Neo 125M - Good balance (125M parameters)"
+        },
+        {
+            "name": "gpt2",
+            "path": "models/gpt2",
+            "size_mb": 124,
+            "description": "GPT-2 - Original but small (124M parameters)"
+        }
+    ]
+    
+    print("📋 Available small models:")
+    for i, model in enumerate(small_models, 1):
+        print(f"{i}. {model['name']}")
+        print(f"   {model['description']}")
+        print(f"   Size: ~{model['size_mb']} MB")
+        print()
+    
+    try:
+        choice = int(input("Pilih model (1-4): ").strip())
+        if choice < 1 or choice > len(small_models):
+            print("❌ Pilihan tidak valid, menggunakan default: distilgpt2")
+            choice = 1
+        
+        selected_model = small_models[choice - 1]
+        print(f"\n🎯 Selected: {selected_model['name']}")
+        
+        # Download model
+        print(f"\n📥 Downloading {selected_model['name']}...")
+        if download_model_with_transformers(selected_model['name'], selected_model['path']):
+            print(f"✅ Model downloaded successfully!")
+            return selected_model
+        else:
+            print("❌ Download failed")
+            return None
+            
+    except (ValueError, KeyboardInterrupt):
+        print("\n❌ Download cancelled")
+        return None
+
+def download_model_with_transformers(model_name, model_path):
+    """Download model menggunakan transformers library"""
+    try:
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        
+        print(f"Downloading tokenizer...")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        tokenizer.save_pretrained(model_path)
+        
+        print(f"Downloading model...")
+        model = AutoModelForCausalLM.from_pretrained(model_name)
+        model.save_pretrained(model_path)
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error downloading model: {e}")
+        return False
+
+def create_local_training_config(model_info):
+    """Create configuration untuk training lokal"""
+    config_dir = Path("configs")
+    config_dir.mkdir(exist_ok=True)
+    
+    config_content = f"""# Local Training Configuration for {model_info['name']}
+model_name: "{model_info['name']}"
+model_path: "{model_info['path']}"
+max_length: 512
+temperature: 0.7
+top_p: 0.9
+top_k: 40
+repetition_penalty: 1.1
+
+# LoRA Configuration (for memory efficiency)
+lora_config:
+  r: 8  # Reduced for smaller models
+  lora_alpha: 16
+  lora_dropout: 0.1
+  target_modules: ["q_proj", "v_proj", "k_proj", "o_proj"]
+  
+# Training Configuration (optimized for local training)
+training_config:
+  learning_rate: 1e-4  # Lower learning rate for stability
+  batch_size: 2  # Smaller batch size for memory
+  gradient_accumulation_steps: 8  # Accumulate gradients
+  num_epochs: 3
+  warmup_steps: 50
+  save_steps: 100
+  eval_steps: 100
+  max_grad_norm: 1.0
+  weight_decay: 0.01
+  
+# Hardware Configuration
+hardware_config:
+  device: "auto"  # Will use GPU if available
+  mixed_precision: true  # Use mixed precision for memory efficiency
+  gradient_checkpointing: true  # Save memory during training
+"""
+    
+    config_file = config_dir / f"local_training_{model_info['name'].split('/')[-1].lower().replace('-', '_')}.yaml"
+    with open(config_file, 'w') as f:
+        f.write(config_content)
+    
+    print(f"✅ Local training config created: {config_file}")
+    return str(config_file)
+
+def setup_local_training_environment():
+    """Setup environment untuk training lokal"""
+    print("\n🔧 Setting up Local Training Environment...")
+    print("=" * 50)
+    
+    # Install required packages
+    packages = [
+        "torch",
+        "transformers", 
+        "datasets",
+        "accelerate",
+        "peft",
+        "bitsandbytes",
+        "scipy",
+        "scikit-learn"
+    ]
+    
+    print("📦 Installing required packages...")
+    for package in packages:
+        try:
+            subprocess.run([sys.executable, "-m", "pip", "install", package], 
+                         check=True, capture_output=True)
+            print(f"✅ {package} installed")
+        except subprocess.CalledProcessError:
+            print(f"⚠️  Failed to install {package}")
+    
+    print("\n✅ Local training environment setup complete!")
+
+def main():
+    print("🚀 Local Training Setup")
+    print("=" * 50)
+    
+    # Check system requirements
+    if not check_system_requirements():
+        print("❌ System requirements not met")
+        return
+    
+    # Setup training environment
+    setup_local_training_environment()
+    
+    # Download small model
+    model_info = download_small_model()
+    if not model_info:
+        print("❌ Model download failed")
+        return
+    
+    # Create training config
+    config_file = create_local_training_config(model_info)
+    
+    print(f"\n🎉 Local Training Setup Complete!")
+    print("=" * 50)
+    print(f"📁 Model: {model_info['path']}")
+    print(f"⚙️  Config: {config_file}")
+    print(f"📊 Dataset: data/lora_dataset_20250829_113330.jsonl")
+    
+    print(f"\n📋 Next steps:")
+    print("1. Review configuration: cat configs/local_training_*.yaml")
+    print("2. Start training: python scripts/finetune_lora.py")
+    print("3. Monitor training: tail -f logs/training.log")
+    
+    print(f"\n💡 Tips for local training:")
+    print("- Use smaller batch sizes if you run out of memory")
+    print("- Enable gradient checkpointing for memory efficiency")
+    print("- Monitor GPU memory usage with nvidia-smi")
+    print("- Consider using mixed precision training")
+
+if __name__ == "__main__":
+    main()
+
+
+

scripts/novita_ai_setup.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+Script untuk setup dan menggunakan Novita AI
+"""
+
+import os
+import sys
+import requests
+import json
+from pathlib import Path
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class NovitaAIClient:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://api.novita.ai"
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    def test_connection(self):
+        """Test koneksi ke Novita AI API"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/v1/models",
+                headers=self.headers
+            )
+            if response.status_code == 200:
+                logger.info("✅ Koneksi ke Novita AI berhasil!")
+                return True
+            else:
+                logger.error(f"❌ Error: {response.status_code} - {response.text}")
+                return False
+        except Exception as e:
+            logger.error(f"❌ Error koneksi: {e}")
+            return False
+    
+    def get_available_models(self):
+        """Dapatkan daftar model yang tersedia"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/v1/models",
+                headers=self.headers
+            )
+            if response.status_code == 200:
+                models = response.json()
+                logger.info("📋 Model yang tersedia:")
+                for model in models.get('data', []):
+                    logger.info(f"  - {model.get('id', 'Unknown')}: {model.get('name', 'Unknown')}")
+                return models
+            else:
+                logger.error(f"❌ Error: {response.status_code}")
+                return None
+        except Exception as e:
+            logger.error(f"❌ Error: {e}")
+            return None
+    
+    def create_fine_tuning_job(self, model_name, training_file, validation_file=None):
+        """Buat fine-tuning job"""
+        try:
+            payload = {
+                "model": model_name,
+                "training_file": training_file,
+                "validation_file": validation_file,
+                "hyperparameters": {
+                    "n_epochs": 3,
+                    "batch_size": 4,
+                    "learning_rate_multiplier": 1.0
+                }
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/v1/fine_tuning/jobs",
+                headers=self.headers,
+                json=payload
+            )
+            
+            if response.status_code == 200:
+                job = response.json()
+                logger.info(f"✅ Fine-tuning job created: {job.get('id')}")
+                return job
+            else:
+                logger.error(f"❌ Error: {response.status_code} - {response.text}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"❌ Error: {e}")
+            return None
+    
+    def list_fine_tuning_jobs(self):
+        """List semua fine-tuning jobs"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/v1/fine_tuning/jobs",
+                headers=self.headers
+            )
+            
+            if response.status_code == 200:
+                jobs = response.json()
+                logger.info("📋 Fine-tuning jobs:")
+                for job in jobs.get('data', []):
+                    status = job.get('status', 'unknown')
+                    model = job.get('model', 'unknown')
+                    job_id = job.get('id', 'unknown')
+                    logger.info(f"  - {job_id}: {model} ({status})")
+                return jobs
+            else:
+                logger.error(f"❌ Error: {response.status_code}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"❌ Error: {e}")
+            return None
+    
+    def get_fine_tuning_job(self, job_id):
+        """Dapatkan detail fine-tuning job"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/v1/fine_tuning/jobs/{job_id}",
+                headers=self.headers
+            )
+            
+            if response.status_code == 200:
+                job = response.json()
+                logger.info(f"📋 Job {job_id}:")
+                logger.info(f"  Status: {job.get('status')}")
+                logger.info(f"  Model: {job.get('model')}")
+                logger.info(f"  Created: {job.get('created_at')}")
+                return job
+            else:
+                logger.error(f"❌ Error: {response.status_code}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"❌ Error: {e}")
+            return None
+
+def setup_novita_environment():
+    """Setup environment untuk Novita AI"""
+    print("🚀 Setup Novita AI Environment")
+    print("=" * 40)
+    
+    # Check API key
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("⚠️  NOVITA_API_KEY tidak ditemukan")
+        api_key = input("Masukkan Novita AI API key: ").strip()
+        if api_key:
+            os.environ['NOVITA_API_KEY'] = api_key
+        else:
+            print("❌ API key diperlukan untuk melanjutkan")
+            return None
+    
+    # Test connection
+    client = NovitaAIClient(api_key)
+    if not client.test_connection():
+        print("❌ Gagal koneksi ke Novita AI")
+        return None
+    
+    return client
+
+def create_sample_dataset():
+    """Buat sample dataset untuk fine-tuning"""
+    data_dir = Path("data")
+    data_dir.mkdir(exist_ok=True)
+    
+    # Sample data untuk fine-tuning
+    sample_data = [
+        {
+            "messages": [
+                {"role": "system", "content": "Anda adalah asisten AI yang membantu dengan pertanyaan dalam bahasa Indonesia."},
+                {"role": "user", "content": "Apa itu machine learning?"},
+                {"role": "assistant", "content": "Machine learning adalah cabang dari artificial intelligence yang memungkinkan komputer belajar dari data tanpa diprogram secara eksplisit."}
+            ]
+        },
+        {
+            "messages": [
+                {"role": "system", "content": "Anda adalah asisten AI yang membantu dengan pertanyaan dalam bahasa Indonesia."},
+                {"role": "user", "content": "Jelaskan tentang deep learning"},
+                {"role": "assistant", "content": "Deep learning adalah subset dari machine learning yang menggunakan neural network dengan banyak layer untuk memproses data kompleks."}
+            ]
+        },
+        {
+            "messages": [
+                {"role": "system", "content": "Anda adalah asisten AI yang membantu dengan pertanyaan dalam bahasa Indonesia."},
+                {"role": "user", "content": "Bagaimana cara kerja neural network?"},
+                {"role": "assistant", "content": "Neural network bekerja dengan menerima input, memproses melalui hidden layers, dan menghasilkan output berdasarkan weights yang telah dilatih."}
+            ]
+        }
+    ]
+    
+    # Save sebagai JSONL
+    output_file = data_dir / "training_data.jsonl"
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item in sample_data:
+            json.dump(item, f, ensure_ascii=False)
+            f.write('\n')
+    
+    print(f"✅ Sample dataset created: {output_file}")
+    return str(output_file)
+
+def main():
+    print("🤖 Novita AI Setup & Fine-tuning")
+    print("=" * 50)
+    
+    # Setup environment
+    client = setup_novita_environment()
+    if not client:
+        return
+    
+    # Get available models
+    print("\n1️⃣ Getting available models...")
+    models = client.get_available_models()
+    
+    # Create sample dataset
+    print("\n2️⃣ Creating sample dataset...")
+    training_file = create_sample_dataset()
+    
+    # Show menu
+    while True:
+        print("\n📋 Menu:")
+        print("1. List fine-tuning jobs")
+        print("2. Create fine-tuning job")
+        print("3. Check job status")
+        print("4. Exit")
+        
+        choice = input("\nPilihan (1-4): ").strip()
+        
+        if choice == "1":
+            client.list_fine_tuning_jobs()
+        elif choice == "2":
+            if models and models.get('data'):
+                model_id = input("Masukkan model ID: ").strip()
+                job = client.create_fine_tuning_job(model_id, training_file)
+                if job:
+                    print(f"✅ Job created: {job.get('id')}")
+            else:
+                print("❌ Tidak ada model tersedia")
+        elif choice == "3":
+            job_id = input("Masukkan job ID: ").strip()
+            client.get_fine_tuning_job(job_id)
+        elif choice == "4":
+            print("👋 Goodbye!")
+            break
+        else:
+            print("❌ Pilihan tidak valid")
+
+if __name__ == "__main__":
+    main()
+
+
+

scripts/novita_ai_setup_v2.py

@@ -0,0 +1,376 @@
+#!/usr/bin/env python3
+"""
+Script untuk setup dan menggunakan Novita AI (Updated Version)
+"""
+
+import os
+import sys
+import requests
+import json
+from pathlib import Path
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class NovitaAIClient:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        # Use correct Novita AI endpoint
+        self.possible_endpoints = [
+            "https://api.novita.ai/openai",
+            "https://api.novita.ai",
+            "https://api.novita.com/openai"
+        ]
+        self.base_url = None
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    def find_working_endpoint(self):
+        """Find working API endpoint"""
+        for endpoint in self.possible_endpoints:
+            try:
+                logger.info(f"🔍 Testing endpoint: {endpoint}")
+                response = requests.get(
+                    f"{endpoint}/v1/models",
+                    headers=self.headers,
+                    timeout=10
+                )
+                if response.status_code == 200:
+                    self.base_url = endpoint
+                    logger.info(f"✅ Working endpoint found: {endpoint}")
+                    return True
+                else:
+                    logger.info(f"⚠️  Endpoint {endpoint} returned {response.status_code}")
+            except Exception as e:
+                logger.info(f"❌ Endpoint {endpoint} failed: {e}")
+                continue
+        
+        return False
+    
+    def test_connection(self):
+        """Test koneksi ke Novita AI API"""
+        if not self.find_working_endpoint():
+            logger.error("❌ Tidak ada endpoint yang berfungsi")
+            return False
+        
+        try:
+            # Use OpenAI-compatible paths
+            test_paths = [
+                "/models",
+                "/v1/models",
+                "/chat/completions"
+            ]
+            
+            for path in test_paths:
+                try:
+                    response = requests.get(
+                        f"{self.base_url}{path}",
+                        headers=self.headers,
+                        timeout=10
+                    )
+                    if response.status_code == 200:
+                        logger.info(f"✅ Koneksi ke Novita AI berhasil! Endpoint: {self.base_url}{path}")
+                        return True
+                    elif response.status_code == 401:
+                        logger.error("❌ Unauthorized - API key mungkin salah")
+                        return False
+                    elif response.status_code == 404:
+                        logger.info(f"⚠️  Path {path} tidak ditemukan, mencoba yang lain...")
+                        continue
+                    else:
+                        logger.info(f"⚠️  Endpoint {path} returned {response.status_code}")
+                except Exception as e:
+                    logger.info(f"⚠️  Path {path} failed: {e}")
+                    continue
+            
+            logger.error("❌ Tidak ada endpoint yang berfungsi")
+            return False
+            
+        except Exception as e:
+            logger.error(f"❌ Error koneksi: {e}")
+            return False
+    
+    def get_available_models(self):
+        """Dapatkan daftar model yang tersedia"""
+        if not self.base_url:
+            logger.error("❌ Base URL belum diset")
+            return None
+            
+        try:
+            # Use OpenAI-compatible model endpoints
+            model_paths = [
+                "/models",
+                "/v1/models"
+            ]
+            
+            for path in model_paths:
+                try:
+                    response = requests.get(
+                        f"{self.base_url}{path}",
+                        headers=self.headers,
+                        timeout=10
+                    )
+                    if response.status_code == 200:
+                        models = response.json()
+                        logger.info("📋 Model yang tersedia:")
+                        if isinstance(models, dict) and 'data' in models:
+                            for model in models['data']:
+                                logger.info(f"  - {model.get('id', 'Unknown')}: {model.get('name', 'Unknown')}")
+                        elif isinstance(models, list):
+                            for model in models:
+                                logger.info(f"  - {model.get('id', 'Unknown')}: {model.get('name', 'Unknown')}")
+                        else:
+                            logger.info(f"  Response format: {type(models)}")
+                            logger.info(f"  Content: {models}")
+                        return models
+                    else:
+                        logger.info(f"⚠️  Path {path} returned {response.status_code}")
+                except Exception as e:
+                    logger.info(f"⚠️  Path {path} failed: {e}")
+                    continue
+            
+            logger.error("❌ Tidak bisa mendapatkan daftar model")
+            return None
+            
+        except Exception as e:
+            logger.error(f"❌ Error: {e}")
+            return None
+    
+    def create_fine_tuning_job(self, model_name, training_file, validation_file=None):
+        """Buat fine-tuning job"""
+        if not self.base_url:
+            logger.error("❌ Base URL belum diset")
+            return None
+            
+        try:
+            payload = {
+                "model": model_name,
+                "training_file": training_file,
+                "validation_file": validation_file,
+                "hyperparameters": {
+                    "n_epochs": 3,
+                    "batch_size": 4,
+                    "learning_rate_multiplier": 1.0
+                }
+            }
+            
+            # Use OpenAI-compatible fine-tuning endpoints
+            ft_paths = [
+                "/fine_tuning/jobs",
+                "/v1/fine_tuning/jobs"
+            ]
+            
+            for path in ft_paths:
+                try:
+                    response = requests.post(
+                        f"{self.base_url}{path}",
+                        headers=self.headers,
+                        json=payload,
+                        timeout=30
+                    )
+                    
+                    if response.status_code == 200:
+                        job = response.json()
+                        logger.info(f"✅ Fine-tuning job created: {job.get('id')}")
+                        return job
+                    elif response.status_code == 404:
+                        logger.info(f"⚠️  Path {path} tidak ditemukan, mencoba yang lain...")
+                        continue
+                    else:
+                        logger.error(f"❌ Error: {response.status_code} - {response.text}")
+                        continue
+                        
+                except Exception as e:
+                    logger.info(f"⚠️  Path {path} failed: {e}")
+                    continue
+            
+            logger.error("❌ Tidak bisa membuat fine-tuning job")
+            return None
+                
+        except Exception as e:
+            logger.error(f"❌ Error: {e}")
+            return None
+    
+    def list_fine_tuning_jobs(self):
+        """List semua fine-tuning jobs"""
+        if not self.base_url:
+            logger.error("❌ Base URL belum diset")
+            return None
+            
+        try:
+            # Use OpenAI-compatible job listing endpoints
+            job_paths = [
+                "/fine_tuning/jobs",
+                "/v1/fine_tuning/jobs"
+            ]
+            
+            for path in job_paths:
+                try:
+                    response = requests.get(
+                        f"{self.base_url}{path}",
+                        headers=self.headers,
+                        timeout=10
+                    )
+                    
+                    if response.status_code == 200:
+                        jobs = response.json()
+                        logger.info("📋 Fine-tuning jobs:")
+                        if isinstance(jobs, dict) and 'data' in jobs:
+                            for job in jobs['data']:
+                                status = job.get('status', 'unknown')
+                                model = job.get('model', 'unknown')
+                                job_id = job.get('id', 'unknown')
+                                logger.info(f"  - {job_id}: {model} ({status})")
+                        elif isinstance(jobs, list):
+                            for job in jobs:
+                                status = job.get('status', 'unknown')
+                                model = job.get('model', 'unknown')
+                                job_id = job.get('id', 'unknown')
+                                logger.info(f"  - {job_id}: {model} ({status})")
+                        else:
+                            logger.info(f"  Response format: {type(jobs)}")
+                            logger.info(f"  Content: {jobs}")
+                        return jobs
+                    elif response.status_code == 404:
+                        logger.info(f"⚠️  Path {path} tidak ditemukan, mencoba yang lain...")
+                        continue
+                    else:
+                        logger.error(f"❌ Error: {response.status_code}")
+                        continue
+                        
+                except Exception as e:
+                    logger.info(f"⚠️  Path {path} failed: {e}")
+                    continue
+            
+            logger.error("❌ Tidak bisa mendapatkan daftar jobs")
+            return None
+                
+        except Exception as e:
+            logger.error(f"❌ Error: {e}")
+            return None
+
+def setup_novita_environment():
+    """Setup environment untuk Novita AI"""
+    print("🚀 Setup Novita AI Environment")
+    print("=" * 40)
+    
+    # Check API key
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("⚠️  NOVITA_API_KEY tidak ditemukan")
+        api_key = input("Masukkan Novita AI API key: ").strip()
+        if api_key:
+            os.environ['NOVITA_API_KEY'] = api_key
+        else:
+            print("❌ API key diperlukan untuk melanjutkan")
+            return None
+    
+    # Test connection
+    client = NovitaAIClient(api_key)
+    if not client.test_connection():
+        print("❌ Gagal koneksi ke Novita AI")
+        print("💡 Tips:")
+        print("- Pastikan API key benar")
+        print("- Cek koneksi internet")
+        print("- Cek dokumentasi Novita AI untuk endpoint yang benar")
+        return None
+    
+    return client
+
+def create_sample_dataset():
+    """Gunakan dataset yang sudah ada atau buat yang baru jika tidak ada"""
+    data_dir = Path("data")
+    data_dir.mkdir(exist_ok=True)
+    
+    # Cek apakah dataset sudah ada
+    existing_dataset = data_dir / "lora_dataset_20250829_113330.jsonl"
+    if existing_dataset.exists():
+        print(f"✅ Dataset sudah ada: {existing_dataset}")
+        print(f"📊 File size: {existing_dataset.stat().st_size / 1024:.2f} KB")
+        return str(existing_dataset)
+    
+    # Jika tidak ada, buat sample dataset
+    print("⚠️  Dataset tidak ditemukan, membuat sample dataset...")
+    sample_data = [
+        {
+            "messages": [
+                {"role": "system", "content": "Anda adalah asisten AI yang membantu dengan pertanyaan dalam bahasa Indonesia."},
+                {"role": "user", "content": "Apa itu machine learning?"},
+                {"role": "assistant", "content": "Machine learning adalah cabang dari artificial intelligence yang memungkinkan komputer belajar dari data tanpa diprogram secara eksplisit."}
+            ]
+        },
+        {
+            "messages": [
+                {"role": "system", "content": "Anda adalah asisten AI yang membantu dengan pertanyaan dalam bahasa Indonesia."},
+                {"role": "user", "content": "Jelaskan tentang deep learning"},
+                {"role": "assistant", "content": "Deep learning adalah subset dari machine learning yang menggunakan neural network dengan banyak layer untuk memproses data kompleks."}
+            ]
+        }
+    ]
+    
+    # Save sebagai JSONL
+    output_file = data_dir / "training_data.jsonl"
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item in sample_data:
+            json.dump(item, f, ensure_ascii=False)
+            f.write('\n')
+    
+    print(f"✅ Sample dataset created: {output_file}")
+    return str(output_file)
+
+def main():
+    print("🤖 Novita AI Setup & Fine-tuning (Updated)")
+    print("=" * 50)
+    
+    # Setup environment
+    client = setup_novita_environment()
+    if not client:
+        return
+    
+    # Get available models
+    print("\n1️⃣ Getting available models...")
+    models = client.get_available_models()
+    
+    # Create sample dataset
+    print("\n2️⃣ Creating sample dataset...")
+    training_file = create_sample_dataset()
+    
+    # Show menu
+    while True:
+        print("\n📋 Menu:")
+        print("1. List fine-tuning jobs")
+        print("2. Create fine-tuning job")
+        print("3. Check job status")
+        print("4. Test API endpoints")
+        print("5. Exit")
+        
+        choice = input("\nPilihan (1-5): ").strip()
+        
+        if choice == "1":
+            client.list_fine_tuning_jobs()
+        elif choice == "2":
+            if models:
+                model_id = input("Masukkan model ID: ").strip()
+                job = client.create_fine_tuning_job(model_id, training_file)
+                if job:
+                    print(f"✅ Job created: {job.get('id')}")
+            else:
+                print("❌ Tidak ada model tersedia")
+        elif choice == "3":
+            job_id = input("Masukkan job ID: ").strip()
+            # This would need to be implemented based on actual API
+            print("⚠️  Check job status belum diimplementasikan")
+        elif choice == "4":
+            print("🔍 Testing API endpoints...")
+            client.test_connection()
+        elif choice == "5":
+            print("👋 Goodbye!")
+            break
+        else:
+            print("❌ Pilihan tidak valid")
+
+if __name__ == "__main__":
+    main()

scripts/run_novita_finetuning.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""
+Script sederhana untuk menjalankan fine-tuning Novita AI
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Import NovitaAIClient dari script yang sudah ada
+sys.path.append('scripts')
+from novita_ai_setup_v2 import NovitaAIClient, create_sample_dataset
+
+def main():
+    print("🚀 Novita AI Fine-tuning - Auto Run")
+    print("=" * 50)
+    
+    # Check environment variables
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY tidak ditemukan")
+        print("Silakan set: export NOVITA_API_KEY='your_key'")
+        return
+    
+    base_url = os.getenv('NOVITA_BASE_URL', 'https://api.novita.ai/openai')
+    print(f"🔑 API Key: {api_key[:10]}...{api_key[-10:]}")
+    print(f"🌐 Base URL: {base_url}")
+    
+    # Create client
+    client = NovitaAIClient(api_key)
+    client.base_url = base_url
+    
+    # Test connection
+    print("\n1️⃣ Testing connection...")
+    if not client.test_connection():
+        print("❌ Koneksi gagal")
+        return
+    
+    # Get available models
+    print("\n2️⃣ Getting available models...")
+    models = client.get_available_models()
+    
+    if not models:
+        print("❌ Tidak bisa mendapatkan daftar model")
+        return
+    
+    # Select model automatically (Llama 3.2 1B Instruct if available)
+    selected_model = None
+    preferred_models = [
+        "meta-llama/llama-3.2-1b-instruct",
+        "meta-llama/llama-3.2-3b-instruct",
+        "qwen/qwen3-4b-fp8",
+        "qwen/qwen3-8b-fp8"
+    ]
+    
+    print("\n🎯 Selecting model...")
+    for preferred in preferred_models:
+        if isinstance(models, dict) and 'data' in models:
+            for model in models['data']:
+                if model.get('id') == preferred:
+                    selected_model = preferred
+                    print(f"✅ Selected: {preferred}")
+                    break
+        elif isinstance(models, list):
+            for model in models:
+                if model.get('id') == preferred:
+                    selected_model = preferred
+                    print(f"✅ Selected: {preferred}")
+                    break
+        
+        if selected_model:
+            break
+    
+    if not selected_model:
+        # Fallback to first available model
+        if isinstance(models, dict) and 'data' in models and models['data']:
+            selected_model = models['data'][0].get('id')
+        elif isinstance(models, list) and models:
+            selected_model = models[0].get('id')
+        
+        if selected_model:
+            print(f"⚠️  Fallback to: {selected_model}")
+        else:
+            print("❌ Tidak ada model yang tersedia")
+            return
+    
+    # Create dataset
+    print("\n3️⃣ Preparing dataset...")
+    training_file = create_sample_dataset()
+    
+    # Create fine-tuning job
+    print(f"\n4️⃣ Creating fine-tuning job...")
+    print(f"   Model: {selected_model}")
+    print(f"   Training file: {training_file}")
+    
+    job = client.create_fine_tuning_job(selected_model, training_file)
+    
+    if job:
+        print(f"\n✅ Fine-tuning job created successfully!")
+        print(f"   Job ID: {job.get('id')}")
+        print(f"   Status: {job.get('status', 'unknown')}")
+        print(f"   Model: {job.get('model', 'unknown')}")
+        
+        print(f"\n📋 Next steps:")
+        print(f"1. Monitor job status")
+        print(f"2. Check logs for progress")
+        print(f"3. Download fine-tuned model when complete")
+        
+    else:
+        print("\n❌ Failed to create fine-tuning job")
+        print("💡 Check the error messages above")
+
+if __name__ == "__main__":
+    main()
+
+
+

scripts/test_model.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""
+Script untuk testing model yang sudah di-fine-tune
+"""
+
+import os
+import sys
+import yaml
+import torch
+from pathlib import Path
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def load_finetuned_model(model_path, lora_weights_path):
+    """Load fine-tuned model with LoRA weights"""
+    logger.info(f"Loading base model from: {model_path}")
+    
+    # Load base model
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    
+    # Load LoRA weights
+    logger.info(f"Loading LoRA weights from: {lora_weights_path}")
+    model = PeftModel.from_pretrained(model, lora_weights_path)
+    
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_path,
+        trust_remote_code=True
+    )
+    
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    
+    return model, tokenizer
+
+def generate_response(model, tokenizer, prompt, max_length=512):
+    """Generate response from the model"""
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_length=max_length,
+            temperature=0.7,
+            top_p=0.9,
+            top_k=40,
+            repetition_penalty=1.1,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response
+
+def interactive_test(model, tokenizer):
+    """Interactive testing mode"""
+    print("🤖 Interactive Testing Mode")
+    print("Type 'quit' to exit")
+    print("-" * 50)
+    
+    while True:
+        try:
+            user_input = input("\n👤 You: ").strip()
+            
+            if user_input.lower() in ['quit', 'exit', 'q']:
+                print("👋 Goodbye!")
+                break
+            
+            if not user_input:
+                continue
+            
+            print("\n🤖 Assistant: ", end="")
+            response = generate_response(model, tokenizer, user_input)
+            
+            # Extract only the generated part (remove input)
+            if user_input in response:
+                generated_part = response.split(user_input)[-1].strip()
+                print(generated_part)
+            else:
+                print(response)
+                
+        except KeyboardInterrupt:
+            print("\n👋 Goodbye!")
+            break
+        except Exception as e:
+            logger.error(f"Error generating response: {e}")
+            print(f"❌ Error: {e}")
+
+def batch_test(model, tokenizer, test_cases):
+    """Batch testing with predefined test cases"""
+    print("🧪 Batch Testing Mode")
+    print("=" * 50)
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"\n📝 Test Case {i}: {test_case['prompt']}")
+        print("-" * 40)
+        
+        try:
+            response = generate_response(model, tokenizer, test_case['prompt'])
+            print(f"🤖 Response: {response}")
+            
+            if 'expected' in test_case:
+                print(f"🎯 Expected: {test_case['expected']}")
+                
+        except Exception as e:
+            logger.error(f"Error in test case {i}: {e}")
+            print(f"❌ Error: {e}")
+
+def main():
+    print("🧪 Model Testing - Fine-tuned Llama 3.1 8B")
+    print("=" * 50)
+    
+    # Check if model exists
+    base_model_path = "models/llama-3.1-8b-instruct"
+    lora_weights_path = "models/finetuned-llama-lora"
+    
+    if not os.path.exists(base_model_path):
+        print(f"❌ Base model tidak ditemukan: {base_model_path}")
+        print("Jalankan download_model.py terlebih dahulu")
+        sys.exit(1)
+    
+    if not os.path.exists(lora_weights_path):
+        print(f"⚠️  LoRA weights tidak ditemukan: {lora_weights_path}")
+        print("Model akan menggunakan base model tanpa fine-tuning")
+        lora_weights_path = None
+    
+    try:
+        # Load model
+        print("1️⃣ Loading model...")
+        if lora_weights_path:
+            model, tokenizer = load_finetuned_model(base_model_path, lora_weights_path)
+        else:
+            from transformers import AutoTokenizer, AutoModelForCausalLM
+            model = AutoModelForCausalLM.from_pretrained(
+                base_model_path,
+                torch_dtype=torch.float16,
+                device_map="auto",
+                trust_remote_code=True
+            )
+            tokenizer = AutoTokenizer.from_pretrained(
+                base_model_path,
+                trust_remote_code=True
+            )
+        
+        print("✅ Model loaded successfully!")
+        
+        # Test cases
+        test_cases = [
+            {
+                "prompt": "Apa itu machine learning?",
+                "expected": "Penjelasan tentang machine learning"
+            },
+            {
+                "prompt": "Jelaskan tentang deep learning dalam bahasa Indonesia",
+                "expected": "Penjelasan tentang deep learning"
+            },
+            {
+                "prompt": "Buat puisi tentang teknologi",
+                "expected": "Puisi tentang teknologi"
+            }
+        ]
+        
+        # Choose testing mode
+        print("\n2️⃣ Pilih mode testing:")
+        print("1. Interactive mode (chat)")
+        print("2. Batch testing")
+        print("3. Custom prompt")
+        
+        choice = input("\nPilihan (1-3): ").strip()
+        
+        if choice == "1":
+            interactive_test(model, tokenizer)
+        elif choice == "2":
+            batch_test(model, tokenizer, test_cases)
+        elif choice == "3":
+            custom_prompt = input("Masukkan prompt custom: ").strip()
+            if custom_prompt:
+                response = generate_response(model, tokenizer, custom_prompt)
+                print(f"\n🤖 Response: {response}")
+        else:
+            print("❌ Pilihan tidak valid")
+            
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        print(f"❌ Error loading model: {e}")
+
+if __name__ == "__main__":
+    main()
+
+
+
+

scripts/test_novita_connection.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Simple script untuk test koneksi Novita AI
+"""
+
+import os
+import requests
+import json
+
+def test_novita_connection():
+    """Test koneksi ke Novita AI dengan berbagai cara"""
+    
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY tidak ditemukan")
+        return
+    
+    print(f"🔑 API Key: {api_key[:10]}...{api_key[-10:]}")
+    print("🔍 Testing koneksi ke Novita AI...")
+    
+    # Test different possible endpoints
+    endpoints_to_test = [
+        "https://api.novita.ai",
+        "https://api.novita.com",
+        "https://novita.ai/api",
+        "https://novita.com/api",
+        "https://api.novita.ai/v1",
+        "https://api.novita.com/v1",
+        "https://novita.ai/api/v1",
+        "https://novita.com/api/v1"
+    ]
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    working_endpoints = []
+    
+    for endpoint in endpoints_to_test:
+        print(f"\n🔍 Testing: {endpoint}")
+        
+        # Test basic connectivity
+        try:
+            # Test GET request
+            response = requests.get(f"{endpoint}/models", headers=headers, timeout=10)
+            print(f"  GET /models: {response.status_code}")
+            
+            if response.status_code == 200:
+                print(f"  ✅ Success! Response: {response.text[:200]}...")
+                working_endpoints.append(endpoint)
+            elif response.status_code == 401:
+                print(f"  ⚠️  Unauthorized - API key mungkin salah")
+            elif response.status_code == 404:
+                print(f"  ⚠️  Not Found - Endpoint tidak ada")
+            else:
+                print(f"  ⚠️  Status: {response.status_code}")
+                
+        except requests.exceptions.ConnectionError as e:
+            print(f"  ❌ Connection Error: {e}")
+        except requests.exceptions.Timeout as e:
+            print(f"  ⏰ Timeout: {e}")
+        except Exception as e:
+            print(f"  ❌ Error: {e}")
+        
+        # Test POST request
+        try:
+            test_data = {"test": "connection"}
+            response = requests.post(f"{endpoint}/test", headers=headers, json=test_data, timeout=10)
+            print(f"  POST /test: {response.status_code}")
+        except Exception as e:
+            print(f"  ❌ POST Error: {e}")
+    
+    print(f"\n📊 Summary:")
+    if working_endpoints:
+        print(f"✅ Working endpoints: {len(working_endpoints)}")
+        for endpoint in working_endpoints:
+            print(f"  - {endpoint}")
+    else:
+        print("❌ No working endpoints found")
+        print("\n💡 Suggestions:")
+        print("1. Check if the API key is correct")
+        print("2. Check Novita AI documentation for correct endpoints")
+        print("3. Try using a different API key")
+        print("4. Check if there are any IP restrictions")
+    
+    return working_endpoints
+
+def test_openai_compatible():
+    """Test if Novita AI is OpenAI compatible"""
+    print("\n🤖 Testing OpenAI compatibility...")
+    
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY tidak ditemukan")
+        return
+    
+    # Try OpenAI-compatible endpoints
+    openai_endpoints = [
+        "https://api.novita.ai/v1",
+        "https://api.novita.com/v1",
+        "https://novita.ai/api/v1",
+        "https://novita.com/api/v1"
+    ]
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    for endpoint in openai_endpoints:
+        print(f"\n🔍 Testing OpenAI endpoint: {endpoint}")
+        
+        try:
+            # Test models endpoint
+            response = requests.get(f"{endpoint}/models", headers=headers, timeout=10)
+            print(f"  GET /models: {response.status_code}")
+            
+            if response.status_code == 200:
+                print(f"  ✅ Success!")
+                try:
+                    models = response.json()
+                    print(f"  📋 Models: {json.dumps(models, indent=2)[:300]}...")
+                except:
+                    print(f"  📋 Response: {response.text[:200]}...")
+            elif response.status_code == 401:
+                print(f"  ⚠️  Unauthorized")
+            elif response.status_code == 404:
+                print(f"  ⚠️  Not Found")
+            else:
+                print(f"  ⚠️  Status: {response.status_code}")
+                
+        except Exception as e:
+            print(f"  ❌ Error: {e}")
+
+def main():
+    print("🔍 Novita AI Connection Tester")
+    print("=" * 40)
+    
+    # Test basic connection
+    working_endpoints = test_novita_connection()
+    
+    # Test OpenAI compatibility
+    test_openai_compatible()
+    
+    print(f"\n🎯 Next Steps:")
+    if working_endpoints:
+        print("✅ Koneksi berhasil! Anda bisa melanjutkan dengan fine-tuning")
+        print("💡 Gunakan endpoint yang berfungsi untuk setup selanjutnya")
+    else:
+        print("❌ Koneksi gagal. Cek dokumentasi Novita AI")
+        print("💡 Atau gunakan alternatif lain seperti local models")
+
+if __name__ == "__main__":
+    main()
+
+
+

scripts/train_with_monitoring.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Script untuk training dengan monitoring GPU dan logging yang lengkap
+"""
+
+import os
+import sys
+import time
+import json
+import psutil
+import GPUtil
+from pathlib import Path
+from datetime import datetime
+import logging
+from finetune_lora import main as finetune_main
+
+def setup_logging():
+    """Setup logging dengan format yang lengkap"""
+    log_dir = Path("logs")
+    log_dir.mkdir(exist_ok=True)
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_file = log_dir / f"training_{timestamp}.log"
+    
+    # Setup logging format
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler(log_file, encoding='utf-8'),
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    
+    return logging.getLogger(__name__)
+
+def get_system_info():
+    """Get system information"""
+    info = {
+        "timestamp": datetime.now().isoformat(),
+        "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_usage": {}
+    }
+    
+    # Disk usage
+    for partition in psutil.disk_partitions():
+        try:
+            usage = psutil.disk_usage(partition.mountpoint)
+            info["disk_usage"][partition.mountpoint] = {
+                "total_gb": round(usage.total / (1024**3), 2),
+                "used_gb": round(usage.used / (1024**3), 2),
+                "free_gb": round(usage.free / (1024**3), 2),
+                "percent": usage.percent
+            }
+        except PermissionError:
+            continue
+    
+    return info
+
+def get_gpu_info():
+    """Get GPU information"""
+    try:
+        gpus = GPUtil.getGPUs()
+        gpu_info = []
+        
+        for gpu in gpus:
+            gpu_info.append({
+                "id": gpu.id,
+                "name": gpu.name,
+                "memory_total_mb": gpu.memoryTotal,
+                "memory_used_mb": gpu.memoryUsed,
+                "memory_free_mb": gpu.memoryFree,
+                "memory_utilization_percent": gpu.memoryUtil * 100,
+                "gpu_utilization_percent": gpu.load * 100,
+                "temperature_celsius": gpu.temperature
+            })
+        
+        return gpu_info
+    except Exception as e:
+        logging.warning(f"Could not get GPU info: {e}")
+        return []
+
+def monitor_resources(logger, interval=30):
+    """Monitor system resources during training"""
+    logger.info("🔍 Starting resource monitoring...")
+    
+    start_time = time.time()
+    monitoring_data = []
+    
+    try:
+        while True:
+            # Get current resource usage
+            current_time = time.time()
+            elapsed_time = current_time - start_time
+            
+            # System info
+            system_info = get_system_info()
+            system_info["elapsed_time_seconds"] = elapsed_time
+            
+            # GPU info
+            gpu_info = get_gpu_info()
+            
+            # Memory usage
+            memory = psutil.virtual_memory()
+            system_info["memory_used_gb"] = round(memory.used / (1024**3), 2)
+            system_info["memory_percent"] = memory.percent
+            
+            # CPU usage
+            system_info["cpu_percent"] = psutil.cpu_percent(interval=1)
+            
+            # Combine all info
+            monitoring_entry = {
+                "timestamp": datetime.now().isoformat(),
+                "elapsed_time_seconds": elapsed_time,
+                "system": system_info,
+                "gpu": gpu_info
+            }
+            
+            monitoring_data.append(monitoring_entry)
+            
+            # Log summary
+            logger.info(f"⏱️  Elapsed: {elapsed_time/60:.1f}min | "
+                       f"CPU: {system_info['cpu_percent']:.1f}% | "
+                       f"RAM: {system_info['memory_percent']:.1f}%")
+            
+            if gpu_info:
+                for gpu in gpu_info:
+                    logger.info(f"🎮 GPU {gpu['id']}: "
+                               f"Util: {gpu['gpu_utilization_percent']:.1f}% | "
+                               f"Memory: {gpu['memory_utilization_percent']:.1f}% | "
+                               f"Temp: {gpu['temperature_celsius']:.1f}°C")
+            
+            # Save monitoring data periodically
+            if len(monitoring_data) % 10 == 0:  # Every 10 entries
+                monitoring_file = Path("logs") / f"monitoring_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+                with open(monitoring_file, 'w') as f:
+                    json.dump(monitoring_data, f, indent=2)
+                logger.info(f"💾 Monitoring data saved: {monitoring_file}")
+            
+            time.sleep(interval)
+            
+    except KeyboardInterrupt:
+        logger.info("⏹️  Resource monitoring stopped by user")
+    
+    return monitoring_data
+
+def main():
+    """Main function untuk training dengan monitoring"""
+    print("🚀 Training dengan Monitoring - Llama 3.1 8B LoRA")
+    print("=" * 60)
+    
+    # Setup logging
+    logger = setup_logging()
+    
+    # Log system information
+    logger.info("🖥️  System Information:")
+    system_info = get_system_info()
+    for key, value in system_info.items():
+        if key != "disk_usage":
+            logger.info(f"  {key}: {value}")
+    
+    # Log GPU information
+    gpu_info = get_gpu_info()
+    if gpu_info:
+        logger.info("🎮 GPU Information:")
+        for gpu in gpu_info:
+            logger.info(f"  GPU {gpu['id']}: {gpu['name']}")
+            logger.info(f"    Memory: {gpu['memory_total_mb']}MB total")
+            logger.info(f"    Temperature: {gpu['temperature_celsius']}°C")
+    else:
+        logger.warning("⚠️  No GPU detected. Training will be very slow on CPU!")
+    
+    # Check prerequisites
+    logger.info("🔍 Checking prerequisites...")
+    
+    # Check if model exists
+    model_path = Path("models/llama-3.1-8b-instruct")
+    if not model_path.exists():
+        logger.error("❌ Base model not found. Please run download_model.py first!")
+        return
+    
+    # Check if dataset exists
+    data_path = Path("data/training_data.jsonl")
+    if not data_path.exists():
+        logger.error("❌ Training dataset not found. Please run create_sample_dataset.py first!")
+        return
+    
+    # Check if config exists
+    config_path = Path("configs/llama_config.yaml")
+    if not config_path.exists():
+        logger.error("❌ Model configuration not found. Please run download_model.py first!")
+        return
+    
+    logger.info("✅ All prerequisites met!")
+    
+    # Start resource monitoring in background
+    import threading
+    monitoring_thread = threading.Thread(
+        target=monitor_resources, 
+        args=(logger, 30),  # Monitor every 30 seconds
+        daemon=True
+    )
+    monitoring_thread.start()
+    
+    # Start training
+    logger.info("🚀 Starting LoRA fine-tuning...")
+    try:
+        finetune_main()
+        logger.info("✅ Training completed successfully!")
+    except Exception as e:
+        logger.error(f"❌ Training failed: {e}")
+        raise
+    finally:
+        logger.info("📊 Training session ended")
+        
+        # Save final monitoring data
+        monitoring_file = Path("logs") / f"final_monitoring_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        # Note: In a real implementation, you'd want to capture the monitoring data
+        logger.info(f"💾 Final monitoring data saved: {monitoring_file}")
+
+if __name__ == "__main__":
+    main()
+
+
+
+

setup.bat

@@ -0,0 +1,54 @@
+@echo off
+echo 🚀 Setup Base LLM Environment (Windows)
+echo ======================================
+
+REM Check if Python is available
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ❌ Python tidak ditemukan!
+    echo Silakan install Python 3.8+ terlebih dahulu
+    pause
+    exit /b 1
+)
+
+echo ✅ Python ditemukan
+
+REM Create virtual environment
+echo 📦 Creating virtual environment...
+python -m venv venv
+
+REM Activate virtual environment
+echo 🔧 Activating virtual environment...
+call venv\Scripts\activate.bat
+
+REM Upgrade pip
+echo ⬆️  Upgrading pip...
+python -m pip install --upgrade pip
+
+REM Install requirements
+echo 📚 Installing requirements...
+pip install -r requirements.txt
+
+REM Install additional tools
+echo 🛠️  Installing additional tools...
+pip install huggingface-cli
+
+echo.
+echo ✅ Setup selesai!
+echo.
+echo 📋 Langkah selanjutnya:
+echo 1. Aktifkan virtual environment: venv\Scripts\activate.bat
+echo 2. Set HuggingFace token: set HUGGINGFACE_TOKEN=your_token
+echo 3. Jalankan: python scripts\download_model.py
+echo 4. Jalankan: python scripts\finetune_lora.py
+echo.
+echo 💡 Tips:
+echo - Selalu aktifkan venv sebelum menjalankan script
+echo - Gunakan 'deactivate' untuk keluar dari venv
+echo - Pastikan GPU tersedia untuk training
+echo.
+pause
+
+
+
+

setup.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+echo "🚀 Setup Base LLM Environment"
+echo "=============================="
+
+# Check if Python 3.8+ is available
+python_version=$(python3 --version 2>&1 | grep -oP '\d+\.\d+' | head -1)
+if [[ -z "$python_version" ]]; then
+    echo "❌ Python 3 tidak ditemukan!"
+    echo "Silakan install Python 3.8+ terlebih dahulu"
+    exit 1
+fi
+
+echo "✅ Python version: $python_version"
+
+# Create virtual environment
+echo "📦 Creating virtual environment..."
+python3 -m venv venv
+
+# Activate virtual environment
+echo "🔧 Activating virtual environment..."
+source venv/bin/activate
+
+# Upgrade pip
+echo "⬆️  Upgrading pip..."
+pip install --upgrade pip
+
+# Install requirements
+echo "📚 Installing requirements..."
+pip install -r requirements.txt
+
+# Install additional tools
+echo "🛠️  Installing additional tools..."
+pip install huggingface-cli
+
+echo ""
+echo "✅ Setup selesai!"
+echo ""
+echo "📋 Langkah selanjutnya:"
+echo "1. Aktifkan virtual environment: source venv/bin/activate"
+echo "2. Set HuggingFace token: export HUGGINGFACE_TOKEN='your_token'"
+echo "3. Jalankan: python scripts/download_model.py"
+echo "4. Jalankan: python scripts/finetune_lora.py"
+echo ""
+echo "💡 Tips:"
+echo "- Selalu aktifkan venv sebelum menjalankan script"
+echo "- Gunakan 'deactivate' untuk keluar dari venv"
+echo "- Pastikan GPU tersedia untuk training"
+
+
+
+

setup_novita.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+echo "🚀 Setup Novita AI Environment"
+echo "=============================="
+
+# Check if Python 3.8+ is available
+python_version=$(python3 --version 2>&1 | grep -oP '\d+\.\d+' | head -1)
+if [[ -z "$python_version" ]]; then
+    echo "❌ Python 3 tidak ditemukan!"
+    echo "Silakan install Python 3.8+ terlebih dahulu"
+    exit 1
+fi
+
+echo "✅ Python version: $python_version"
+
+# Create virtual environment
+echo "📦 Creating virtual environment..."
+python3 -m venv venv
+
+# Activate virtual environment
+echo "🔧 Activating virtual environment..."
+source venv/bin/activate
+
+# Upgrade pip
+echo "⬆️  Upgrading pip..."
+pip install --upgrade pip
+
+# Install requirements for Novita AI
+echo "📚 Installing requirements..."
+pip install requests openai python-dotenv
+
+# Install additional tools
+echo "🛠️  Installing additional tools..."
+pip install huggingface-hub
+
+echo ""
+echo "✅ Setup selesai!"
+echo ""
+echo "📋 Langkah selanjutnya:"
+echo "1. Aktifkan virtual environment: source venv/bin/activate"
+echo "2. Set Novita AI API key: export NOVITA_API_KEY='your_key'"
+echo "3. Jalankan: python scripts/novita_ai_setup.py"
+echo ""
+echo "💡 Tips:"
+echo "- Selalu aktifkan venv sebelum menjalankan script"
+echo "- Gunakan 'deactivate' untuk keluar dari venv"
+echo "- Pastikan API key Novita AI valid"
+echo ""
+echo "🔑 Untuk mendapatkan API key:"
+echo "1. Kunjungi https://novita.ai"
+echo "2. Buat account atau login"
+echo "3. Buka dashboard dan cari API keys"
+echo "4. Copy API key dan set sebagai environment variable"
+
+
+

templates/chat.html

@@ -0,0 +1,350 @@
+<!DOCTYPE html>
+<html lang="id">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Textilindo AI Assistant</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            height: 100vh;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        .chat-container {
+            width: 90%;
+            max-width: 800px;
+            height: 80vh;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            text-align: center;
+        }
+
+        .header h1 {
+            font-size: 24px;
+            margin-bottom: 5px;
+        }
+
+        .header p {
+            opacity: 0.9;
+            font-size: 14px;
+        }
+
+        .chat-messages {
+            flex: 1;
+            padding: 20px;
+            overflow-y: auto;
+            background: #f8f9fa;
+        }
+
+        .message {
+            margin-bottom: 15px;
+            display: flex;
+            align-items: flex-start;
+        }
+
+        .message.user {
+            justify-content: flex-end;
+        }
+
+        .message-content {
+            max-width: 70%;
+            padding: 12px 16px;
+            border-radius: 18px;
+            word-wrap: break-word;
+        }
+
+        .message.user .message-content {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border-bottom-right-radius: 4px;
+        }
+
+        .message.assistant .message-content {
+            background: white;
+            color: #333;
+            border: 1px solid #e1e5e9;
+            border-bottom-left-radius: 4px;
+        }
+
+        .avatar {
+            width: 32px;
+            height: 32px;
+            border-radius: 50%;
+            margin: 0 8px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-weight: bold;
+            font-size: 14px;
+        }
+
+        .user .avatar {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+
+        .assistant .avatar {
+            background: #28a745;
+            color: white;
+        }
+
+        .input-container {
+            padding: 20px;
+            background: white;
+            border-top: 1px solid #e1e5e9;
+        }
+
+        .input-form {
+            display: flex;
+            gap: 10px;
+        }
+
+        .message-input {
+            flex: 1;
+            padding: 12px 16px;
+            border: 2px solid #e1e5e9;
+            border-radius: 25px;
+            font-size: 14px;
+            outline: none;
+            transition: border-color 0.3s;
+        }
+
+        .message-input:focus {
+            border-color: #667eea;
+        }
+
+        .send-button {
+            padding: 12px 24px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 25px;
+            cursor: pointer;
+            font-weight: bold;
+            transition: transform 0.2s;
+        }
+
+        .send-button:hover {
+            transform: translateY(-2px);
+        }
+
+        .send-button:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .typing-indicator {
+            display: none;
+            padding: 12px 16px;
+            background: white;
+            border: 1px solid #e1e5e9;
+            border-radius: 18px;
+            border-bottom-left-radius: 4px;
+            color: #666;
+            font-style: italic;
+        }
+
+        .stats {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            background: white;
+            padding: 15px;
+            border-radius: 10px;
+            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+            font-size: 12px;
+            max-width: 200px;
+        }
+
+        .stats h3 {
+            margin-bottom: 10px;
+            color: #667eea;
+        }
+
+        .stats p {
+            margin-bottom: 5px;
+        }
+
+        @media (max-width: 768px) {
+            .chat-container {
+                width: 95%;
+                height: 90vh;
+            }
+            
+            .stats {
+                position: static;
+                margin: 10px;
+                max-width: none;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="stats" id="stats">
+        <h3>📊 Stats</h3>
+        <p>Loading...</p>
+    </div>
+
+    <div class="chat-container">
+        <div class="header">
+            <h1>🤖 Textilindo AI Assistant</h1>
+            <p>Powered by Novita AI • Ask me anything about Textilindo!</p>
+        </div>
+
+        <div class="chat-messages" id="chatMessages">
+            <div class="message assistant">
+                <div class="avatar">AI</div>
+                <div class="message-content">
+                    Halo! Saya adalah AI Assistant Textilindo. Ada yang bisa saya bantu? 😊
+                </div>
+            </div>
+        </div>
+
+        <div class="typing-indicator" id="typingIndicator">
+            AI sedang mengetik...
+        </div>
+
+        <div class="input-container">
+            <form class="input-form" id="chatForm">
+                <input type="text" class="message-input" id="messageInput" 
+                       placeholder="Ketik pertanyaan Anda di sini..." autocomplete="off">
+                <button type="submit" class="send-button" id="sendButton">
+                    Kirim
+                </button>
+            </form>
+        </div>
+    </div>
+
+    <script>
+        const chatMessages = document.getElementById('chatMessages');
+        const messageInput = document.getElementById('messageInput');
+        const sendButton = document.getElementById('sendButton');
+        const chatForm = document.getElementById('chatForm');
+        const typingIndicator = document.getElementById('typingIndicator');
+        const stats = document.getElementById('stats');
+
+        // Load stats
+        fetch('/stats')
+            .then(response => response.json())
+            .then(data => {
+                if (data.error) {
+                    stats.innerHTML = '<h3>📊 Stats</h3><p>Error loading stats</p>';
+                } else {
+                    stats.innerHTML = `
+                        <h3>📊 Stats</h3>
+                        <p>📝 ${data.total_examples} examples</p>
+                        <p>🤖 ${data.model.split('/').pop()}</p>
+                        <p>📂 ${Object.keys(data.topics).length} topics</p>
+                    `;
+                }
+            })
+            .catch(error => {
+                stats.innerHTML = '<h3>📊 Stats</h3><p>Error loading stats</p>';
+            });
+
+        function addMessage(content, isUser = false) {
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${isUser ? 'user' : 'assistant'}`;
+            
+            const avatar = document.createElement('div');
+            avatar.className = 'avatar';
+            avatar.textContent = isUser ? 'U' : 'AI';
+            
+            const messageContent = document.createElement('div');
+            messageContent.className = 'message-content';
+            messageContent.textContent = content;
+            
+            messageDiv.appendChild(avatar);
+            messageDiv.appendChild(messageContent);
+            
+            chatMessages.appendChild(messageDiv);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
+        function showTyping() {
+            typingIndicator.style.display = 'block';
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
+        function hideTyping() {
+            typingIndicator.style.display = 'none';
+        }
+
+        async function sendMessage(message) {
+            if (!message.trim()) return;
+
+            // Add user message
+            addMessage(message, true);
+            messageInput.value = '';
+
+            // Show typing indicator
+            showTyping();
+
+            try {
+                const response = await fetch('/chat', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ message: message })
+                });
+
+                const data = await response.json();
+                
+                // Hide typing indicator
+                hideTyping();
+
+                // Add AI response
+                addMessage(data.response);
+
+            } catch (error) {
+                hideTyping();
+                addMessage('Maaf, terjadi kesalahan. Silakan coba lagi.');
+                console.error('Error:', error);
+            }
+        }
+
+        chatForm.addEventListener('submit', (e) => {
+            e.preventDefault();
+            const message = messageInput.value.trim();
+            if (message) {
+                sendMessage(message);
+            }
+        });
+
+        messageInput.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                const message = messageInput.value.trim();
+                if (message) {
+                    sendMessage(message);
+                }
+            }
+        });
+
+        // Focus input on load
+        messageInput.focus();
+    </script>
+</body>
+</html>

test_novita_simple.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Simple script untuk test koneksi Novita AI dengan endpoint yang benar
+"""
+
+import os
+import requests
+import json
+
+def test_novita_connection():
+    """Test koneksi ke Novita AI dengan endpoint yang benar"""
+    
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY tidak ditemukan")
+        return False
+    
+    print(f"🔑 API Key: {api_key[:10]}...{api_key[-10:]}")
+    print("🔍 Testing koneksi ke Novita AI...")
+    
+    # Use the correct endpoint
+    base_url = "https://api.novita.ai/openai"
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    try:
+        # Test models endpoint
+        print(f"🔍 Testing: {base_url}/models")
+        response = requests.get(f"{base_url}/models", headers=headers, timeout=10)
+        print(f"  Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            print("✅ Koneksi berhasil!")
+            models = response.json()
+            print(f"📋 Found {len(models.get('data', []))} models")
+            return True
+        else:
+            print(f"❌ Error: {response.status_code} - {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+def test_chat_completion():
+    """Test chat completion dengan model sederhana"""
+    
+    api_key = os.getenv('NOVITA_API_KEY')
+    if not api_key:
+        print("❌ NOVITA_API_KEY tidak ditemukan")
+        return False
+    
+    base_url = "https://api.novita.ai/openai"
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    # Test dengan model yang ringan
+    payload = {
+        "model": "meta-llama/llama-3.2-1b-instruct",
+        "messages": [
+            {"role": "user", "content": "Hello! How are you today?"}
+        ],
+        "max_tokens": 50,
+        "temperature": 0.7
+    }
+    
+    try:
+        print(f"🔍 Testing chat completion...")
+        response = requests.post(f"{base_url}/chat/completions", headers=headers, json=payload, timeout=30)
+        print(f"  Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Chat completion berhasil!")
+            print(f"📝 Response: {result.get('choices', [{}])[0].get('message', {}).get('content', 'No content')}")
+            return True
+        else:
+            print(f"❌ Error: {response.status_code} - {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+def main():
+    print("🚀 Novita AI Simple Test")
+    print("=" * 40)
+    
+    # Test connection
+    if test_novita_connection():
+        print("\n🎉 Koneksi berhasil! Sekarang test chat completion...")
+        
+        # Test chat completion
+        if test_chat_completion():
+            print("\n🎉 Semua test berhasil! Novita AI siap digunakan.")
+            print("\n📋 Next steps:")
+            print("1. Gunakan script novita_ai_setup_v2.py untuk fine-tuning")
+            print("2. Atau gunakan script test_model.py untuk testing")
+            print("3. Monitor usage di dashboard Novita AI")
+        else:
+            print("\n⚠️  Chat completion gagal, tapi koneksi OK")
+    else:
+        print("\n❌ Koneksi gagal. Cek API key dan endpoint")
+
+if __name__ == "__main__":
+    main()

web_app.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Web interface for Textilindo AI Chat
+"""
+
+from flask import Flask, render_template, request, jsonify
+import os
+import json
+import requests
+from difflib import SequenceMatcher
+
+app = Flask(__name__)
+
+class TextilindoAI:
+    def __init__(self, api_key):
+        self.api_key = api_key
+        self.base_url = "https://api.novita.ai/openai"
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        self.model = "qwen/qwen3-235b-a22b-instruct-2507"
+        self.dataset = self.load_dataset()
+        
+    def load_dataset(self):
+        """Load the training dataset"""
+        dataset = []
+        dataset_path = "data/textilindo_training_data.jsonl"
+        
+        if os.path.exists(dataset_path):
+            try:
+                with open(dataset_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line:
+                            data = json.loads(line)
+                            dataset.append(data)
+            except Exception as e:
+                print(f"Error loading dataset: {e}")
+        
+        return dataset
+    
+    def find_relevant_context(self, user_query, top_k=3):
+        """Find most relevant examples from dataset"""
+        if not self.dataset:
+            return []
+        
+        scores = []
+        for i, example in enumerate(self.dataset):
+            instruction = example.get('instruction', '').lower()
+            output = example.get('output', '').lower()
+            query = user_query.lower()
+            
+            instruction_score = SequenceMatcher(None, query, instruction).ratio()
+            output_score = SequenceMatcher(None, query, output).ratio()
+            combined_score = (instruction_score * 0.7) + (output_score * 0.3)
+            scores.append((combined_score, i))
+        
+        scores.sort(reverse=True)
+        relevant_examples = []
+        
+        for score, idx in scores[:top_k]:
+            if score > 0.1:
+                relevant_examples.append(self.dataset[idx])
+        
+        return relevant_examples
+    
+    def create_context_prompt(self, user_query, relevant_examples):
+        """Create a prompt with relevant context"""
+        if not relevant_examples:
+            return user_query
+        
+        context_parts = []
+        context_parts.append("Berikut adalah beberapa contoh pertanyaan dan jawaban tentang Textilindo:")
+        context_parts.append("")
+        
+        for i, example in enumerate(relevant_examples, 1):
+            instruction = example.get('instruction', '')
+            output = example.get('output', '')
+            context_parts.append(f"Contoh {i}:")
+            context_parts.append(f"Pertanyaan: {instruction}")
+            context_parts.append(f"Jawaban: {output}")
+            context_parts.append("")
+        
+        context_parts.append("Berdasarkan contoh di atas, jawab pertanyaan berikut:")
+        context_parts.append(f"Pertanyaan: {user_query}")
+        context_parts.append("Jawaban:")
+        
+        return "\n".join(context_parts)
+    
+    def chat(self, message):
+        """Send message to Novita AI with RAG context"""
+        relevant_examples = self.find_relevant_context(message, 3)
+        
+        if relevant_examples:
+            enhanced_prompt = self.create_context_prompt(message, relevant_examples)
+        else:
+            enhanced_prompt = message
+        
+        payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": enhanced_prompt}],
+            "max_tokens": 300,
+            "temperature": 0.7,
+            "top_p": 0.9
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/chat/completions", 
+                headers=self.headers, 
+                json=payload, 
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result.get('choices', [{}])[0].get('message', {}).get('content', '')
+            else:
+                return f"Error: {response.status_code}"
+                
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+# Initialize AI
+ai = TextilindoAI(os.getenv('NOVITA_API_KEY', ''))
+
+@app.route('/')
+def home():
+    return render_template('chat.html')
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    data = request.get_json()
+    message = data.get('message', '')
+    
+    if not message:
+        return jsonify({'response': 'Please enter a message'})
+    
+    response = ai.chat(message)
+    return jsonify({'response': response})
+
+@app.route('/stats')
+def stats():
+    if not ai.dataset:
+        return jsonify({'error': 'No dataset loaded'})
+    
+    topics = {}
+    for example in ai.dataset:
+        metadata = example.get('metadata', {})
+        topic = metadata.get('topic', 'unknown')
+        topics[topic] = topics.get(topic, 0) + 1
+    
+    return jsonify({
+        'total_examples': len(ai.dataset),
+        'topics': topics,
+        'model': ai.model
+    })
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)