Upload 26 files

Dockerfile

@@ -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,319 @@
+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
+from app.services.psych_service import psych_service
+from typing import List
+
+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/main.py (Bagian process_chat saja)
+
+@app.post("/chat/process", response_model=schemas.ChatResponse)
+async def process_chat(req: schemas.ChatRequest):
+    # 1. Ambil data role
+    role_data = skill_manager.get_role_data(req.role)
+    # --- [UPDATE BARU: Ektrak Silabus Lengkap] ---
+    # Kita buat string rapi berisi Skill + Topik-topiknya
+    syllabus_list = []
+    if role_data:
+        for s in role_data['sub_skills']:
+            # Ambil nama skill utama
+            skill_name = s['name']
+            
+            # Kumpulkan semua exam_topics dari level beginner, intermediate, advanced
+            all_topics = []
+            for lvl_key, lvl_data in s['levels'].items():
+                topics = lvl_data.get('exam_topics', [])
+                all_topics.extend(topics)
+            
+            # Hapus duplikat topik dan gabungkan jadi string
+            unique_topics = list(set(all_topics))
+            topic_str = ", ".join(unique_topics)
+            
+            syllabus_list.append(f"TOPIC {skill_name}: [{topic_str}]")
+    
+    # Variable ini yang nanti dikirim ke LLM
+    syllabus_context = "\n".join(syllabus_list)
+    # ---------------------------------------------
+    skill_names = [s['name'] for s in role_data['sub_skills']] if role_data else []
+
+    # 2. Router
+    intent = await llm_engine.process_user_intent(req.message, skill_names)
+    
+    action = intent.get('action')
+    # PERUBAHAN 1: Ambil List skills, bukan single skill
+    detected_skills_list = intent.get('detected_skills', [])
+    
+    final_reply = ""
+    response_data = None
+    
+    # 3. Logic
+    if action == "START_EXAM":
+        target_skill_ids = []
+        
+        # A. Cari ID untuk SEMUA skill yang dideteksi (Looping)
+        if detected_skills_list and role_data:
+            for ds in detected_skills_list:
+                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:
+                            target_skill_ids.append(s['id'])
+        
+        # B. Jika ada skill yang valid, generate soal untuk MASING-MASING skill
+        if target_skill_ids:
+            exam_list = []
+            
+            for skid in target_skill_ids:
+                # Ambil level user
+                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 (Sequential)
+                llm_res = await llm_engine.generate_question(level_data['exam_topics'], user_current_level)
+                
+                # Masukkan ke list soal
+                exam_list.append({
+                    "skill_id": skid,
+                    "skill_name": skill_details['name'],
+                    "level": user_current_level,
+                    "question": llm_res['question_text'],
+                    "context": llm_res['grading_rubric']
+                })
+            
+            # C. Format Response Baru (Multi-Exam)
+            response_data = {
+                "mode": "multiple_exams", # Penanda buat frontend
+                "exams": exam_list        # List soal ada di sini
+            }
+            
+            skill_display = ", ".join([x['skill_name'] for x in exam_list])
+            final_reply = f"Siap! Saya siapkan {len(exam_list)} ujian untukmu: **{skill_display}**. Silakan kerjakan satu per satu di bawah ini! 👇"
+            
+        else:
+            # Jika user mau ujian tapi skill ga jelas
+            action = "CASUAL_CHAT"
+            final_reply = await llm_engine.casual_chat(req.message, [m.dict() for m in req.history], syllabus_context)
+
+    elif action == "START_PSYCH_TEST":
+        response_data = {"trigger_psych_test": True}
+        final_reply = "Tenang, Mora punya tes kepribadian singkat untuk membantumu memilih job role antara **AI Engineer** atau **Front-End Developer**. Yuk coba sekarang! 👇"
+
+    elif action == "GET_RECOMMENDATION":
+        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], syllabus_context)
+
+    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
+
+# ==========================================
+# ENDPOINT PSIKOLOGI (JOB ROLE TEST)
+# ==========================================
+
+@app.get("/psych/questions", response_model=List[schemas.PsychQuestionItem])
+def get_psych_questions():
+    """Mengambil daftar soal tes kepribadian."""
+    return psych_service.get_all_questions()
+
+@app.post("/psych/submit", response_model=schemas.PsychResultResponse)
+async def submit_psych_test(req: schemas.PsychSubmitRequest):
+    """Menerima jawaban user, hitung skor, dan minta analisis LLM."""
+    
+    # 1. Hitung Skor secara matematis
+    result = psych_service.calculate_result(req.answers)
+    
+    winner = result["winner"]
+    scores = result["scores"]
+    traits = result["traits"]
+    
+    # 2. Minta LLM buatkan kata-kata mutiara/analisis
+    analysis_text = await llm_engine.analyze_psych_result(winner, traits)
+    
+    return schemas.PsychResultResponse(
+        suggested_role=winner,
+        analysis=analysis_text,
+        scores=scores
+    )

