Upload 7 files

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

adi.py

@@ -0,0 +1,247 @@
+# =====================================================================================================
+# Anti-Dump Algorithm (ADI)
+# Copyright 2008 - 2025 S. Volkan Kücükbudak
+# Apache License V2 + ESOL 1.1
+# https://github.com/VolkanSah/Anti-Dump-Index
+# =====================================================================================================
+
+from dataclasses import dataclass
+from typing import List, Dict, Tuple, Optional
+import re
+import numpy as np
+import json
+from pathlib import Path
+
+@dataclass
+class InputMetrics:
+    noise: float
+    effort: float
+    context: float
+    details: float
+    bonus_factors: float
+    penalty_factors: float
+    repetition_penalty: float = 0.0
+
+class DumpindexAnalyzer:
+    def __init__(self, weights: Dict[str, float] = None, enable_logging: bool = False):
+        self.weights = weights or {
+            'noise': 1.0,
+            'effort': 2.0,
+            'context': 1.5,
+            'details': 1.5,
+            'bonus': 0.5,
+            'penalty': 1.0
+        }
+        self.enable_logging = enable_logging
+        self.log_file = Path('adi_logs.jsonl')
+
+        self.noise_patterns = {
+            'urgency': r'\b(urgent|asap|emergency|!!+|\?\?+)\b',
+            'informal': r'\b(pls|plz|thx|omg|wtf)\b',
+            'vague': r'\b(something|somehow|maybe|probably)\b'
+        }
+        self.detail_patterns = {
+            'code_elements': r'\b(function|class|method|variable|array|object|def|return)\b',
+            'technical_terms': r'\b(error|exception|bug|issue|crash|fail|traceback|stack)\b',
+            'specifics': r'[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*'
+        }
+        self.context_indicators = {
+            'background': r'\b(because|since|as|when|while)\b',
+            'environment': r'\b(using|version|environment|platform|system)\b',
+            'goal': r'\b(trying to|want to|need to|goal is|attempting to)\b'
+        }
+
+    def _has_negation_before(self, text: str, match_pos: int, window_size: int = 50) -> bool:
+        window_start = max(0, match_pos - window_size)
+        window = text[window_start:match_pos].lower()
+        return bool(re.search(r'\b(no|not|never|without|dont|don\'t|doesnt|doesn\'t)\b', window))
+
+    def calculate_repetition_penalty(self, text: str) -> float:
+        words = text.lower().split()
+        if len(words) == 0:
+            return 0.0
+        unique_ratio = len(set(words)) / len(words)
+        word_counts = {}
+        for word in words:
+            if len(word) > 3:
+                word_counts[word] = word_counts.get(word, 0) + 1
+        max_repetition = max(word_counts.values()) if word_counts else 1
+        repetition_factor = min(max_repetition / len(words), 0.5)
+        penalty = (1 - unique_ratio) * 2 + repetition_factor * 2
+        return min(penalty, 3.0)
+
+    def calculate_noise(self, text: str) -> Tuple[float, Dict]:
+        noise_count = 0
+        noise_details = {}
+        for category, pattern in self.noise_patterns.items():
+            matches = re.findall(pattern, text.lower())
+            noise_count += len(matches)
+            noise_details[category] = matches
+        total_words = len(text.split())
+        return (noise_count / max(total_words, 1), noise_details)
+
+    def calculate_effort(self, text: str) -> float:
+        sentences = [s.strip() for s in re.split(r'[.!?]+', text) if s.strip()]
+        if not sentences:
+            return 0.0
+        avg_sentence_length = np.mean([len(s.split()) for s in sentences])
+        has_formatting = bool(re.search(r'```|\*\*|\n\s*\n', text))
+        has_punctuation = bool(re.search(r'[.,;:]', text))
+        sentence_quality = (
+            (len(sentences) >= 3) * 1.0 +
+            (20 <= avg_sentence_length <= 50) * 2.0 +
+            (avg_sentence_length >= 5) * 0.5
+        )
+        return min(5.0, sentence_quality + has_formatting * 1.5 + has_punctuation * 1.5)
+
+    def calculate_context(self, text: str) -> float:
+        context_score = 0.0
+        for category, pattern in self.context_indicators.items():
+            for match in re.finditer(pattern, text.lower()):
+                if not self._has_negation_before(text, match.start()):
+                    context_score += 1.0
+                    break
+        return min(5.0, context_score)
+
+    def calculate_details(self, text: str) -> Tuple[float, Dict]:
+        detail_score = 0.0
+        detail_findings = {}
+        for category, pattern in self.detail_patterns.items():
+            matches = re.findall(pattern, text.lower())
+            score = len(matches) * 0.5
+            detail_findings[category] = matches
+            detail_score += score
+        return (min(5.0, detail_score), detail_findings)
+
+    def calculate_bonus_factors(self, text: str) -> float:
+        bonus_score = 0.0
+        if re.search(r'```[\s\S]*?```', text):
+            bonus_score += 1.0
+        if re.search(r'\[.*?\]\(.*?\)', text):
+            bonus_score += 0.5
+        if re.search(r'\n\s*[-*+]\s', text):
+            bonus_score += 0.5
+        return bonus_score
+
+    def calculate_penalty_factors(self, text: str) -> Tuple[float, Dict]:
+        penalties = {}
+        alpha_chars = re.findall(r'[a-zA-Z]', text)
+        if alpha_chars:
+            caps_ratio = len(re.findall(r'[A-Z]', text)) / len(alpha_chars)
+            if caps_ratio > 0.7:
+                penalties['excessive_caps'] = caps_ratio
+        excessive_punctuation = len(re.findall(r'[!?]{2,}', text))
+        if excessive_punctuation:
+            penalties['excessive_punctuation'] = excessive_punctuation
+        if len(text.split()) < 10:
+            penalties['too_short'] = 1.0
+        penalty_score = sum(penalties.values()) if penalties else 0
+        return (min(5.0, penalty_score), penalties)
+
+    def calculate_adi(self, metrics: InputMetrics) -> float:
+        try:
+            numerator = (
+                self.weights['noise'] * metrics.noise -
+                (self.weights['effort'] * metrics.effort +
+                 self.weights['bonus'] * metrics.bonus_factors)
+            )
+            denominator = (
+                self.weights['context'] * metrics.context +
+                self.weights['details'] * metrics.details +
+                self.weights['penalty'] * metrics.penalty_factors +
+                metrics.repetition_penalty
+            )
+            return numerator / max(denominator, 0.1)
+        except Exception as e:
+            return float('inf')
+
+    def analyze_input(self, text: str, user_context: Optional[Dict] = None) -> Dict:
+        noise_value, noise_details = self.calculate_noise(text)
+        effort_value = self.calculate_effort(text)
+        context_value = self.calculate_context(text)
+        details_value, detail_findings = self.calculate_details(text)
+        bonus_value = self.calculate_bonus_factors(text)
+        penalty_value, penalty_details = self.calculate_penalty_factors(text)
+        repetition_value = self.calculate_repetition_penalty(text)
+
+        metrics = InputMetrics(
+            noise=noise_value, effort=effort_value, context=context_value,
+            details=details_value, bonus_factors=bonus_value,
+            penalty_factors=penalty_value, repetition_penalty=repetition_value
+        )
+        adi = self.calculate_adi(metrics)
+
+        adi_adjusted = adi
+        if user_context:
+            if user_context.get('tier') == 'enterprise':
+                adi_adjusted *= 0.8
+            if user_context.get('history_avg', 0) < 0:
+                adi_adjusted *= 0.9
+
+        decision = self._make_decision(adi_adjusted)
+        recommendations = self._generate_recommendations(
+            metrics, noise_details, detail_findings, penalty_details
+        )
+
+        return {
+            'adi': round(adi, 3),
+            'adi_adjusted': round(adi_adjusted, 3) if user_context else None,
+            'metrics': {
+                'noise': round(noise_value, 3), 'effort': round(effort_value, 3),
+                'context': round(context_value, 3), 'details': round(details_value, 3),
+                'bonus_factors': round(bonus_value, 3), 'penalty_factors': round(penalty_value, 3),
+                'repetition_penalty': round(repetition_value, 3)
+            },
+            'decision': decision,
+            'recommendations': recommendations,
+            'details': {
+                'noise_findings': noise_details,
+                'technical_details': detail_findings,
+                'penalties': penalty_details
+            }
+        }
+
+    def _make_decision(self, adi: float) -> str:
+        if adi > 1:
+            return "REJECT"
+        elif 0 <= adi <= 1:
+            return "MEDIUM_PRIORITY"
+        else:
+            return "HIGH_PRIORITY"
+
+    def _generate_recommendations(self, metrics, noise_details, detail_findings, penalty_details):
+        recommendations = []
+        if metrics.noise > 0.3:
+            recommendations.append("Reduce informal or urgent expressions.")
+        if metrics.context < 1.0:
+            recommendations.append("Provide more context (environment, background, goal).")
+        if metrics.details < 1.0:
+            recommendations.append("Include specific technical details or error messages.")
+        if metrics.effort < 2.0:
+            recommendations.append("Improve the structure of your input with proper sentences.")
+        if metrics.repetition_penalty > 1.0:
+            recommendations.append("Avoid repeating the same keywords excessively.")
+        if metrics.penalty_factors > 0:
+            if 'excessive_caps' in penalty_details:
+                recommendations.append("Avoid excessive capitalization.")
+            if 'excessive_punctuation' in penalty_details:
+                recommendations.append("Reduce excessive punctuation marks.")
+            if 'too_short' in penalty_details:
+                recommendations.append("Provide a more detailed description (minimum 10 words).")
+        if not recommendations:
+            recommendations.append("Your input quality is excellent. No improvements needed.")
+        return recommendations
+
+    def _log_analysis(self, text: str, adi: float, metrics: InputMetrics):
+        log_entry = {
+            'text_hash': hash(text), 'text_length': len(text), 'adi': round(adi, 3),
+            'metrics': {
+                'noise': round(metrics.noise, 3), 'effort': round(metrics.effort, 3),
+                'context': round(metrics.context, 3), 'details': round(metrics.details, 3),
+                'bonus_factors': round(metrics.bonus_factors, 3),
+                'penalty_factors': round(metrics.penalty_factors, 3),
+                'repetition_penalty': round(metrics.repetition_penalty, 3)
+            }
+        }
+        with open(self.log_file, 'a') as f:
+            f.write(json.dumps(log_entry) + '\n')

