feat: complete module 1 language detection

.gitignore

@@ -0,0 +1,20 @@
+# Python environments and caches
+.venv/
+__pycache__/
+*.py[cod]
+.ipynb_checkpoints/
+
+# Local data generated from public datasets
+data/*.csv
+
+# Trained model artifacts
+src/models/*.pkl
+src/models/saved_emotion_model/
+src/models/saved_*/
+checkpoints/
+runs/
+
+# Local secrets and editor files
+.env
+*.log
+.vscode/

Fetch_Data.py

@@ -0,0 +1,10 @@
+import pandas as pd
+from datasets import load_dataset
+
+dataset = load_dataset("papluca/language-identification")
+
+dataset['train'].to_pandas().to_csv("data/lang_train.csv", index=False)
+dataset['validation'].to_pandas().to_csv("data/lang_val.csv", index=False)
+dataset['test'].to_pandas().to_csv("data/lang_test.csv", index=False)
+
+print("Data is ready")

README.md

@@ -0,0 +1,38 @@
+# RAG-Based Mental Health Support Chatbot
+
+This repository contains the module work for the NLP final project.
+
+## Module 1: Language Detection
+
+The language detector is implemented with traditional NLP:
+
+- Vectorizer: character-level TF-IDF with `char_wb` n-grams from 2 to 4 characters
+- Classifier: Multinomial Naive Bayes
+- Dataset: `papluca/language-identification`
+- Supported languages: Arabic, Bulgarian, German, Greek, English, Spanish, French, Hindi, Italian, Japanese, Dutch, Polish, Portuguese, Russian, Swahili, Thai, Turkish, Urdu, Vietnamese, Chinese
+
+### Train and Evaluate
+
+```bash
+.\.venv\Scripts\python.exe src\models\language_classifier.py
+```
+
+This trains the model, saves it to `src/models/saved_lang_model.pkl`, and writes reports to:
+
+```text
+reports/module_1_language_detection/
+```
+
+### Run the UI
+
+```bash
+.\.venv\Scripts\python.exe src\models\language_detector_ui.py
+```
+
+The UI returns the detected language, confidence, and whether the prediction passed the confidence threshold.
+
+### Install Dependencies
+
+```bash
+.\.venv\Scripts\python.exe -m pip install -r requirements.txt
+```

Requirements.md

@@ -0,0 +1,54 @@
+NLP Final Task 2026 
+RAG-Based Mental Health Support Chatbot 
+Introduction 
+This project requires designing and implementing a Retrieval-Augmented Generation (RAG) 
+based chatbot for a mental health support system. The chatbot must provide grounded, 
+empathetic, and context-aware responses to queries related to anxiety, depression, stress, 
+and crisis support. 
+The system integrates multiple NLP techniques into a single pipeline, where each component 
+plays a critical role in improving overall system performance. 
+Prerequisites 
+Before starting this project, complete the following course: 
+• Retrieval Augmented Generation (RAG) @ deeplearning.ai 
+ONLY the first 4 modules. 5th module is extra. 
+System Overview 
+The chatbot system is composed of multiple interconnected modules. Each module 
+contributes directly to the performance of the final system, making this a fully integrated, 
+end-to-end project rather than isolated tasks. 
+Project Modules 
+1) Language Detection 
+Build a multi-class classifier using Traditional NLP such as: Count Vectorizer or TF-IDF 
+Vectorizer. Train ML model to classify the language of the user’s question. This module is very 
+important for the entire system for searching right in the knowledgebase in addition to replying in 
+the same language and so on. 
+2) Emotion Classifier 
+Build a multi-class classifier using either Recurrent Neural Networks OR Transformers. Feel 
+free to choose as you like. Train model to classify emotion of the user’s question. This module is 
+very important for optimizing the final chatbot response depending on the user’s emotion to be 
+able to handle his different emotions. This is a key factor in the success of the system. 
+3) Intent Classifier 
+Build a multi-class classifier using either zero shot or few shot LLM prompting to classify the 
+intent of the user’s question. Intent is one of the following:  greeting, goodbye, gratitude, 
+asking_mental_health_question, out_of_scope.  This module is very important for routing the 
+entire system to the best route for answering. For example: - If the user is greeting, there is no need for RAG and answer directly. - If the user is asking a mental health question, you must use RAG to answer. 
+4) Q&A RAG 
+Build RAG pipeline using the mental health counseling dataset to answer the upcoming user’s 
+questions. Feel free to use the suitable framework you prefer or build from scratch, as you like. 
+You need to follow these components: - For vector database, use free cloud qdrant.  - For embeddings, use senetence transformer. - For LLM, use free groq account and gpt-oss-120b or gpt-oss-20b. 
+Datasets 
+1) Language Identification Dataset 
+2) Emotion Dataset 
+3) Mental Health Counseling Conversations 
+Guidelines 
+• You must use python. 
+• Choose the most suitable data pre-processing techniques. 
+• Use Flask or FastAPI or any suitable web framework to deploy the model locally. 
+Deliverables 
+• Four module-specific notebooks. 
+• Deployment scripts. 
+• Any additional files/documentation you need. 
+Notes 
+• In the assessment phase, you’ll be asked to run your models locally, furthermore, you’ll 
+be asked in any technical decision/implementation you’ve made, so be well prepared, 
+and avoid overcomplicated approaches you don’t fully grasp. 
+• Early submission doesn’t affect your grade, take your time. 