app/schemas.py

@@ -0,0 +1,105 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+# ==========================================
+# 1. CHAT & ROUTING SYSTEM
+# ==========================================
+
+class ChatMessage(BaseModel):
+    """Format pesan tunggal untuk riwayat chat (History)."""
+    role: str       # "user" atau "assistant"
+    content: str
+
+class ChatRequest(BaseModel):
+    """
+    Payload utama yang dikirim Frontend saat user chatting.
+    Backend butuh 'current_skills' dan 'role' karena Backend tidak punya Database.
+    """
+    message: str                        # Pesan user saat ini
+    role: str                           # Contoh: "AI Engineer"
+    history: List[ChatMessage] = []     # 5 pesan terakhir untuk konteks percakapan
+    current_skills: Dict[str, str] = {} # Contoh: {"python": "intermediate", "nlp": "beginner"}
+
+class ChatResponse(BaseModel):
+    """Balasan dari Backend ke Frontend."""
+    reply: str                          # Teks balasan bot
+    action_type: str                    # "START_EXAM", "GET_RECOMMENDATION", "CASUAL_CHAT", "START_PSYCH_TEST"
+    data: Optional[Dict[str, Any]] = None # Data tambahan (Soal ujian / List Rekomendasi)
+
+# ==========================================
+# 2. EXAM SYSTEM (UJIAN)
+# ==========================================
+
+class QuestionResponse(BaseModel):
+    """Output soal dari LLM."""
+    question_text: str
+    question_context: Dict[str, Any]    # Kunci jawaban/Rubrik (Frontend wajib simpan ini)
+    skill_id: str
+
+class AnswerSubmission(BaseModel):
+    """Payload saat user mengirim jawaban ujian."""
+    user_answer: str
+    question_context: Dict[str, Any]    # Kunci jawaban yang dikirim balik oleh Frontend
+
+class EvaluationResponse(BaseModel):
+    """Hasil penilaian AI Judge."""
+    is_correct: bool
+    score: int
+    feedback: str
+    passed: bool                        # True jika score >= 70
+    suggested_new_level: Optional[str] = None # Saran level baru (misal: "intermediate")
+
+# ==========================================
+# 3. RECOMMENDATION SYSTEM (ML POWERED)
+# ==========================================
+
+class SkillGap(BaseModel):
+    skill_name: str      # Contoh: "SQL"
+    target_level: str    # Contoh: "Pemula"
+
+class UserProfile(BaseModel):
+    name: str            # Contoh: "Siti Adaptive"
+    active_path: str     # Contoh: "Data Scientist"
+    missing_skills: List[SkillGap] # List of objects
+    completed_courses: List[int] = []
+
+class RecommendationItem(BaseModel):
+    skill: str
+    current_level: str
+    course_to_take: str
+    chapters: List[str]
+    match_score: float
+    badge: str
+# ==========================================
+# 4. PROGRESS SYSTEM
+# ==========================================
+
+class ProgressRequest(BaseModel):
+    """Request untuk hitung progress bar."""
+    role: str
+    current_skills: Dict[str, str]
+
+class ProgressItem(BaseModel):
+    """Format satu item progress skill."""
+    skill_name: str
+    current_level: str
+    progress_percent: int               # 0 - 100
+    remaining_tutorials: int
+
+# ==========================================
+# 5. PSYCH TEST SYSTEM (Fitur Baru)
+# ==========================================
+
+class PsychQuestionItem(BaseModel):
+    id: int
+    question: str
+    options: Dict[str, str] # {"A": "...", "B": "..."}
+
+class PsychSubmitRequest(BaseModel):
+    """Format jawaban yang dikirim user. Key = ID Soal, Value = Pilihan (A/B)"""
+    answers: Dict[int, str]  # Contoh: {1: "A", 2: "B", 3: "A", ...}
+
+class PsychResultResponse(BaseModel):
+    suggested_role: str
+    analysis: str            # Penjelasan dari LLM
+    scores: Dict[str, int]   # Skor detail (misal: AI=3, Frontend=2)