main.py

@@ -0,0 +1,198 @@
+# =============================================================================
+# main.py
+# FastAPI — OpenAI-compatible /v1/chat/completions endpoint
+# SmolLM2 Service Space
+# Copyright 2026 - Volkan Kücükbudak
+# Apache License V2 + ESOL 1.1
+# =============================================================================
+# Hub connects via:
+#   base_url = "https://codey-lab-smollm-service.hf.space/v1"
+#   → POST /v1/chat/completions  (OpenAI-compatible)
+#   → GET  /v1/health            (status check)
+# =============================================================================
+
+import logging
+import time
+import uuid
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from typing import List, Optional
+
+import smollm
+import model as model_module
+from adi import DumpindexAnalyzer
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+logger = logging.getLogger("main")
+
+# ── ADI ───────────────────────────────────────────────────────────────────────
+adi_analyzer = DumpindexAnalyzer(enable_logging=False)
+
+
+# ── Startup ───────────────────────────────────────────────────────────────────
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("=== SmolLM2 Service starting ===")
+    logger.info(f"Model config: {model_module.status()}")
+    smollm.load()  # preload model on startup
+    yield
+    logger.info("=== SmolLM2 Service stopped ===")
+
+app = FastAPI(title="SmolLM2 Service", version="1.0.0", lifespan=lifespan)
+
+
+# =============================================================================
+# Request / Response Models (OpenAI-compatible)
+# =============================================================================
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    model:       Optional[str] = "smollm2-360m"
+    messages:    List[Message]
+    max_tokens:  Optional[int] = 150
+    temperature: Optional[float] = 0.2
+    stream:      Optional[bool] = False
+
+class ChatCompletionResponse(BaseModel):
+    id:      str
+    object:  str = "chat.completion"
+    created: int
+    model:   str
+    choices: List[dict]
+    adi:     Optional[dict] = None  # ADI result attached to response
+
+
+# =============================================================================
+# Routes
+# =============================================================================
+
+@app.get("/")
+async def root():
+    return {
+        "service": "SmolLM2 Service",
+        "model":   smollm.device_info(),
+        "ready":   smollm.is_ready(),
+        "docs":    "/docs",
+    }
+
+
+@app.get("/v1/health")
+async def health():
+    return {
+        "status":  "ok" if smollm.is_ready() else "loading",
+        "device":  smollm.device_info(),
+        "model":   model_module.status(),
+    }
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(req: ChatCompletionRequest):
+    if not req.messages:
+        raise HTTPException(status_code=400, detail="messages cannot be empty")
+
+    # ── Extract prompt + system prompt ────────────────────────────────────────
+    system_prompt = ""
+    user_prompt   = ""
+
+    for msg in req.messages:
+        if msg.role == "system":
+            system_prompt = msg.content
+        elif msg.role == "user":
+            user_prompt = msg.content
+
+    if not user_prompt:
+        raise HTTPException(status_code=400, detail="No user message found")
+
+    # ── ADI Analysis ──────────────────────────────────────────────────────────
+    adi_result = adi_analyzer.analyze_input(user_prompt)
+    decision   = adi_result["decision"]
+    logger.info(f"ADI | decision: {decision} | score: {adi_result['adi']}")
+
+    # ── Route by ADI decision ─────────────────────────────────────────────────
+    if decision == "REJECT":
+        logger.info("ADI → REJECT: returning rejection response")
+        response_text = (
+            "Your request needs more detail before I can help. "
+            "Suggestions: " + " | ".join(adi_result["recommendations"])
+        )
+        # Log to dataset
+        model_module.push_log({
+            "prompt":        user_prompt,
+            "system_prompt": system_prompt,
+            "adi_score":     adi_result["adi"],
+            "adi_decision":  decision,
+            "adi_metrics":   adi_result["metrics"],
+            "response":      None,
+            "routed_to":     "REJECT",
+            "model":         req.model,
+        })
+        return _build_response(req.model, response_text, adi_result)
+
+    # ── SmolLM2 Inference ─────────────────────────────────────────────────────
+    try:
+        response_text = await smollm.complete(
+            prompt=user_prompt,
+            system_prompt=system_prompt,
+            max_tokens=req.max_tokens,
+            temperature=req.temperature,
+        )
+        routed_to = "smollm2"
+        logger.info(f"SmolLM2 response ok | decision: {decision}")
+
+    except Exception as e:
+        logger.warning(f"SmolLM2 failed: {type(e).__name__} — triggering hub fallback")
+        # Return 503 so hub's fallback chain kicks in
+        raise HTTPException(
+            status_code=503,
+            detail={
+                "error":        "smollm_unavailable",
+                "adi_decision": decision,
+                "message":      "Route to next provider in fallback chain",
+            }
+        )
+
+    # ── Log to Dataset ────────────────────────────────────────────────────────
+    model_module.push_log({
+        "prompt":        user_prompt,
+        "system_prompt": system_prompt,
+        "adi_score":     adi_result["adi"],
+        "adi_decision":  decision,
+        "adi_metrics":   adi_result["metrics"],
+        "response":      response_text,
+        "routed_to":     routed_to,
+        "model":         req.model,
+    })
+
+    return _build_response(req.model, response_text, adi_result)
+
+
+# =============================================================================
+# Helpers
+# =============================================================================
+
+def _build_response(model: str, content: str, adi_result: dict) -> dict:
+    return {
+        "id":      f"smollm-{uuid.uuid4().hex[:8]}",
+        "object":  "chat.completion",
+        "created": int(time.time()),
+        "model":   model,
+        "choices": [{
+            "index":         0,
+            "message":       {"role": "assistant", "content": content},
+            "finish_reason": "stop",
+        }],
+        "adi": {
+            "score":    adi_result["adi"],
+            "decision": adi_result["decision"],
+            "metrics":  adi_result["metrics"],
+        }
+    }