notebooks/module_1_language_detection.ipynb

@@ -0,0 +1,83 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Module 1: Language Detection\n",
+        "\n",
+        "This notebook documents the language detection module for the RAG-based mental health support chatbot. The goal is to classify the user question language so later modules can route retrieval and response generation correctly."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Approach\n",
+        "\n",
+        "- Use traditional NLP as required by the project brief.\n",
+        "- Extract character-level TF-IDF features because language identity is strongly reflected in scripts, accents, and short character patterns.\n",
+        "- Train a Multinomial Naive Bayes classifier because it is fast, explainable, and strong for sparse text features."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import sys\n",
+        "from pathlib import Path\n",
+        "\n",
+        "PROJECT_ROOT = Path.cwd().resolve().parent if Path.cwd().name == 'notebooks' else Path.cwd().resolve()\n",
+        "sys.path.append(str(PROJECT_ROOT / 'src' / 'models'))\n",
+        "\n",
+        "from language_classifier import LanguageDetector, DATA_DIR"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "detector = LanguageDetector()\n",
+        "results = detector.train(\n",
+        "    train_path=DATA_DIR / 'lang_train.csv',\n",
+        "    validation_path=DATA_DIR / 'lang_val.csv',\n",
+        "    test_path=DATA_DIR / 'lang_test.csv',\n",
+        ")\n",
+        "results['test']['accuracy']"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "samples = [\n",
+        "    'I feel anxious and need help.',\n",
+        "    'انا اشعر بالقلق واحتاج الى المساعدة.',\n",
+        "    \"Je me sens stresse aujourd'hui.\",\n",
+        "]\n",
+        "\n",
+        "for sample in samples:\n",
+        "    print(sample, '->', detector.predict_with_confidence(sample))"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "pygments_lexer": "ipython3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

reports/module_1_language_detection/metrics_summary.json

@@ -0,0 +1,38 @@
+{
+  "model": "Character n-gram TF-IDF + Multinomial Naive Bayes",
+  "vectorizer": {
+    "analyzer": "char_wb",
+    "ngram_range": [
+      2,
+      4
+    ],
+    "max_features": 50000,
+    "lowercase": true
+  },
+  "classifier": "MultinomialNB",
+  "confidence_threshold": 0.65,
+  "validation_accuracy": 0.9935,
+  "test_accuracy": 0.994,
+  "languages": {
+    "ar": "Arabic",
+    "bg": "Bulgarian",
+    "de": "German",
+    "el": "Greek",
+    "en": "English",
+    "es": "Spanish",
+    "fr": "French",
+    "hi": "Hindi",
+    "it": "Italian",
+    "ja": "Japanese",
+    "nl": "Dutch",
+    "pl": "Polish",
+    "pt": "Portuguese",
+    "ru": "Russian",
+    "sw": "Swahili",
+    "th": "Thai",
+    "tr": "Turkish",
+    "ur": "Urdu",
+    "vi": "Vietnamese",
+    "zh": "Chinese"
+  }
+}