app/services/llm_engine.py

@@ -0,0 +1,221 @@
+import os
+import json
+from groq import AsyncGroq
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class LLMEngine:
+    def __init__(self):
+        self.api_key = os.getenv("GROQ_API_KEY")
+        if not self.api_key:
+            raise ValueError("GROQ_API_KEY not found in .env file")
+        
+        self.client = AsyncGroq(api_key=self.api_key)
+
+    async def process_user_intent(self, user_text: str, available_skills: list):
+        # Ubah list skill jadi string biar AI tau menu apa aja yang ada
+        skills_str = "\n".join([f"- {s}" for s in available_skills])
+        
+        system_prompt = f"""
+        ROLE: Kamu adalah 'Router' untuk MORA, sebuah AI Learning Assistant.
+        Tugasmu BUKAN menjawab pertanyaan, tapi mengarahkan user ke fitur yang benar.
+        
+        DAFTAR SKILL TERSEDIA DI DATABASE:
+        {skills_str}
+        
+        INSTRUKSI UTAMA:
+        Analisis pesan user dan tentukan ACTION JSON.
+        
+        1. ACTION: "START_EXAM"
+            - Trigger: User ingin "tes", "ujian", "uji kemampuan", "soal", atau menyebut topik teknis (SQL, Python, CV, NLP).
+            - TUGAS PENTING (MAPPING): User sering menyebut topik spesifik (misal "SQL"). Kamu WAJIB mencocokkannya dengan "Nama Skill Tersedia" yang paling relevan.
+                Contoh: 
+                - User: "Tes SQL" -> Detected: "Software & Data Foundations"
+                - User: "Tes Vision" -> Detected: "Deep Learning & Computer Vision"
+            
+        2. ACTION: "GET_RECOMMENDATION"
+            - Trigger: User minta "saran", "belajar apa", "rekomendasi", "bingung mulai mana".
+            
+        3. ACTION: "START_PSYCH_TEST"
+            - Trigger: User tanya "karir", "cocok kerja apa", "tes minat".
+            
+        4. ACTION: "CASUAL_CHAT"
+            - Trigger: Hanya untuk sapaan ("Halo"), curhat, atau pertanyaan di luar konteks belajar.
+            - JANGAN gunakan ini jika user jelas-jelas minta tes/soal.
+        
+        OUTPUT JSON (Hanya JSON, tanpa teks lain):
+        {{
+            "action": "...",
+            "detected_skills": ["Nama Skill Database 1", "Nama Skill Database 2"] (Array berisi String nama skill persis dari daftar diatas. Kosongkan jika tidak ada.)
+        }}
+        """
+        
+        try:
+            chat_completion = await self.client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_text}
+                ],
+                model="llama-3.3-70b-versatile", # Wajib model 70b biar pinter mapping
+                temperature=0.0, # Wajib 0 agar tidak kreatif/halu
+                response_format={"type": "json_object"}
+            )
+            
+            response_content = chat_completion.choices[0].message.content
+            print(f"DEBUG AI MAPPING: {response_content}") # Cek di terminal mappingnya bener gak
+            return json.loads(response_content)
+        except Exception as e:
+            print(f"Error Intent: {e}")
+            return {"action": "CASUAL_CHAT", "detected_skills": []}
+
+    async def generate_question(self, topics: list, level: str):
+        topics_str = ", ".join(topics)
+        prompt = f"""
+        Buatkan 1 soal esai pendek untuk menguji pemahaman user tentang topik: {topics_str}.
+        Tingkat Kesulitan: {level}.
+        Bahasa: Indonesia.
+        
+        Output JSON:
+        {{
+            "question_text": "Pertanyaan...",
+            "grading_rubric": {{
+                "keywords": ["kata1", "kata2"],
+                "explanation_focus": "Poin utama yang harus dijelaskan"
+            }}
+        }}
+        """
+        try:
+            completion = await self.client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                # UPDATE MODEL
+                model="llama-3.3-70b-versatile",
+                response_format={"type": "json_object"}
+            )
+            return json.loads(completion.choices[0].message.content)
+        except:
+            return None
+
+    async def evaluate_answer(self, user_answer: str, question_context: dict):
+        prompt = f"""
+        Bertindaklah sebagai Dosen AI yang menilai jawaban mahasiswa.
+        
+        Soal/Konteks: {json.dumps(question_context)}
+        Jawaban Mahasiswa: "{user_answer}"
+        
+        Tugas:
+        1. Beri skor 0-100.
+        2. Beri feedback singkat & ramah (Bahasa Indonesia).
+        3. Tentukan apakah jawaban BENAR secara konsep (is_correct).
+        
+        Output JSON:
+        {{
+            "score": 85,
+            "feedback": "Penjelasanmu bagus, tapi kurang detail di bagian...",
+            "is_correct": true
+        }}
+        """
+        try:
+            completion = await self.client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                # UPDATE MODEL
+                model="llama-3.3-70b-versatile",
+                response_format={"type": "json_object"}
+            )
+            return json.loads(completion.choices[0].message.content)
+        except:
+            return {"score": 0, "feedback": "Error menilai.", "is_correct": False}
+
+    async def casual_chat(self, user_text: str, history: list = [], syllabus_context: str = ""):
+        
+        prompt_template = f"""
+        [ROLE]
+        Namamu MORA. Kamu adalah Mentor & Asisten Teknis Spesialis.
+        
+        [PENGETAHUAN & SILABUS KAMU]
+        Kamu HANYA menguasai materi yang tertera di bawah ini. Gunakan daftar ini sebagai acuan validasi jawabanmu:
+        
+        {syllabus_context}
+
+        [TUGAS UTAMA]
+        1. **JAWAB PERTANYAAN TEKNIS:**
+            Jika user bertanya definisi atau konsep tentang topik yang ADA di silabus di atas (misal: "Apa itu List?", "Jelaskan Supervised Learning"), JAWABLAH dengan penjelasan konseptual yang singkat, padat, dan mudah dimengerti (maksimal 3-4 kalimat).
+            
+        2. **GAYA MENGAJAR:**
+            Gunakan analogi sederhana jika perlu. Jangan terlalu kaku seperti buku teks, tapi tetap akurat.
+            
+        3. **BATASAN (BLACK LIST):**
+            - Jika topik TIDAK ADA di silabus (misal: Hardware, IoT, Masak, Mobil, coding selain yang di sylabus), TOLAK dengan sopan dan pivot ke materi silabus.
+            - JANGAN BERIKAN KODE FULL. Jika user minta "Buatkan kodingan", arahkan mereka untuk mengambil Ujian/Tes. Kamu hanya menjelaskan *Konsep* dan *Logika*.
+            - Hindari jawaban yang terlalu panjang (lebih dari 4 kalimat).
+            - Jika tidak yakin, katakan "Maaf, itu di luar pengetahuan saya."
+            - Jangan buat-buat jawaban untuk topik di luar silabus.
+
+        [CONTOH INTERAKSI]
+        User: "Apa itu Supervised Learning?"
+        Mora: (Cek silabus... ada!) "Supervised Learning itu ibarat belajar dengan kunci jawaban. Model dilatih pakai data yang sudah ada labelnya, jadi dia tau mana yang benar dan salah. Contohnya kayak filter email spam!"
+        
+        User: "Gimana cara bikin robot?"
+        Mora: (Cek silabus... tidak ada!) "Waduh, itu ranah hardware/robotik, di luar silabusku. Tapi kalau kamu mau tau cara memprogram otak robotnya pakai Python (AI), aku bisa jelaskan logikanya!"
+
+        [PERSONALITY]
+        Ramah, Suportif, Emoji secukupnya.
+        """
+
+        system_msg = {
+            "role": "system", 
+            "content": prompt_template
+        }
+        
+        messages = [system_msg]
+        for msg in history[-5:]:
+            messages.append({"role": msg['role'], "content": msg['content']})
+        messages.append({"role": "user", "content": user_text})
+        
+        try:
+            completion = await self.client.chat.completions.create(
+                messages=messages,
+                model="llama-3.3-70b-versatile", 
+                temperature=0.3 
+            )
+            return completion.choices[0].message.content
+        except Exception as e:
+            return f"Maaf, otak saya sedang error. (Error: {str(e)})"
+        
+
+    async def analyze_psych_result(self, role: str, traits: list[str]):
+        """
+        Membuat penjelasan psikologis kenapa user cocok di role tersebut.
+        """
+        traits_str = "\n".join(traits)
+        
+        prompt = f"""
+        Kamu adalah Konsultan Karir IT yang ahli membaca kepribadian.
+        
+        DATA USER:
+        User baru saja mengikuti tes kepribadian sederhana.
+        Hasil kecocokan tertinggi: **{role}**.
+        Kebiasaan/Pilihan User:
+        {traits_str}
+        
+        TUGAS:
+        Berikan analisis singkat (maksimal 3 kalimat) dan memotivasi.
+        Jelaskan hubungan antara kebiasaan user di atas dengan job role {role}.
+        Gunakan gaya bahasa santai tapi meyakinkan.
+        
+        Contoh Output:
+        "Wah, kamu punya bakat alami jadi AI Engineer! Kebiasaanmu yang suka menganalisis fakta dan mencari review mendalam menunjukkan kamu punya pola pikir analitis yang kuat, modal penting buat ngolah data!"
+        """
+        
+        try:
+            chat_completion = self.client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model="llama-3.1-8b-instant",
+                temperature=0.7
+            )
+            return chat_completion.choices[0].message.content
+        except Exception as e:
+            return f"Berdasarkan jawabanmu, kamu sangat cocok menjadi {role}! Semangat belajar ya! 🚀"
+
+llm_engine = LLMEngine()