model.py

@@ -0,0 +1,179 @@
+# =============================================================================
+# model.py
+# HuggingFace Model + Dataset Access Layer
+# SmolLM2 Service Space
+# Copyright 2026 - Volkan Kücükbudak
+# Apache License V2 + ESOL 1.1
+# =============================================================================
+# Handles:
+#   - Model loading (SmolLM2 from HF or private repo)
+#   - Dataset read/write (private HF dataset)
+#   - Token resolution (HF_TOKEN → TEST_TOKEN → None)
+# =============================================================================
+
+import os
+import logging
+from datetime import datetime
+from typing import Optional
+from huggingface_hub import HfApi, login
+from datasets import load_dataset, Dataset
+
+logger = logging.getLogger("model")
+
+# ── Token Resolution ──────────────────────────────────────────────────────────
+TOKEN = (
+    os.environ.get("HF_TOKEN") or
+    os.environ.get("TEST_TOKEN") or
+    os.environ.get("HUGGINGFACE_TOKEN") or
+    os.environ.get("HF_API_TOKEN") or
+    None
+)
+
+# ── Config from ENV ───────────────────────────────────────────────────────────
+MODEL_REPO    = os.environ.get("MODEL_REPO", "HuggingFaceTB/SmolLM2-360M-Instruct")
+DATASET_REPO  = os.environ.get("DATASET_REPO", "codey-lab/data.universal-mcp-hub")
+PRIVATE_MODEL = os.environ.get("PRIVATE_MODEL_REPO", "codey-lab/model.universal-mcp-hub")
+
+# ── HF API ────────────────────────────────────────────────────────────────────
+_api: Optional[HfApi] = None
+
+def get_api() -> Optional[HfApi]:
+    """Returns authenticated HfApi instance or None if no token."""
+    global _api
+    if _api is None and TOKEN:
+        try:
+            login(token=TOKEN, add_to_git_credential=False)
+            _api = HfApi(token=TOKEN)
+            logger.info("HF API authenticated")
+        except Exception as e:
+            logger.warning(f"HF API auth failed: {type(e).__name__} — running unauthenticated")
+    return _api
+
+
+# =============================================================================
+# Model Access
+# =============================================================================
+
+def get_model_id() -> str:
+    """
+    Returns model ID to load.
+    Prefers private fine-tuned model if available, falls back to base model.
+    """
+    api = get_api()
+    if api and PRIVATE_MODEL:
+        try:
+            api.model_info(PRIVATE_MODEL, token=TOKEN)
+            logger.info(f"Using private model: {PRIVATE_MODEL}")
+            return PRIVATE_MODEL
+        except Exception:
+            logger.info(f"Private model not ready — using base: {MODEL_REPO}")
+    return MODEL_REPO
+
+
+def get_model_kwargs() -> dict:
+    """Returns kwargs for from_pretrained() calls."""
+    kwargs = {}
+    if TOKEN:
+        kwargs["token"] = TOKEN
+    return kwargs
+
+
+# =============================================================================
+# Dataset Access
+# =============================================================================
+
+def load_logs() -> list:
+    """
+    Load existing log entries from HF Dataset.
+    Returns empty list if dataset doesn't exist yet.
+    """
+    if not TOKEN:
+        logger.warning("No token — dataset read skipped")
+        return []
+    try:
+        ds = load_dataset(DATASET_REPO, split="train", token=TOKEN)
+        return ds.to_list()
+    except Exception as e:
+        logger.info(f"Dataset load: {type(e).__name__} — starting fresh")
+        return []
+
+
+def push_log(entry: dict) -> bool:
+    """
+    Append a log entry to HF Dataset and push.
+    
+    Args:
+        entry: dict with prompt, adi, response, model, timestamp etc.
+    
+    Returns:
+        True on success, False on failure.
+    """
+    if not TOKEN:
+        logger.warning("No token — dataset push skipped")
+        return False
+    try:
+        existing = load_logs()
+        entry["timestamp"] = datetime.utcnow().isoformat()
+        existing.append(entry)
+        ds = Dataset.from_list(existing)
+        ds.push_to_hub(DATASET_REPO, token=TOKEN, private=True)
+        logger.info(f"Dataset updated — total entries: {len(existing)}")
+        return True
+    except Exception as e:
+        logger.warning(f"Dataset push failed: {type(e).__name__}: {e}")
+        return False
+
+
+def push_model_card(info: dict) -> bool:
+    """
+    Update model card / metadata in private model repo.
+    Useful for tracking which weights/config is deployed.
+    """
+    api = get_api()
+    if not api:
+        return False
+    try:
+        content = f"""---
+language: en
+license: apache-2.0
+base_model: {MODEL_REPO}
+---
+
+# SmolLM2 Service
+
+Base: `{MODEL_REPO}`  
+Dataset: `{DATASET_REPO}`  
+Last updated: {datetime.utcnow().isoformat()}
+
+## Config
+```json
+{info}
+```
+"""
+        api.upload_file(
+            path_or_fileobj=content.encode(),
+            path_in_repo="README.md",
+            repo_id=PRIVATE_MODEL,
+            repo_type="model",
+            token=TOKEN,
+        )
+        logger.info(f"Model card updated: {PRIVATE_MODEL}")
+        return True
+    except Exception as e:
+        logger.warning(f"Model card update failed: {type(e).__name__}: {e}")
+        return False
+
+
+# =============================================================================
+# Health
+# =============================================================================
+
+def status() -> dict:
+    """Returns model/dataset config status for health endpoint."""
+    return {
+        "token":         "set" if TOKEN else "missing",
+        "model_repo":    MODEL_REPO,
+        "private_model": PRIVATE_MODEL,
+        "dataset_repo":  DATASET_REPO,
+        "hf_api":        "authenticated" if get_api() else "unauthenticated",
+    }

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.115.0
+uvicorn==0.30.6
+transformers==4.46.0
+torch==2.4.1
+accelerate==0.34.2
+numpy==1.26.4
+huggingface_hub==0.25.0
+datasets==3.0.1
+pydantic==2.9.2
+httpx==0.27.2