reports/module_1_language_detection/test_classification_report.csv

@@ -0,0 +1,24 @@
+,precision,recall,f1-score,support
+ar,1.0,0.998,0.998998998998999,500.0
+bg,0.998003992015968,1.0,0.999000999000999,500.0
+de,1.0,1.0,1.0,500.0
+el,1.0,1.0,1.0,500.0
+en,0.984251968503937,1.0,0.9920634920634921,500.0
+es,0.9784735812133072,1.0,0.9891196834817013,500.0
+fr,0.9920634920634921,1.0,0.9960159362549801,500.0
+hi,1.0,0.968,0.983739837398374,500.0
+it,0.996,0.996,0.996,500.0
+ja,1.0,1.0,1.0,500.0
+nl,1.0,0.996,0.9979959919839679,500.0
+pl,1.0,0.99,0.9949748743718593,500.0
+pt,0.9979508196721312,0.974,0.9858299595141701,500.0
+ru,1.0,0.998,0.998998998998999,500.0
+sw,0.9397363465160076,0.998,0.967992240543162,500.0
+th,1.0,0.998,0.998998998998999,500.0
+tr,0.998003992015968,1.0,0.999000999000999,500.0
+ur,1.0,0.964,0.9816700610997964,500.0
+vi,1.0,1.0,1.0,500.0
+zh,1.0,1.0,1.0,500.0
+accuracy,0.994,0.994,0.994,0.994
+macro avg,0.9942242096000407,0.994,0.9940200535855249,10000.0
+weighted avg,0.9942242096000405,0.994,0.994020053585525,10000.0

reports/module_1_language_detection/test_classification_report.txt

@@ -0,0 +1,26 @@
+              precision    recall  f1-score   support
+
+          ar       1.00      1.00      1.00       500
+          bg       1.00      1.00      1.00       500
+          de       1.00      1.00      1.00       500
+          el       1.00      1.00      1.00       500
+          en       0.98      1.00      0.99       500
+          es       0.98      1.00      0.99       500
+          fr       0.99      1.00      1.00       500
+          hi       1.00      0.97      0.98       500
+          it       1.00      1.00      1.00       500
+          ja       1.00      1.00      1.00       500
+          nl       1.00      1.00      1.00       500
+          pl       1.00      0.99      0.99       500
+          pt       1.00      0.97      0.99       500
+          ru       1.00      1.00      1.00       500
+          sw       0.94      1.00      0.97       500
+          th       1.00      1.00      1.00       500
+          tr       1.00      1.00      1.00       500
+          ur       1.00      0.96      0.98       500
+          vi       1.00      1.00      1.00       500
+          zh       1.00      1.00      1.00       500
+
+    accuracy                           0.99     10000
+   macro avg       0.99      0.99      0.99     10000
+weighted avg       0.99      0.99      0.99     10000

reports/module_1_language_detection/test_confusion_matrix.csv