app/services/psych_service.py

@@ -0,0 +1,97 @@
+# app/services/psych_service.py
+from typing import Dict
+
+# 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",
+            "B": "Coret-coret atau menulis di buku"
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    },
+    {
+        "id": 2,
+        "question": "JJika sedang menghadapi masalah, cara mana yang paling mirip denganmu?",
+        "options": {
+            "A": "Cari tahu masalahnya dari berbagai macam sudut pandang",
+            "B": "Ngobrol dengan teman untuk mendapatkan ide baru"
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    },
+    {
+        "id": 3,
+        "question": "Kalau lagi bermain sosial media, mana aktivitas yang paling relate denganmu?",
+        "options": {
+            "A": "Stalking akun-akun yang suka share fakta-fakta seru",
+            "B": "Share-share postingan teman sambil comment"
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    },
+    {
+        "id": 4,
+        "question": "Nah, kalau lagi liburan, kegiatan mana yang paling bikin kamu excited?",
+        "options": {
+            "A": "Mencari review tempat yang akan dikunjungi",
+            "B": "Membuat konten blog atau vlog tentang petualangan liburan"
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    },
+    {
+        "id": 5,
+        "question": "Kalau lagi kerja bareng tim, mana peran yang paling mirip dengamu?",
+        "options": {
+            "A": "Jadi orang yang bantu tim ngambil keputusan dengan analisis situasi",
+            "B": "Jadi orang yang bikin presentasi buat menyampaikan ide-ide tim"
+        },
+        "role_mapping": {"A": "AI Engineer", "B": "Front-End Web Developer"}
+    }
+]
+
+class PsychService:
+    def get_all_questions(self):
+        """Mengembalikan soal tanpa kunci jawaban (untuk frontend)"""
+        return [
+            {
+                "id": q["id"],
+                "question": q["question"],
+                "options": q["options"]
+            }
+            for q in PSYCH_QUESTIONS
+        ]
+
+    def calculate_result(self, user_answers: Dict[int, str]):
+        """
+        Menghitung skor berdasarkan jawaban user.
+        user_answers contoh: {1: "A", 2: "B"}
+        """
+        scores = {"AI Engineer": 0, "Front-End Web Developer": 0}
+        
+        # Simpan trait kepribadian user untuk dikirim ke LLM nanti
+        user_traits = []
+
+        for q in PSYCH_QUESTIONS:
+            q_id = q["id"]
+            user_choice = user_answers.get(q_id) # "A" atau "B"
+            
+            if user_choice and user_choice in q["role_mapping"]:
+                # 1. Tambah Skor
+                role = q["role_mapping"][user_choice]
+                scores[role] += 1
+                
+                # 2. Catat trait (pilihan user) untuk konteks LLM
+                chosen_text = q["options"][user_choice]
+                user_traits.append(f"- Lebih suka: {chosen_text}")
+
+        # Tentukan Pemenang
+        winner_role = max(scores, key=scores.get)
+        
+        return {
+            "winner": winner_role,
+            "scores": scores,
+            "traits": user_traits
+        }
+
+psych_service = PsychService()

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