smollm.py

@@ -0,0 +1,88 @@
+# =============================================================================
+# smollm.py
+# SmolLM2 Inference Engine
+# SmolLM2 Service Space
+# Copyright 2026 - Volkan Kücükbudak
+# Apache License V2 + ESOL 1.1
+# =============================================================================
+
+import logging
+import torch
+from typing import Optional
+import model as model_module
+
+logger = logging.getLogger("smollm")
+
+_tokenizer = None
+_model     = None
+_device    = None
+
+
+def load():
+    """Lazy model loader — called on first request."""
+    global _tokenizer, _model, _device
+
+    if _model is not None:
+        return
+
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    model_id = model_module.get_model_id()
+    kwargs   = model_module.get_model_kwargs()
+    _device  = "cuda" if torch.cuda.is_available() else "cpu"
+
+    logger.info(f"Loading {model_id} on {_device}...")
+    _tokenizer = AutoTokenizer.from_pretrained(model_id, **kwargs)
+    _model     = AutoModelForCausalLM.from_pretrained(model_id, **kwargs).to(_device)
+    logger.info(f"Model ready [{_device}]")
+
+    # Update model card on startup
+    model_module.push_model_card({
+        "model_id": model_id,
+        "device": _device,
+    })
+
+
+async def complete(
+    prompt: str,
+    system_prompt: str = "",
+    max_tokens: int = 150,
+    temperature: float = 0.2,
+) -> str:
+    """
+    Run SmolLM2 inference.
+
+    Returns:
+        Generated text string.
+    Raises:
+        RuntimeError on inference failure.
+    """
+    load()
+
+    messages = []
+    if system_prompt.strip():
+        messages.append({"role": "system", "content": system_prompt})
+    messages.append({"role": "user", "content": prompt})
+
+    text   = _tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = _tokenizer.encode(text, return_tensors="pt").to(_device)
+
+    with torch.no_grad():
+        outputs = _model.generate(
+            inputs,
+            max_new_tokens=max_tokens,
+            temperature=temperature if temperature > 0 else None,
+            do_sample=temperature > 0,
+            top_p=0.9 if temperature > 0 else None,
+            pad_token_id=_tokenizer.eos_token_id,
+        )
+
+    new_tokens = outputs[0][inputs.shape[-1]:]
+    return _tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+
+
+def is_ready() -> bool:
+    return _model is not None
+
+def device_info() -> str:
+    return _device or "not loaded"