@@ -0,0 +1,21 @@
+,ar,bg,de,el,en,es,fr,hi,it,ja,nl,pl,pt,ru,sw,th,tr,ur,vi,zh
+ar,499,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+bg,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+de,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+el,0,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+en,0,0,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+es,0,0,0,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+fr,0,0,0,0,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0
+hi,0,0,0,0,1,0,0,484,0,0,0,0,0,0,15,0,0,0,0,0
+it,0,0,0,0,1,1,0,0,498,0,0,0,0,0,0,0,0,0,0,0
+ja,0,0,0,0,0,0,0,0,0,500,0,0,0,0,0,0,0,0,0,0
+nl,0,0,0,0,2,0,0,0,0,0,498,0,0,0,0,0,0,0,0,0
+pl,0,0,0,0,1,0,1,0,1,0,0,495,1,0,1,0,0,0,0,0
+pt,0,0,0,0,1,10,2,0,0,0,0,0,487,0,0,0,0,0,0,0
+ru,0,1,0,0,0,0,0,0,0,0,0,0,0,499,0,0,0,0,0,0
+sw,0,0,0,0,0,0,0,0,1,0,0,0,0,0,499,0,0,0,0,0
+th,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,499,0,0,0,0
+tr,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,500,0,0,0
+ur,0,0,0,0,1,0,0,0,0,0,0,0,0,0,16,0,1,482,0,0
+vi,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,500,0
+zh,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,500

reports/module_1_language_detection/validation_classification_report.csv

@@ -0,0 +1,24 @@
+,precision,recall,f1-score,support
+ar,1.0,0.994,0.9969909729187563,500.0
+bg,0.9960159362549801,1.0,0.998003992015968,500.0
+de,0.998,0.998,0.998,500.0
+el,1.0,1.0,1.0,500.0
+en,0.9803921568627451,1.0,0.9900990099009901,500.0
+es,0.9881188118811881,0.998,0.9930348258706467,500.0
+fr,0.9940357852882704,1.0,0.9970089730807578,500.0
+hi,1.0,0.952,0.9754098360655737,500.0
+it,0.9900793650793651,0.998,0.9940239043824701,500.0
+ja,0.998,0.998,0.998,500.0
+nl,0.9940357852882704,1.0,0.9970089730807578,500.0
+pl,1.0,0.996,0.9979959919839679,500.0
+pt,0.9979674796747967,0.982,0.9899193548387096,500.0
+ru,1.0,0.996,0.9979959919839679,500.0
+sw,0.9416195856873822,1.0,0.9699321047526673,500.0
+th,1.0,0.998,0.998998998998999,500.0
+tr,0.9960159362549801,1.0,0.998003992015968,500.0
+ur,1.0,0.968,0.983739837398374,500.0
+vi,1.0,1.0,1.0,500.0
+zh,1.0,0.992,0.9959839357429718,500.0
+accuracy,0.9935,0.9935,0.9935,0.9935
+macro avg,0.9937140421135989,0.9935,0.9935075347515774,10000.0
+weighted avg,0.9937140421135989,0.9935,0.9935075347515773,10000.0

reports/module_1_language_detection/validation_classification_report.txt

@@ -0,0 +1,26 @@
+              precision    recall  f1-score   support
+
+          ar       1.00      0.99      1.00       500
+          bg       1.00      1.00      1.00       500
+          de       1.00      1.00      1.00       500
+          el       1.00      1.00      1.00       500
+          en       0.98      1.00      0.99       500
+          es       0.99      1.00      0.99       500
+          fr       0.99      1.00      1.00       500
+          hi       1.00      0.95      0.98       500
+          it       0.99      1.00      0.99       500
+          ja       1.00      1.00      1.00       500
+          nl       0.99      1.00      1.00       500
+          pl       1.00      1.00      1.00       500
+          pt       1.00      0.98      0.99       500
+          ru       1.00      1.00      1.00       500
+          sw       0.94      1.00      0.97       500
+          th       1.00      1.00      1.00       500
+          tr       1.00      1.00      1.00       500
+          ur       1.00      0.97      0.98       500
+          vi       1.00      1.00      1.00       500
+          zh       1.00      0.99      1.00       500
+
+    accuracy                           0.99     10000
+   macro avg       0.99      0.99      0.99     10000
+weighted avg       0.99      0.99      0.99     10000

reports/module_1_language_detection/validation_confusion_matrix.csv

