Upload 11 files

Dockerfiles

@@ -0,0 +1,28 @@
+# 1. Gunakan Python 3.9 (Versi paling stabil untuk Scikit-Learn & Pandas)
+FROM python:3.9
+
+# 2. Set folder kerja di dalam container (Virtual Computer)
+WORKDIR /code
+
+# 3. Copy file requirements.txt terlebih dahulu
+# (Tujuannya agar Docker bisa 'cache' proses install library, biar cepat kalau deploy ulang)
+COPY ./requirements.txt /code/requirements.txt
+
+# 4. Install library yang ada di requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# 5. Copy seluruh sisa file proyek (folder app, model_artifacts, main.py, dll) ke dalam container
+COPY . /code
+
+# 6. Atur izin (Permissions)
+# Hugging Face menjalankan aplikasi sebagai user 'non-root' (user ID 1000).
+# Kita harus memberi izin akses ke folder cache agar aplikasi tidak error saat menulis file sementara.
+RUN mkdir -p /code/cache
+RUN chmod -R 777 /code
+
+# Set Environment Variable untuk Cache (biar library ML gak bingung nyimpan cache dimana)
+ENV XDG_CACHE_HOME=/code/cache
+
+# 7. Perintah Menyalakan Server
+# PENTING: Hugging Face WAJIB menggunakan port 7860. Jangan diganti ke 8000.
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/data/Sub_skill.json