train.py

@@ -0,0 +1,152 @@
+# =============================================================================
+# train.py
+# Dataset Preparation + Finetuning Entry Point
+# SmolLM2 Service Space
+# Copyright 2026 - Volkan Kücükbudak
+# Apache License V2 + ESOL 1.1
+# =============================================================================
+# Usage:
+#   python train.py --mode export   → export HF dataset to training format
+#   python train.py --mode validate → validate ADI weights against dataset
+#   python train.py --mode finetune → finetune SmolLM2 on collected data (future)
+# =============================================================================
+
+import argparse
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+
+import model as model_module
+from adi import DumpindexAnalyzer
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+logger = logging.getLogger("train")
+
+
+# =============================================================================
+# Mode 1 — Export dataset to training format
+# =============================================================================
+
+def export_dataset(output_path: str = "train_data.jsonl"):
+    """
+    Export HF dataset logs to JSONL format for training.
+    Filters: only HIGH_PRIORITY and MEDIUM_PRIORITY entries with actual responses.
+    """
+    logger.info("Loading dataset from HF...")
+    entries = model_module.load_logs()
+
+    if not entries:
+        logger.warning("Dataset empty — nothing to export")
+        return
+
+    output = Path(output_path)
+    count = 0
+
+    with open(output, "w") as f:
+        for entry in entries:
+            # Only export entries where SmolLM2 actually responded
+            if entry.get("adi_decision") == "REJECT":
+                continue
+            if not entry.get("response"):
+                continue
+
+            # Format as instruction tuning pair
+            record = {
+                "instruction": entry.get("system_prompt", "You are a helpful assistant."),
+                "input":       entry.get("prompt", ""),
+                "output":      entry.get("response", ""),
+                "adi_score":   entry.get("adi_score"),
+                "adi_decision": entry.get("adi_decision"),
+            }
+            f.write(json.dumps(record) + "\n")
+            count += 1
+
+    logger.info(f"Exported {count}/{len(entries)} entries → {output}")
+
+
+# =============================================================================
+# Mode 2 — Validate ADI weights against collected data
+# =============================================================================
+
+def validate_adi():
+    """
+    Run ADI weight validation against dataset.
+    Uses entries that have human_label field (manually labeled).
+    """
+    logger.info("Loading dataset for ADI validation...")
+    entries = model_module.load_logs()
+
+    labeled = [(e["prompt"], e["human_label"]) for e in entries if e.get("human_label")]
+
+    if not labeled:
+        logger.warning("No labeled entries found — add 'human_label' field to dataset entries")
+        logger.info("Expected labels: REJECT | MEDIUM_PRIORITY | HIGH_PRIORITY")
+        return
+
+    analyzer = DumpindexAnalyzer()
+    accuracy = analyzer.validate_weights(labeled)
+    logger.info(f"ADI Validation accuracy: {accuracy:.1%} on {len(labeled)} samples")
+
+    # Save results
+    result = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "accuracy": accuracy,
+        "samples": len(labeled),
+        "weights": analyzer.weights,
+    }
+    Path("validation_results.json").write_text(json.dumps(result, indent=2))
+    logger.info("Results saved → validation_results.json")
+
+
+# =============================================================================
+# Mode 3 — Finetune placeholder
+# =============================================================================
+
+def finetune():
+    """
+    Finetune SmolLM2 on collected dataset.
+    Placeholder — requires export first + enough data (>500 samples recommended).
+    """
+    train_file = Path("train_data.jsonl")
+    if not train_file.exists():
+        logger.error("train_data.jsonl not found — run: python train.py --mode export first")
+        return
+
+    lines = train_file.read_text().strip().splitlines()
+    logger.info(f"Training samples available: {len(lines)}")
+
+    if len(lines) < 100:
+        logger.warning(f"Only {len(lines)} samples — recommend 500+ for meaningful finetuning")
+
+    # TODO: implement finetuning with transformers Trainer
+    # Rough plan:
+    #   1. Load base model via model.get_model_id()
+    #   2. Tokenize train_data.jsonl
+    #   3. TrainingArguments + Trainer
+    #   4. Save to PRIVATE_MODEL repo via model.push_model_card()
+    logger.info("Finetune placeholder — not yet implemented")
+    logger.info("Next step: implement with transformers.Trainer or TRL SFTTrainer")
+
+
+# =============================================================================
+# CLI
+# =============================================================================
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="SmolLM2 Training Utilities")
+    parser.add_argument(
+        "--mode",
+        choices=["export", "validate", "finetune"],
+        required=True,
+        help="export: dump dataset to JSONL | validate: test ADI weights | finetune: train model"
+    )
+    parser.add_argument("--output", default="train_data.jsonl", help="Output file for export mode")
+    args = parser.parse_args()
+
+    if args.mode == "export":
+        export_dataset(args.output)
+    elif args.mode == "validate":
+        validate_adi()
+    elif args.mode == "finetune":
+        finetune()