@@ -0,0 +1,21 @@
+,ar,bg,de,el,en,es,fr,hi,it,ja,nl,pl,pt,ru,sw,th,tr,ur,vi,zh
+ar,497,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+bg,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+de,0,0,499,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0
+el,0,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+en,0,0,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+es,0,0,0,0,0,499,0,0,1,0,0,0,0,0,0,0,0,0,0,0
+fr,0,0,0,0,0,0,500,0,0,0,0,0,0,0,0,0,0,0,0,0
+hi,0,0,0,0,1,0,0,476,0,0,3,0,0,0,18,0,2,0,0,0
+it,0,0,0,0,1,0,0,0,499,0,0,0,0,0,0,0,0,0,0,0
+ja,0,0,0,0,0,0,0,0,1,499,0,0,0,0,0,0,0,0,0,0
+nl,0,0,0,0,0,0,0,0,0,0,500,0,0,0,0,0,0,0,0,0
+pl,0,0,0,0,1,0,0,0,1,0,0,498,0,0,0,0,0,0,0,0
+pt,0,0,0,0,1,6,0,0,2,0,0,0,491,0,0,0,0,0,0,0
+ru,0,2,0,0,0,0,0,0,0,0,0,0,0,498,0,0,0,0,0,0
+sw,0,0,0,0,0,0,0,0,0,0,0,0,0,0,500,0,0,0,0,0
+th,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,499,0,0,0,0
+tr,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,500,0,0,0
+ur,0,0,0,0,2,0,1,0,0,0,0,0,0,0,13,0,0,484,0,0
+vi,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,500,0
+zh,0,0,1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,496

requirements.txt

@@ -0,0 +1,6 @@
+pandas==3.0.3
+scikit-learn==1.9.0
+joblib==1.5.3
+gradio==6.18.0
+datasets==5.0.0
+jupyter