@@ -0,0 +1,751 @@
+[
+  {
+    "role_name": "AI Engineer",
+    "description": "Profesional yang membangun dan mengoptimalkan model AI.",
+    "sub_skills": [
+      {
+        "id": "python_data_science",
+        "name": "Python for Data Science",
+        "levels": {
+          "beginner": {
+            "description": "Memahami sintaks dasar Python dan struktur data.",
+            "exam_topics": [
+              "Variables",
+              "Data Types",
+              "List/Dictionary",
+              "Control Flow"
+            ],
+            "recommendation": {
+              "course_name": "Memulai Pemrograman dengan Python",
+              "specific_chapters": [
+                "Variable dan Assignment",
+                "Tipe Data",
+                "Kuis Coding: Variabel dan Assignment"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Mampu menggunakan fungsi, loop kompleks, dan OOP dasar.",
+            "exam_topics": [
+              "Functions",
+              "Loops",
+              "Object-Oriented Programming (OOP)"
+            ],
+            "recommendation": {
+              "course_name": "Memulai Pemrograman dengan Python",
+              "specific_chapters": [
+                "Fungsi",
+                "Perulangan",
+                "Pengenalan Kelas",
+                "Kuis Object-Oriented Programming (OOP)"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Menguasai library data, unit testing, dan style guide.",
+            "exam_topics": [
+              "Unit Testing",
+              "Matriks",
+              "Library Pengolahan Data"
+            ],
+            "recommendation": {
+              "course_name": "Memulai Pemrograman dengan Python",
+              "specific_chapters": [
+                "Pengantar Unit Testing",
+                "Implementasi Matriks pada Python",
+                "Library Machine Learning"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "ml_fundamentals",
+        "name": "Machine Learning Fundamentals",
+        "levels": {
+          "beginner": {
+            "description": "Paham konsep dasar AI, Machine Learning, dan Taksonomi.",
+            "exam_topics": [
+              "AI Taxonomy",
+              "Supervised vs Unsupervised",
+              "Data Splitting"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Dasar AI",
+              "specific_chapters": [
+                "Taksonomi AI",
+                "Tipe-Tipe Machine Learning",
+                "Machine Learning Workflow"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Mampu menangani regresi, klasifikasi, dan data cleaning.",
+            "exam_topics": [
+              "Linear Regression",
+              "Decision Tree",
+              "Handling Missing Value",
+              "Overfitting"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Machine Learning untuk Pemula",
+              "specific_chapters": [
+                "Rangkuman Supervised Learning - Regresi",
+                "Decision Tree",
+                "Penanganan Outlier",
+                "Metode Deteksi Overfitting dan Underfitting"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Menguasai unsupervised learning, tuning, dan evaluasi model kompleks.",
+            "exam_topics": [
+              "Clustering (K-Means/DBSCAN)",
+              "Hyperparameter Tuning (Grid Search)",
+              "Dimensionality Reduction (PCA)"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Machine Learning untuk Pemula",
+              "specific_chapters": [
+                "K-Means Clustering",
+                "DBSCAN",
+                "Grid Search",
+                "Dimensionality Reduction : LDA, PCA, dan t-SNE"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "computer_vision",
+        "name": "Computer Vision",
+        "levels": {
+          "beginner": {
+            "description": "Paham dasar CNN dan pengolahan citra sederhana.",
+            "exam_topics": [
+              "CNN Architecture",
+              "Convolutions",
+              "Pooling",
+              "Image Preprocessing"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Deep Learning",
+              "specific_chapters": [
+                "Dasar-Dasar Convolutional Neural Networks (CNNs)",
+                "Pembuatan Model Klasifikasi Gambar dengan CNN",
+                "Image Generation"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Mampu melakukan Transfer Learning dan Object Detection dasar.",
+            "exam_topics": [
+              "Transfer Learning",
+              "Object Detection Concepts",
+              "Dropout/Batch Normalization"
+            ],
+            "recommendation": {
+              "course_name": "Machine Learning Terapan",
+              "specific_chapters": [
+                "Pengenalan Transfer Learning",
+                "Pengenalan Object Detection",
+                "Teknik-teknik Object Detection"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Menguasai segmentasi gambar dan kustomisasi model visual.",
+            "exam_topics": [
+              "Image Segmentation",
+              "Advanced Object Detection",
+              "Custom Loss for Vision"
+            ],
+            "recommendation": {
+              "course_name": "Membangun Proyek Deep Learning Tingkat Mahir",
+              "specific_chapters": [
+                "Image Segmentation dengan Deep Learning",
+                "Klasifikasi Gambar Lanjutan",
+                "Berkenalan dengan Object Detection"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "nlp",
+        "name": "Natural Language Processing (NLP)",
+        "levels": {
+          "beginner": {
+            "description": "Dasar pemrosesan teks, tokenisasi, dan klasifikasi teks sederhana.",
+            "exam_topics": [
+              "Tokenization",
+              "Text Cleaning",
+              "Binary Classification"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Deep Learning",
+              "specific_chapters": [
+                "Pengenalan Natural Language Processing",
+                "Latihan Pra-pemrosesan Teks",
+                "Binary vs Multiclass vs Multilabel Classification pada Text"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Memahami RNN, LSTM, dan Analisis Sentimen.",
+            "exam_topics": [
+              "RNN",
+              "LSTM",
+              "Sentiment Analysis",
+              "Word Embeddings"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Deep Learning",
+              "specific_chapters": [
+                "Pengenalan Recurrent Neural Network",
+                "Algoritma RNN",
+                "Proyek Analisis Sentimen"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Menguasai Transformers, Attention Mechanism, dan NLU lanjutan.",
+            "exam_topics": [
+              "Transformers",
+              "Attention Mechanism",
+              "Sequence to Sequence",
+              "IndoNLU"
+            ],
+            "recommendation": {
+              "course_name": "Membangun Proyek Deep Learning Tingkat Mahir",
+              "specific_chapters": [
+                "Mengenal Transformer dalam NLP",
+                "Latihan Membangun Model Transformer Milik Kita Sendiri",
+                "Pengenalan IndoNLU"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "time_series",
+        "name": "Time Series Analysis",
+        "levels": {
+          "beginner": {
+            "description": "Konsep dasar data deret waktu dan preprocessing.",
+            "exam_topics": [
+              "Time Series Basics",
+              "Trend & Seasonality",
+              "Data Splitting for Time Series"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Deep Learning",
+              "specific_chapters": [
+                "Pengenalan Time Series",
+                "Data Preprocessing untuk Time Series",
+                "Tipe-Tipe Time Series"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Membuat model forecasting menggunakan LSTM.",
+            "exam_topics": [
+              "LSTM for Time Series",
+              "Windowing",
+              "MAE/Huber Loss"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Deep Learning",
+              "specific_chapters": [
+                "Machine Learning pada Time Series",
+                "Proyek Kedua : Membuat Model Machine Learning dengan Data Time Series"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Analisis Time Series tingkat lanjut dengan kustomisasi.",
+            "exam_topics": [
+              "Advanced Preprocessing",
+              "Custom Model for Time Series"
+            ],
+            "recommendation": {
+              "course_name": "Membangun Proyek Deep Learning Tingkat Mahir",
+              "specific_chapters": [
+                "Eksplorasi Data dalam Time Series",
+                "Data Preprocessing Lanjutan Untuk Time Series",
+                "Latihan Custom Model... pada Time Series Model"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "recommender_system",
+        "name": "Recommender Systems",
+        "levels": {
+          "beginner": {
+            "description": "Memahami konsep Content-Based Filtering.",
+            "exam_topics": [
+              "Content-Based Filtering",
+              "TF-IDF",
+              "Cosine Similarity"
+            ],
+            "recommendation": {
+              "course_name": "Machine Learning Terapan",
+              "specific_chapters": [
+                "Pengenalan Sistem Rekomendasi",
+                "Content Based Filtering",
+                "Feature Engineering dengan TF-IDF"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Memahami Collaborative Filtering.",
+            "exam_topics": [
+              "Collaborative Filtering",
+              "User-Item Matrix",
+              "Embedding Layers"
+            ],
+            "recommendation": {
+              "course_name": "Machine Learning Terapan",
+              "specific_chapters": [
+                "Collaborative Filtering",
+                "Model Development dengan Collaborative Filtering"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Sistem rekomendasi Hybrid dan Neural Collaborative Filtering.",
+            "exam_topics": [
+              "Hybrid Recommender",
+              "Neural Collaborative Filtering",
+              "TensorFlow Recommenders"
+            ],
+            "recommendation": {
+              "course_name": "Membangun Proyek Deep Learning Tingkat Mahir",
+              "specific_chapters": [
+                "Neural Collaborative Filtering",
+                "Retrieval dalam Sistem Rekomendasi",
+                "Hybrid Recommender System"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "mlops_deployment",
+        "name": "MLOps & Deployment",
+        "levels": {
+          "beginner": {
+            "description": "Menyimpan model dan penggunaan TF Lite.",
+            "exam_topics": ["Saving Models (H5/SavedModel)", "TF Lite Basics"],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Deep Learning",
+              "specific_chapters": [
+                "Format Penyimpanan Model",
+                "Pengenalan TensorFlow Lite",
+                "Latihan: Deploy Model ML Menggunakan TensorFlow Lite"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Deployment web (TFJS) dan Serving.",
+            "exam_topics": ["TensorFlow.js", "TF Serving", "Model Conversion"],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Deep Learning",
+              "specific_chapters": [
+                "Pengenalan TensorFlow.js",
+                "Pengenalan TensorFlow Serving",
+                "Latihan: Deploy Model ML Menggunakan TensorFlow.js"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Distributed training dan kustomisasi loop training.",
+            "exam_topics": [
+              "Distributed Training",
+              "Custom Training Loops",
+              "TensorFlow Extended (TFX) concepts"
+            ],
+            "recommendation": {
+              "course_name": "Membangun Proyek Deep Learning Tingkat Mahir",
+              "specific_chapters": [
+                "Strategi Distributed Training dengan TensorFlow",
+                "Custom Training Loop",
+                "Reproducibility dalam TensorFlow"
+              ]
+            }
+          }
+        }
+      }
+    ]
+  },
+  {
+    "role_name": "Front-End Web Developer",
+    "description": "Pengembang yang fokus pada antarmuka visual dan interaksi pengguna di browser.",
+    "sub_skills": [
+      {
+        "id": "html_css_fundamentals",
+        "name": "HTML & CSS Fundamentals",
+        "levels": {
+          "beginner": {
+            "description": "Struktur dasar HTML5 dan styling CSS dasar.",
+            "exam_topics": [
+              "Semantic HTML",
+              "Box Model",
+              "Selectors",
+              "Text Styling"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Dasar Pemrograman Web",
+              "specific_chapters": [
+                "Semantic HTML: Header, Footer, Main, dan Nav",
+                "Box Model",
+                "Selector Dasar"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Layouting modern dengan Flexbox dan Positioning.",
+            "exam_topics": [
+              "Flexbox",
+              "Positioning (Relative/Absolute)",
+              "Floats"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Dasar Pemrograman Web",
+              "specific_chapters": [
+                "Pengantar Flexbox",
+                "Positioning",
+                "Latihan: Implementasi Flexbox pada Halaman Profil"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Layout Grid kompleks dan Desain Responsif.",
+            "exam_topics": ["CSS Grid", "Media Queries", "Responsive Design"],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Front-End Web Development",
+              "specific_chapters": [
+                "Pengantar CSS Grid",
+                "Grid Container dan Grid Item",
+                "Media Query",
+                "Responsive Layout"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "javascript_core",
+        "name": "JavaScript Core Logic",
+        "levels": {
+          "beginner": {
+            "description": "Sintaks dasar JS, tipe data, dan logika dasar.",
+            "exam_topics": [
+              "Variables",
+              "Data Types",
+              "Operators",
+              "Functions"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Dasar Pemrograman JavaScript",
+              "specific_chapters": [
+                "Variabel",
+                "Tipe Data",
+                "Logika Operator dan If Else",
+                "Function"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Manipulasi struktur data dan OOP dasar.",
+            "exam_topics": ["Arrays", "Objects", "Map/Set", "Basic OOP"],
+            "recommendation": {
+              "course_name": "Belajar Dasar Pemrograman JavaScript",
+              "specific_chapters": [
+                "Menstrukturkan Data dengan Object",
+                "Array",
+                "Map",
+                "Pengenalan OOP"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Konsep ES6+, Functional Programming, dan Module.",
+            "exam_topics": [
+              "ES6 Modules",
+              "Arrow Functions",
+              "Higher Order Functions",
+              "Destructuring"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Dasar Pemrograman JavaScript",
+              "specific_chapters": [
+                "ES6 Module",
+                "Arrow Function",
+                "Destructuring Object & Array",
+                "Functional Programming"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "dom_events",
+        "name": "DOM Manipulation & Interactivity",
+        "levels": {
+          "beginner": {
+            "description": "Memilih elemen dan event dasar.",
+            "exam_topics": [
+              "getElementById/querySelector",
+              "Click Events",
+              "Basic DOM Manipulation"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Membuat Front-End Web untuk Pemula",
+              "specific_chapters": [
+                "Mencari DOM",
+                "Manipulasi Konten Melalui innerText",
+                "Menambahkan Event Handler"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Event bubbling, form handling, dan membuat elemen dinamis.",
+            "exam_topics": [
+              "Event Bubbling",
+              "Form Events",
+              "Creating Elements"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Membuat Front-End Web untuk Pemula",
+              "specific_chapters": [
+                "Event Bubbling dan Capturing",
+                "Form Event",
+                "Membuat Elemen HTML"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Web Storage (Local/Session) dan Custom Events.",
+            "exam_topics": [
+              "LocalStorage",
+              "SessionStorage",
+              "JSON Parsing",
+              "Custom Events"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Membuat Front-End Web untuk Pemula",
+              "specific_chapters": [
+                "Pengertian dan Fungsi Web Storage",
+                "Implementasi Web Storage",
+                "Custom Event"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "async_api",
+        "name": "Asynchronous & API",
+        "levels": {
+          "beginner": {
+            "description": "Konsep dasar Async dan Callback.",
+            "exam_topics": [
+              "Synchronous vs Asynchronous",
+              "Callbacks",
+              "setTimeout"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Dasar Pemrograman JavaScript",
+              "specific_chapters": [
+                "Apa Itu Asynchronous Process",
+                "Penanganan dengan Callback",
+                "setTimeout"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Promise dan Fetch API dasar.",
+            "exam_topics": ["Promise", "Fetch API Basics", "JSON Data"],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Front-End Web Development",
+              "specific_chapters": [
+                "Promise",
+                "Dasar Penggunaan Fetch",
+                "Mengonsumsi Data API"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Async/Await, Error Handling, dan Chaining.",
+            "exam_topics": [
+              "Async/Await",
+              "Try/Catch",
+              "Promise.all",
+              "Chaining"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Front-End Web Development",
+              "specific_chapters": [
+                "Sintaks Async/Await",
+                "Error Handling pada Async",
+                "Promise Berantai"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "web_components",
+        "name": "Front-End Architecture (Web Components)",
+        "levels": {
+          "beginner": {
+            "description": "Konsep dasar Custom Elements.",
+            "exam_topics": ["Custom Elements", "HTMLElement Class"],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Front-End Web Development",
+              "specific_chapters": [
+                "Apa Itu Web Component",
+                "Basic Custom Element"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Shadow DOM dan Template.",
+            "exam_topics": ["Shadow DOM", "Templates", "Encapsulation"],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Front-End Web Development",
+              "specific_chapters": [
+                "Pengantar Shadow DOM",
+                "Shadow DOM untuk Web Component"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Lifecycle Callbacks dan Slots.",
+            "exam_topics": [
+              "connectedCallback",
+              "attributeChangedCallback",
+              "Slots"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Fundamental Front-End Web Development",
+              "specific_chapters": [
+                "Siklus Hidup (Lifecycle)",
+                "Fleksibel dengan Slot Element"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "pwa_performance",
+        "name": "PWA & Performance Optimization",
+        "levels": {
+          "beginner": {
+            "description": "Dasar PWA dan Manifest.",
+            "exam_topics": ["Web App Manifest", "Service Worker Basics"],
+            "recommendation": {
+              "course_name": "Belajar Pengembangan Web Intermediate",
+              "specific_chapters": [
+                "Pengenalan Progressive Web Apps",
+                "Web App Manifest",
+                "Registrasi Service Worker"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Caching dan Workbox.",
+            "exam_topics": [
+              "Cache API",
+              "Workbox",
+              "Caching Strategies (StaleWhileRevalidate)"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Pengembangan Web Intermediate",
+              "specific_chapters": [
+                "Workbox Precaching",
+                "Caching Strategies",
+                "Latihan: Offline Capability dengan Workbox"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "Optimasi performa, Lazy Loading, dan Web Vitals.",
+            "exam_topics": [
+              "Image Optimization",
+              "Lazy Loading",
+              "Web Vitals (LCP, FID, CLS)",
+              "Bundle Analyzer"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Pengembangan Web Intermediate",
+              "specific_chapters": [
+                "Image Optimization",
+                "Menggunakan Lazy Loading Image",
+                "Web Vitals",
+                "Bundle Analyzer"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "id": "testing_automation",
+        "name": "Testing & Automation",
+        "levels": {
+          "beginner": {
+            "description": "Dasar pengujian manual dan konsep testing.",
+            "exam_topics": [
+              "Why Testing?",
+              "Manual vs Automated",
+              "Types of Testing"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Dasar Pemrograman JavaScript",
+              "specific_chapters": [
+                "Pengenalan JavaScript Testing",
+                "Pengujian Program"
+              ]
+            }
+          },
+          "intermediate": {
+            "description": "Unit Testing dan Integration Testing.",
+            "exam_topics": [
+              "Jest",
+              "Unit Testing",
+              "Integration Testing",
+              "TDD"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Pengembangan Web Intermediate",
+              "specific_chapters": [
+                "TDD Menggunakan Jest",
+                "Framework Automation Testing",
+                "Menulis Kode Pengujian"
+              ]
+            }
+          },
+          "advanced": {
+            "description": "E2E Testing dan CI/CD.",
+            "exam_topics": [
+              "End-to-End Testing",
+              "CI/CD Concepts",
+              "GitHub Actions"
+            ],
+            "recommendation": {
+              "course_name": "Belajar Pengembangan Web Intermediate",
+              "specific_chapters": [
+                "Kasus 5: End-to-End Testing",
+                "Pendahuluan Continuous Integration & Continuous Deployment",
+                "Latihan: Membuat CI Pipeline menggunakan GitHub Action"
+              ]
+            }
+          }
+        }
+      }
+    ]
+  }
+]

app/main.py

@@ -0,0 +1,256 @@
+from fastapi import FastAPI, HTTPException, Body
+from app import schemas
+from app.services.llm_engine import llm_engine
+from app.services.skill_manager import skill_manager
+import pandas as pd
+import pickle
+import ast
+import os
+from sklearn.metrics.pairwise import linear_kernel
+
+app = FastAPI(title="MORA - AI Learning Assistant (Final)")
+
+# --- GLOBAL MODELS STORE ---
+models = {
+    'df': None,
+    'tfidf': None,
+    'matrix': None
+}
+
+# --- 1. STARTUP: LOAD MODEL .PKL ---
+@app.on_event("startup")
+def load_models():
+    print("🔄 Loading Pre-trained Models...")
+    
+    # Menggunakan Absolute Path agar aman dijalankan dari mana saja
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    base_dir = os.path.dirname(current_dir)
+    artifacts_dir = os.path.join(base_dir, "model_artifacts")
+    
+    try:
+        with open(os.path.join(artifacts_dir, 'courses_df.pkl'), 'rb') as f:
+            models['df'] = pickle.load(f)
+        with open(os.path.join(artifacts_dir, 'tfidf_vectorizer.pkl'), 'rb') as f:
+            models['tfidf'] = pickle.load(f)
+        with open(os.path.join(artifacts_dir, 'tfidf_matrix.pkl'), 'rb') as f:
+            models['matrix'] = pickle.load(f)
+        print(f"✅ Models Loaded Successfully from: {artifacts_dir}")
+    except Exception as e:
+        print(f"❌ Error Loading Models: {e}")
+        print(f"👉 Pastikan folder 'model_artifacts' ada di: {base_dir}")
+
+# --- 2. ENDPOINT REKOMENDASI (ML POWERED) ---
+@app.post("/recommendations")
+def get_recommendations(user: schemas.UserProfile):
+    df = models.get('df')
+    tfidf = models.get('tfidf')
+    matrix = models.get('matrix')
+    
+    # Jika model belum siap, return kosong biar gak crash
+    if df is None: return []
+
+    # Mapping Level agar komputer mengerti urutan
+    LEVEL_MAP = {
+        'beginner': 1, 'dasar': 1, 'pemula': 1,
+        'intermediate': 2, 'menengah': 2,
+        'advanced': 3, 'mahir': 3, 'expert': 3, 'profesional': 3
+    }
+    
+    final_recs = []
+    # Set course yang sudah diambil agar tidak disarankan lagi
+    seen_courses = set(user.completed_courses)
+    
+    # --- LOGIKA CORE: Loop setiap 'Gap' Skill User ---
+    for gap in user.missing_skills:
+        skill_query = gap.skill_name
+        target_lvl_str = gap.target_level.lower()
+        target_lvl_num = LEVEL_MAP.get(target_lvl_str, 1) # Default 1 (Pemula)
+        
+        try:
+            # 1. Transform nama skill jadi vektor angka
+            vec = tfidf.transform([skill_query.lower()])
+            
+            # 2. Hitung kemiripan (Cosine Similarity)
+            scores = linear_kernel(vec, matrix).flatten()
+            
+            # 3. Ambil Top 15 kandidat
+            indices = scores.argsort()[:-15:-1]
+            
+            for idx in indices:
+                score = scores[idx]
+                # Filter awal: Skip jika kemiripan text terlalu rendah
+                if score < 0.1: continue
+                
+                course = df.iloc[idx]
+                c_id = int(course['course_id'])
+                
+                if c_id in seen_courses: continue
+                
+                # --- FILTER LEVEL (ADAPTIVE) ---
+                c_lvl_str = str(course['level_name']).lower()
+                c_lvl_num = LEVEL_MAP.get(c_lvl_str, 1)
+                
+                # Logic: Jangan kasih course yang levelnya DI ATAS target (kejauhan)
+                if c_lvl_num > target_lvl_num: continue
+                
+                # Logic Badge (Penanda)
+                if c_lvl_num == target_lvl_num:
+                    badge = "🎯 Target Pas"
+                else:
+                    badge = "↺ Review Dasar"
+
+                # Parse Tutorial List (karena di CSV formatnya string)
+                tuts = course['tutorial_list']
+                if isinstance(tuts, str):
+                    try: tuts = ast.literal_eval(tuts)
+                    except: tuts = []
+                
+                # Tambahkan ke hasil
+                final_recs.append({
+                    "skill": skill_query,
+                    "current_level": gap.target_level,
+                    "course_to_take": course['course_name'],
+                    "chapters": tuts[:3], # Ambil 3 bab pertama
+                    "match_score": round(score * 100, 1),
+                    "badge": badge
+                })
+                seen_courses.add(c_id)
+                
+        except Exception as e:
+            print(f"Error processing {skill_query}: {e}")
+            continue
+
+    # Urutkan berdasarkan skor kecocokan tertinggi
+    final_recs = sorted(final_recs, key=lambda x: x['match_score'], reverse=True)
+    
+    return final_recs[:5] # Kembalikan Top 5
+
+# --- 3. ENDPOINT CHAT ROUTER ---
+@app.post("/chat/process", response_model=schemas.ChatResponse)
+async def process_chat(req: schemas.ChatRequest):
+    # Ambil silabus skill berdasarkan role user untuk konteks AI
+    role_data = skill_manager.get_role_data(req.role)
+    skill_names = [s['name'] for s in role_data['sub_skills']] if role_data else []
+    
+    # Klasifikasi Niat User (Router LLM)
+    intent = await llm_engine.process_user_intent(req.message, skill_names)
+    
+    action = intent.get('action')
+
+    detected_skills = intent.get('detected_skills', []) 
+    
+    if action == "START_EXAM":
+        target_skill_ids = []
+        
+        # 1. Cari ID untuk SEMUA skill yang dideteksi
+        if detected_skills and role_data:
+            for ds in detected_skills:
+                for s in role_data['sub_skills']:
+                    # Cek kemiripan nama
+                    if s['name'].lower() in ds.lower() or ds.lower() in s['name'].lower():
+                        if s['id'] not in target_skill_ids: # Cegah duplikat
+                            target_skill_ids.append(s['id'])
+        
+        # 2. Generate Soal untuk SETIAP Skill ID yang ketemu
+        if target_skill_ids:
+            exam_questions_list = []
+            
+            for skid in target_skill_ids:
+                # Ambil level user untuk skill ini
+                user_current_level = req.current_skills.get(skid, "beginner")
+                skill_details = skill_manager.get_skill_details(req.role, skid)
+                level_data = skill_details['levels'].get(user_current_level, skill_details['levels']['beginner'])
+                
+                # Generate Soal via LLM (Tunggu satu-satu)
+                llm_res = await llm_engine.generate_question(level_data['exam_topics'], user_current_level)
+                
+                # Masukkan ke list
+                exam_questions_list.append({
+                    "skill_id": skid,
+                    "skill_name": skill_details['name'],
+                    "level": user_current_level,
+                    "question": llm_res['question_text'],
+                    "context": llm_res['grading_rubric']
+                })
+            
+            # 3. Kembalikan List Soal di dalam objek 'data'
+            response_data = {
+                "mode": "multiple_exams", # Penanda buat frontend
+                "exams": exam_questions_list
+            }
+            
+            # Buat kalimat sapaan dinamis
+            skill_names_str = ", ".join([x['skill_name'] for x in exam_questions_list])
+            final_reply = f"Siap! Saya menemukan {len(exam_questions_list)} topik: **{skill_names_str}**. Silakan kerjakan soal-soal berikut di bawah ini! 👇"
+
+        else:
+            # Fallback jika skill tidak dikenali
+            action = "CASUAL_CHAT"
+            final_reply = await llm_engine.casual_chat(req.message, [m.dict() for m in req.history])
+    elif action == "GET_RECOMMENDATION":
+        # Frontend yang harus lanjut memanggil endpoint /recommendations
+        response_data = {"trigger_recommendation": True}
+        final_reply = "Sedang menganalisis kebutuhan belajarmu..."
+
+    elif action == "CASUAL_CHAT":
+        final_reply = await llm_engine.casual_chat(req.message, [m.dict() for m in req.history])
+
+    return schemas.ChatResponse(
+        reply=final_reply,
+        action_type=action,
+        data=response_data
+    )
+
+
+@app.post("/exam/submit", response_model=schemas.EvaluationResponse)
+async def submit_exam(sub: schemas.AnswerSubmission):
+    evaluation = await llm_engine.evaluate_answer(
+        user_answer=sub.user_answer,
+        question_context={
+            "question_text": "REFER TO CONTEXT",
+            "grading_rubric": sub.question_context
+        }
+    )
+    
+    is_passed = evaluation['is_correct'] and evaluation['score'] >= 70
+    suggested_lvl = "intermediate" if is_passed else None # Logika sederhana
+    
+    return schemas.EvaluationResponse(
+        is_correct=evaluation['is_correct'],
+        score=evaluation['score'],
+        feedback=evaluation['feedback'],
+        passed=is_passed,
+        suggested_new_level=suggested_lvl
+    )
+
+# --- 5. ENDPOINT PROGRESS ---
+@app.post("/progress")
+def get_progress(req: schemas.ProgressRequest):
+    role_data = skill_manager.get_role_data(req.role)
+    if not role_data: return []
+    
+    progress_report = []
+    level_weight = {"beginner": 0, "intermediate": 1, "advanced": 2}
+
+    for skill in role_data['sub_skills']:
+        skill_id = skill['id']
+        user_level = req.current_skills.get(skill_id, "beginner")
+        
+        # Hitung Persen
+        current_stage = level_weight.get(user_level, 0)
+        percent = int((current_stage / 3) * 100)
+        if user_level == "beginner": percent = 5
+        elif user_level == "intermediate": percent = 50
+        elif user_level == "advanced": percent = 80
+        
+        # Sisa tutorial (dummy/static logic karena detail ada di rekomendasi)
+        remaining = 0 
+        
+        progress_report.append({
+            "skill_name": skill['name'],
+            "current_level": user_level,
+            "progress_percent": percent,
+            "remaining_tutorials": remaining
+        })
+        
+    return progress_report

app/services/llm_engine.py

@@ -0,0 +1,221 @@
+import os
+import json
+from groq import Groq
+from dotenv import load_dotenv
+
+# Load API Key
+load_dotenv()
+
+# Inisialisasi Client Groq
+client = Groq(
+    api_key=os.getenv("GROQ_API_KEY"),
+)
+
+# Model yang Anda pilih
+MODEL_NAME = "llama-3.3-70b-versatile"
+
+class LLMEngine:
+    
+# ... (kode inisialisasi client Groq tetap sama) ...
+
+    @staticmethod
+    async def process_user_intent(user_text: str, available_skills: list[str]):
+        skills_str = ", ".join(available_skills)
+        
+        system_prompt = f"""
+        ROLE: Klasifikator Niat (Intent Classifier).
+        SKILL TERSEDIA: {skills_str}
+        
+        TUGAS: 
+        1. Tentukan kategori aksi.
+        2. Deteksi SEMUA skill yang disebutkan user.
+        
+        OUTPUT JSON:
+        {{
+            "action": "START_EXAM" | "GET_RECOMMENDATION" | "CASUAL_CHAT",
+            "detected_skills": ["Skill A", "Skill B"] (List of strings, kosongkan jika tidak ada)
+        }}
+        """
+        
+        user_prompt = f'Input: "{user_text}"'
+        
+        try:
+            response = client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                model=MODEL_NAME,
+                temperature=0.1, # Sangat kaku
+                response_format={"type": "json_object"}
+            )
+            return json.loads(response.choices[0].message.content)
+        except Exception as e:
+            print(f"Error intent: {e}")
+            return {"action": "CASUAL_CHAT", "detected_skill": None}
+
+    @staticmethod
+    async def casual_chat(user_text: str):
+        """Untuk ngobrol santai jika tidak ada action khusus"""
+        system_prompt="""
+        ROLE: Kamu adalah asisten belajar bernama MORA.
+        
+        TUGAS:
+        1. Hanya jawab pertanyaan terkait belajar pemrograman, AI, dan web development.
+        
+        """
+        try:
+            response = client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": "Kamu adalah asisten belajar bernama MORA. Jawab ramah dan singkat."},
+                    {"role": "user", "content": user_text}
+                ],
+                model=MODEL_NAME,
+            )
+            return response.choices[0].message.content
+        except:
+            return "Maaf saya sedang error."
+            
+    # ... (Fungsi generate_question dan evaluate_answer biarkan tetap ada) ...
+
+    @staticmethod
+    async def generate_question(topics: list[str], level: str):
+        topics_str = ", ".join(topics)
+        
+        # System Prompt: Instruksi Dasar
+        system_prompt = f"""
+        ROLE: Kamu adalah Senior AI Engineer & Penguji Ujian Teknis.
+        TARGET LEVEL: {level}
+        TOPICS: {topics_str}
+        
+        TUGAS:
+        Buatlah SATU soal studi kasus integrasi (gabungan) untuk menguji pemahaman kandidat.
+        
+        INSTRUKSI KHUSUS:
+        1. Jangan menanyakan definisi. Buat skenario nyata.
+        2. Output HARUS dalam format JSON valid.
+        3. Pertanyaan hanya seputar What, How, Why
+        """
+        
+        # User Prompt: Trigger Generasi
+        user_prompt = """
+        Buatkan soal beserta rubrik penilaiannya sekarang.
+        
+        OUTPUT FORMAT (JSON):
+        {
+            "question_text": "Teks pertanyaan untuk user...",
+            "grading_rubric": {
+                "key_concept": "Konsep utama...",
+                "must_have_keywords": ["keyword1", "keyword2"],
+                "explanation_focus": "Fokus penjelasan..."
+            }
+        }
+        """
+        
+        try:
+            # Panggil API Groq
+            response = client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                model=MODEL_NAME,
+                temperature=0.7,
+                # FITUR PENTING: Memaksa output JSON
+                response_format={"type": "json_object"} 
+            )
+            
+            # Parse string JSON ke Dictionary Python
+            return json.loads(response.choices[0].message.content)
+            
+        except Exception as e:
+            print(f"Error generating question via Groq: {e}")
+            return None
+
+    @staticmethod
+    async def evaluate_answer(user_answer: str, question_context: dict):
+        rubric = question_context.get('grading_rubric')
+        question = question_context.get('question_text')
+        
+        system_prompt = f"""
+        ROLE: Kamu adalah Penilai Ujian (Grader) yang objektif.
+        
+        KONTEKS SOAL: "{question}"
+        
+        RUBRIK (KUNCI JAWABAN):
+        - Konsep: {rubric['key_concept']}
+        - Keyword Wajib: {rubric['must_have_keywords']}
+        - Fokus: {rubric['explanation_focus']}
+        
+        TUGAS:
+        Nilai jawaban user. Analisis maknanya secara semantik.
+        Output HARUS JSON.
+        """
+        
+        user_prompt = f"""
+        JAWABAN USER: "{user_answer}"
+        
+        Berikan penilaianmu dalam format JSON berikut:
+        {{
+            "is_correct": boolean,
+            "score": integer (0-100),
+            "feedback": "Penjelasan singkat (maks 2 kalimat) kenapa benar/salah",
+            "missing_concepts": ["list konsep yang kurang"]
+        }}
+        """
+        
+        try:
+            response = client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                model=MODEL_NAME,
+                temperature=0.5, # Lebih rendah agar penilaian konsisten
+                response_format={"type": "json_object"}
+            )
+            
+            return json.loads(response.choices[0].message.content)
+            
+        except Exception as e:
+            print(f"Error evaluating answer via Groq: {e}")
+            # Return nilai default agar tidak crash
+            return {"is_correct": False, "score": 0, "feedback": "Terjadi kesalahan sistem evaluasi.", "missing_concepts": []}
+        
+    @staticmethod
+    async def analyze_psych_answer(user_answer: str, question_data: dict):
+        """
+        Menentukan user condong ke Opsi A atau B berdasarkan ketikan mereka.
+        """
+        prompt = f"""
+        ROLE: Psikolog Penjurusan Karir IT.
+        
+        PERTANYAAN: "{question_data['question']}"
+        OPSI A: "{question_data['options']['A']}"
+        OPSI B: "{question_data['options']['B']}"
+        
+        JAWABAN USER: "{user_answer}"
+        
+        TUGAS:
+        Analisis jawaban user. Apakah makna kalimatnya lebih dekat ke Opsi A atau Opsi B?
+        
+        OUTPUT JSON:
+        {{
+            "choice": "A" | "B",
+            "reason": "Alasan singkat kenapa masuk kategori itu"
+        }}
+        """
+        
+        try:
+            response = client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model=MODEL_NAME,
+                temperature=0.1, # Harus tegas
+                response_format={"type": "json_object"}
+            )
+            return json.loads(response.choices[0].message.content)
+        except Exception as e:
+            return {"choice": "A", "reason": "Error, default ke A"}
+
+# Instance global
+llm_engine = LLMEngine()

app/services/psych_service.py

@@ -0,0 +1,37 @@
+# app/services/psych_service.py
+
+# Bank Soal Psikologis (Bisa ditambah nanti)
+PSYCH_QUESTIONS = [
+    {
+        "id": 1,
+        "question": "Mana kegiatan yang paling relate denganmu di pagi hari?",
+        "options": {
+            "A": "Baca atau lihat info viral dari berbagai sumber (Cari Pola/Data)",
+            "B": "Coret-coret ide atau menulis jurnal di buku (Visual/Desain)"
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    },
+    {
+        "id": 2,
+        "question": "Jika kamu melihat sebuah website yang jelek, apa yang pertama kali kamu pikirkan?",
+        "options": {
+            "A": "Ini fitur search-nya lambat banget, pasti database-nya berantakan.",
+            "B": "Ini warnanya nabrak banget, font-nya juga susah dibaca."
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    },
+    {
+        "id": 3,
+        "question": "Saat memecahkan masalah, gaya kamu lebih seperti apa?",
+        "options": {
+            "A": "Mengumpulkan banyak data dulu, baru menyimpulkan solusi.",
+            "B": "Mencoba menggambar sketsa solusi dulu, baru diperbaiki sambil jalan."
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    }
+]
+
+def get_psych_question(index: int):
+    if index < len(PSYCH_QUESTIONS):
+        return PSYCH_QUESTIONS[index]
+    return None

app/services/skill_manager.py

@@ -0,0 +1,34 @@
+import json
+import os
+
+# Lokasi file JSON
+JSON_PATH = os.path.join(os.path.dirname(__file__), "../data/Sub_skill.json")
+
+class SkillManager:
+    def __init__(self):
+        self.data = self._load_data()
+
+    def _load_data(self):
+        with open(JSON_PATH, 'r') as f:
+            return json.load(f)
+
+    def get_role_data(self, role_name: str):
+        """Mengambil data skill berdasarkan role (AI Engineer / Web Dev)"""
+        for role in self.data:
+            if role['role_name'].lower() == role_name.lower():
+                return role
+        return None
+
+    def get_skill_details(self, role_name: str, skill_id: str):
+        """Mengambil detail satu skill spesifik"""
+        role_data = self.get_role_data(role_name)
+        if not role_data:
+            return None
+        
+        for skill in role_data['sub_skills']:
+            if skill['id'] == skill_id:
+                return skill
+        return None
+
+# Instance global
+skill_manager = SkillManager()

model_artifacts/courses_df.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dbab867c7952fba0817085133a78cbb87ab5e624f590fda4b0e7931e65880f6a
+size 354601

model_artifacts/tfidf_matrix.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3a5539d76aedad5fa18b3147a84f2e274faf9b2959e403959549540b8618e47
+size 91324

model_artifacts/tfidf_vectorizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25e1a1a524f82d96889e5b40e18770ef48262dec554481bed15c5bcf1b939f98
+size 62435

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+pydantic
+groq
+python-dotenv
+pandas
+numpy
+scikit-learn==1.6.1