src/models/language_classifier.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+import joblib
+import pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.pipeline import Pipeline
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+DATA_DIR = PROJECT_ROOT / "data"
+MODEL_DIR = PROJECT_ROOT / "src" / "models"
+REPORTS_DIR = PROJECT_ROOT / "reports" / "module_1_language_detection"
+DEFAULT_MODEL_PATH = MODEL_DIR / "saved_lang_model.pkl"
+
+LANGUAGE_NAMES = {
+    "ar": "Arabic",
+    "bg": "Bulgarian",
+    "de": "German",
+    "el": "Greek",
+    "en": "English",
+    "es": "Spanish",
+    "fr": "French",
+    "hi": "Hindi",
+    "it": "Italian",
+    "ja": "Japanese",
+    "nl": "Dutch",
+    "pl": "Polish",
+    "pt": "Portuguese",
+    "ru": "Russian",
+    "sw": "Swahili",
+    "th": "Thai",
+    "tr": "Turkish",
+    "ur": "Urdu",
+    "vi": "Vietnamese",
+    "zh": "Chinese",
+}
+
+
+class LanguageDetector:
+    """Traditional NLP language detector using character TF-IDF and Naive Bayes."""
+
+    def __init__(
+        self,
+        model_path: str | Path = DEFAULT_MODEL_PATH,
+        confidence_threshold: float = 0.65,
+    ) -> None:
+        self.model_path = Path(model_path)
+        self.confidence_threshold = confidence_threshold
+        self.pipeline = self._build_pipeline()
+
+    @staticmethod
+    def _build_pipeline() -> Pipeline:
+        return Pipeline(
+            [
+                (
+                    "tfidf",
+                    TfidfVectorizer(
+                        analyzer="char_wb",
+                        ngram_range=(2, 4),
+                        max_features=50000,
+                        lowercase=True,
+                    ),
+                ),
+                ("clf", MultinomialNB()),
+            ]
+        )
+
+    @staticmethod
+    def _load_dataset(path: str | Path) -> pd.DataFrame:
+        df = pd.read_csv(path)
+        required_columns = {"text", "labels"}
+        missing_columns = required_columns.difference(df.columns)
+
+        if missing_columns:
+            raise ValueError(f"{path} is missing columns: {sorted(missing_columns)}")
+
+        df = df.dropna(subset=["text", "labels"]).copy()
+        df["text"] = df["text"].astype(str).str.strip()
+        df = df[df["text"] != ""]
+        return df
+
+    def train(
+        self,
+        train_path: str | Path = DATA_DIR / "lang_train.csv",
+        validation_path: str | Path = DATA_DIR / "lang_val.csv",
+        test_path: str | Path = DATA_DIR / "lang_test.csv",
+    ) -> dict[str, Any]:
+        train_df = self._load_dataset(train_path)
+        validation_df = self._load_dataset(validation_path)
+        test_df = self._load_dataset(test_path)
+
+        print("Training character n-gram TF-IDF language detector...")
+        self.pipeline.fit(train_df["text"], train_df["labels"])
+
+        validation_metrics = self.evaluate(validation_df, "validation")
+        test_metrics = self.evaluate(test_df, "test")
+
+        self.save_model()
+        self.save_reports(validation_metrics, test_metrics)
+
+        return {
+            "validation": validation_metrics,
+            "test": test_metrics,
+            "model_path": str(self.model_path),
+        }
+
+    def evaluate(self, df: pd.DataFrame, split_name: str) -> dict[str, Any]:
+        predictions = self.pipeline.predict(df["text"])
+        labels = sorted(df["labels"].unique())
+        report_dict = classification_report(
+            df["labels"],
+            predictions,
+            labels=labels,
+            output_dict=True,
+            zero_division=0,
+        )
+        report_text = classification_report(
+            df["labels"],
+            predictions,
+            labels=labels,
+            zero_division=0,
+        )
+        matrix = confusion_matrix(df["labels"], predictions, labels=labels)
+
+        accuracy = accuracy_score(df["labels"], predictions)
+        print(f"{split_name.title()} accuracy: {accuracy * 100:.2f}%")
+
+        return {
+            "split": split_name,
+            "accuracy": accuracy,
+            "labels": labels,
+            "classification_report": report_dict,
+            "classification_report_text": report_text,
+            "confusion_matrix": matrix.tolist(),
+        }
+
+    def save_model(self) -> None:
+        self.model_path.parent.mkdir(parents=True, exist_ok=True)
+        joblib.dump(self.pipeline, self.model_path)
+        print(f"Saved model to {self.model_path}")
+
+    def save_reports(self, validation_metrics: dict[str, Any], test_metrics: dict[str, Any]) -> None:
+        REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+        summary = {
+            "model": "Character n-gram TF-IDF + Multinomial Naive Bayes",
+            "vectorizer": {
+                "analyzer": "char_wb",
+                "ngram_range": [2, 4],
+                "max_features": 50000,
+                "lowercase": True,
+            },
+            "classifier": "MultinomialNB",
+            "confidence_threshold": self.confidence_threshold,
+            "validation_accuracy": validation_metrics["accuracy"],
+            "test_accuracy": test_metrics["accuracy"],
+            "languages": LANGUAGE_NAMES,
+        }
+
+        (REPORTS_DIR / "metrics_summary.json").write_text(
+            json.dumps(summary, indent=2),
+            encoding="utf-8",
+        )
+
+        for metrics in (validation_metrics, test_metrics):
+            split = metrics["split"]
+            labels = metrics["labels"]
+
+            (REPORTS_DIR / f"{split}_classification_report.txt").write_text(
+                metrics["classification_report_text"],
+                encoding="utf-8",
+            )
+
+            pd.DataFrame(metrics["classification_report"]).transpose().to_csv(
+                REPORTS_DIR / f"{split}_classification_report.csv",
+                encoding="utf-8",
+            )
+
+            pd.DataFrame(
+                metrics["confusion_matrix"],
+                index=labels,
+                columns=labels,
+            ).to_csv(REPORTS_DIR / f"{split}_confusion_matrix.csv", encoding="utf-8")
+
+        print(f"Saved evaluation reports to {REPORTS_DIR}")
+
+    def load_model(self) -> None:
+        if not self.model_path.exists():
+            raise FileNotFoundError(
+                f"Model not found at {self.model_path}. Run training first."
+            )
+        self.pipeline = joblib.load(self.model_path)
+
+    def predict(self, text: str) -> str:
+        return self.predict_with_confidence(text)["language_code"]
+
+    def predict_with_confidence(self, text: str) -> dict[str, Any]:
+        clean_text = text.strip()
+        if len(clean_text) < 3:
+            return {
+                "language_code": "unknown",
+                "language_name": "Unknown",
+                "confidence": 0.0,
+                "is_confident": False,
+                "message": "Please enter at least 3 characters.",
+            }
+
+        probabilities = self.pipeline.predict_proba([clean_text])[0]
+        best_index = int(probabilities.argmax())
+        language_code = str(self.pipeline.classes_[best_index])
+        confidence = float(probabilities[best_index])
+
+        return {
+            "language_code": language_code,
+            "language_name": LANGUAGE_NAMES.get(language_code, language_code.upper()),
+            "confidence": confidence,
+            "is_confident": confidence >= self.confidence_threshold,
+            "message": None,
+        }
+
+
+def _configure_console() -> None:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Train and evaluate Module 1 language detector.")
+    parser.add_argument("--train-path", default=DATA_DIR / "lang_train.csv", type=Path)
+    parser.add_argument("--validation-path", default=DATA_DIR / "lang_val.csv", type=Path)
+    parser.add_argument("--test-path", default=DATA_DIR / "lang_test.csv", type=Path)
+    parser.add_argument("--model-path", default=DEFAULT_MODEL_PATH, type=Path)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    _configure_console()
+    args = parse_args()
+
+    detector = LanguageDetector(model_path=args.model_path)
+    results = detector.train(args.train_path, args.validation_path, args.test_path)
+
+    sample_texts = [
+        "I feel anxious and need someone to talk to.",
+        "أنا أشعر بالقلق وأحتاج إلى المساعدة.",
+        "Je me sens stresse aujourd'hui.",
+    ]
+
+    print("\nSample predictions:")
+    for sample in sample_texts:
+        prediction = detector.predict_with_confidence(sample)
+        print(
+            f"- {sample!r} -> {prediction['language_name']} "
+            f"({prediction['confidence'] * 100:.1f}%)"
+        )
+
+    print(f"\nFinal test accuracy: {results['test']['accuracy'] * 100:.2f}%")

src/models/language_detector_ui.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+
+import gradio as gr
+
+from language_classifier import DEFAULT_MODEL_PATH, LanguageDetector
+
+
+MODEL_PATH = Path(DEFAULT_MODEL_PATH)
+detector = LanguageDetector(model_path=MODEL_PATH)
+detector.load_model()
+
+
+def predict_language(text: str) -> dict[str, str | float]:
+    prediction = detector.predict_with_confidence(text or "")
+
+    if prediction["message"]:
+        return {
+            "language": prediction["language_name"],
+            "confidence": prediction["confidence"],
+            "status": prediction["message"],
+        }
+
+    status = "Confident" if prediction["is_confident"] else "Uncertain"
+    return {
+        "language": prediction["language_name"],
+        "confidence": round(prediction["confidence"], 4),
+        "status": status,
+    }
+
+
+interface = gr.Interface(
+    fn=predict_language,
+    inputs=gr.Textbox(
+        lines=5,
+        placeholder="Type a question in any supported language...",
+        label="User Question",
+    ),
+    outputs=gr.JSON(label="Detection Result"),
+    title="Module 1: Language Detection",
+    description="Character n-gram TF-IDF language classifier for routing chatbot queries.",
+    flagging_mode="never",
+)
+
+
+if __name__ == "__main__":
+    interface.launch()

src/models/test_ui.py

@@ -0,0 +1,5 @@
+from language_detector_ui import interface, predict_language
+
+
+if __name__ == "__main__":
+    interface.launch()