.

Dockerfile

@@ -24,3 +24,5 @@ RUN mkdir -p /app/nltk_data /app/hf_cache && \
 
 EXPOSE 7860
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+
+#

app.py

@@ -28,7 +28,7 @@ app = FastAPI(
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, replace with your frontend URL
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -142,7 +142,7 @@ async def health_check():
         }
 
 
-@app.post("/api/analyze", response_model=AnalysisResponse)
+@app.post("/api/analyze")
 async def analyze_text(request: AnalysisRequest):
     """
     Analyze text using the DeBERTa AI detection model
@@ -158,12 +158,12 @@ async def analyze_text(request: AnalysisRequest):
         if not request.text or len(request.text.strip()) == 0:
             raise HTTPException(status_code=400, detail="Text cannot be empty")
         
-        # Check text length for meaningful analysis (80-7000 words)
+        # Check text length for meaningful analysis (50-7000 words)
         word_count = len(request.text.split())
-        if word_count < 80:
+        if word_count < 50:
             raise HTTPException(
                 status_code=400,
-                detail="Text is too short for analysis. Please provide at least 80 words for accurate AI detection and sentiment analysis."
+                detail="Text is too short for analysis. Please provide at least 50 words for accurate AI detection and sentiment analysis."
             )
         
         if word_count > 7000:
@@ -200,12 +200,12 @@ async def detect_ai(request: AnalysisRequest):
         if not request.text or len(request.text.strip()) == 0:
             raise HTTPException(status_code=400, detail="Text cannot be empty")
         
-        # Check text length (80-7000 words)
+        # Check text length (50-7000 words)
         word_count = len(request.text.split())
-        if word_count < 80:
+        if word_count < 50:
             raise HTTPException(
                 status_code=400,
-                detail="Text is too short. Please provide at least 80 words."
+                detail="Text is too short. Please provide at least 50 words."
             )
         elif word_count > 7000:
             raise HTTPException(
@@ -222,7 +222,8 @@ async def detect_ai(request: AnalysisRequest):
             "probability": result["probability"],
             "confidence": result["confidence"],
             "explanation": result["explanation"],
-            "mixed_analysis": result.get("mixed_analysis", None)
+            "mixed_analysis": result.get("mixed_analysis", None),
+            "modelProcessingTime": result.get("modelProcessingTime", None)
         }
         
     except HTTPException:

model_handler.py

@@ -10,6 +10,7 @@ import torch.nn.functional as F
 from transformers import AutoTokenizer, AutoConfig, AutoModel, PreTrainedModel, AutoModelForSequenceClassification
 import os
 import logging
+import time
 from typing import Dict, Any, Optional, List, Tuple
 import numpy as np
 from pathlib import Path
@@ -18,11 +19,17 @@ import json
 import nltk
 from nltk.tokenize import sent_tokenize
 
+
 # Download NLTK data
 try:
     nltk.data.find('tokenizers/punkt')
 except LookupError:
     nltk.download('punkt', quiet=True)
+    
+try:
+    nltk.data.find('tokenizers/punkt_tab')
+except LookupError:
+    nltk.download('punkt_tab', quiet=True)
 
 logger = logging.getLogger(__name__)
 
@@ -80,7 +87,7 @@ class AIDetectionModelHandler:
         Initialize the model handler
         
         Args:
-            model_path: Path to the model directory (default: env MODEL_PATH or /app/model)
+            model_path: Path to the model directory (default: ../model/model)
             max_length: Maximum token length for input text
         """
         self.max_length = max_length
@@ -94,20 +101,11 @@ class AIDetectionModelHandler:
         
         # Default model paths
         if model_path is None:
-            # Prefer explicit env var
-            env_model_path = os.getenv("MODEL_PATH")
-            if env_model_path and os.path.exists(env_model_path):
-                model_path = env_model_path
-            elif os.path.exists("/app/model"):
-                model_path = "/app/model"
-            else:
-                # Fallback to legacy relative path
-                backend_dir = Path(__file__).parent
-                model_path = str(backend_dir.parent / "model" / "model")
+            backend_dir = Path(__file__).parent
+            model_path = str(backend_dir.parent / "model" / "model")
         
         self.model_path = model_path
-        # XGBoost file is expected inside the same folder as the other model artifacts
-        self.xgboost_path = str(Path(model_path) / "xgboost_model.json")
+        self.xgboost_path = str(Path(model_path).parent / "xgboost_model.json")
         
         # Load the models
         self._load_models()
@@ -115,6 +113,9 @@ class AIDetectionModelHandler:
     def _load_models(self):
         """Load DeBERTa, sentiment model, and XGBoost classifier"""
         try:
+            logger.info(f"CUDA available: {torch.cuda.is_available()}")
+            logger.info(f"Selected device: {self.device}")
+
             logger.info(f"Loading models from: {self.model_path}")
             logger.info(f"Using device: {self.device}")
             
@@ -132,6 +133,8 @@ class AIDetectionModelHandler:
             self.deberta_model.to(self.device)
             self.deberta_model.eval()
             
+            print("DeBERTa model device:", next(self.deberta_model.parameters()).device)
+
             # 2. Load sentiment analysis model (DistilBERT)
             logger.info("Loading sentiment model...")
             sentiment_model_name = "distilbert-base-uncased-finetuned-sst-2-english"
@@ -140,16 +143,40 @@ class AIDetectionModelHandler:
             self.sentiment_model.to(self.device)
             self.sentiment_model.eval()
             
+            print("Sentiment model device:", next(self.sentiment_model.parameters()).device)
+
             # 3. Load XGBoost model
             if os.path.exists(self.xgboost_path):
                 logger.info(f"Loading XGBoost model from: {self.xgboost_path}")
+                t0 = time.perf_counter()
                 self.xgboost_model = xgb.Booster()
                 self.xgboost_model.load_model(self.xgboost_path)
+                # Force GPU or CPU depending on hardware
+                if torch.cuda.is_available():
+                    logger.info("Setting XGBoost to use GPU predictor")
+                    try:
+                        self.xgboost_model.set_param({"predictor": "gpu_predictor", "tree_method": "gpu_hist"})
+                        logger.info("XGBoost configured to use GPU (gpu_predictor, gpu_hist)")
+                    except Exception as ie:
+                        logger.warning(f"Failed to set XGBoost GPU params: {ie}")
+                else:
+                    logger.info("Setting XGBoost to use CPU predictor")
+                    try:
+                        self.xgboost_model.set_param({"predictor": "cpu_predictor", "tree_method": "hist"})
+                    except Exception as ie:
+                        logger.warning(f"Failed to set XGBoost CPU params: {ie}")
+                
+                t1 = time.perf_counter()
+                logger.info(f"XGBoost model loaded in {t1 - t0:.4f}s")
                 logger.info("✅ XGBoost model loaded!")
             else:
                 logger.warning(f"XGBoost model not found at {self.xgboost_path}, using DeBERTa only")
                 self.xgboost_model = None
             
+            # 🔍 OPTIONAL: PRINT GPU NAME
+            if torch.cuda.is_available():
+                print("GPU detected:", torch.cuda.get_device_name(0))
+
             self.model_loaded = True
             logger.info("✅ All models loaded successfully!")
             
@@ -179,9 +206,11 @@ class AIDetectionModelHandler:
                 return [0.5]  # Neutral if no sentences
             
             scores = []
-            
+            start_total = time.perf_counter()
+
             with torch.no_grad():
-                for sentence in sentences:
+                for i, sentence in enumerate(sentences):
+                    s0 = time.perf_counter()
                     # Tokenize sentence
                     inputs = self.sentiment_tokenizer(
                         sentence,
@@ -192,6 +221,7 @@ class AIDetectionModelHandler:
                     )
                     inputs = {k: v.to(self.device) for k, v in inputs.items()}
                     
+
                     # Get sentiment prediction
                     outputs = self.sentiment_model(**inputs)
                     logits = outputs.logits
@@ -202,7 +232,10 @@ class AIDetectionModelHandler:
                     # Convert to polarity score (-1 to 1, where 0.5 is neutral)
                     polarity = (pos_prob - 0.5) * 2  # Maps [0,1] to [-1,1]
                     scores.append(polarity)
-            
+                    s1 = time.perf_counter()
+                    logger.debug(f"Sentiment sentence processed in {s1 - s0:.4f}s")
+            total_time = time.perf_counter() - start_total
+            logger.info(f"Extracted sentiment scores for {len(sentences)} sentences in {total_time:.4f}s")
             return scores
             
         except Exception as e:
@@ -219,12 +252,16 @@ class AIDetectionModelHandler:
         Returns:
             Numpy array with [avg_polarity, polarity_variance]
         """
+        start = time.perf_counter()
         sentiment_scores = self.get_sentiment_scores(text)
         
         # Calculate features
         avg_polarity = float(np.mean(sentiment_scores)) if sentiment_scores else 0.0
         polarity_variance = float(np.var(sentiment_scores)) if len(sentiment_scores) > 1 else 0.0
         
+        duration = time.perf_counter() - start
+        logger.info(f"Sentiment features extracted in {duration:.4f}s (avg_polarity={avg_polarity:.4f}, variance={polarity_variance:.4f})")
+
         return np.array([avg_polarity, polarity_variance], dtype=np.float32)
     
     def get_deberta_embeddings(self, text: str) -> np.ndarray:
@@ -238,7 +275,9 @@ class AIDetectionModelHandler:
             Numpy array of embeddings
         """
         try:
+            t_total = time.perf_counter()
             # Tokenize input
+            t0 = time.perf_counter()
             encoded = self.tokenizer(
                 text,
                 padding='max_length',
@@ -247,23 +286,33 @@ class AIDetectionModelHandler:
                 return_tensors='pt'
             )
             
+            t1 = time.perf_counter()
+            logger.debug(f"Tokenization time: {t1 - t0:.4f}s")
+
             input_ids = encoded['input_ids'].to(self.device)
             attention_mask = encoded['attention_mask'].to(self.device)
             
             # Get embeddings
             with torch.no_grad():
+                t0 = time.perf_counter()
                 outputs = self.deberta_model.model(input_ids=input_ids, attention_mask=attention_mask)
+                t1 = time.perf_counter()
+                logger.debug(f"Transformer forward pass time: {t1 - t0:.4f}s")
+                
                 last_hidden_state = outputs[0]
                 
                 # Mean pooling
+                t0 = time.perf_counter()
                 input_mask_expanded = attention_mask.unsqueeze(-1).expand(last_hidden_state.size()).float()
                 sum_embeddings = torch.sum(last_hidden_state * input_mask_expanded, dim=1)
                 sum_mask = torch.clamp(input_mask_expanded.sum(dim=1), min=1e-9)
                 pooled_output = sum_embeddings / sum_mask
+                t1 = time.perf_counter()
+                logger.debug(f"Pooling time: {t1 - t0:.4f}s")
             
             # Convert to numpy
             embeddings = pooled_output.cpu().numpy().flatten()
-            
+            total = time.perf_counter() - t_total
             return embeddings
             
         except Exception as e:
@@ -285,19 +334,26 @@ class AIDetectionModelHandler:
             raise RuntimeError("Model not loaded. Cannot perform prediction.")
         
         try:
+            overall_start = time.perf_counter()
             # Extract sentiment features
             logger.info("Extracting sentiment features...")
+            sentiment_start = time.perf_counter()
             sentiment_features = self.extract_sentiment_features(text)
+            sentiment_time = time.perf_counter() - sentiment_start
             avg_polarity = float(sentiment_features[0])
             polarity_variance = float(sentiment_features[1])
-            
+            logger.info(f"Sentiment extraction took {sentiment_time:.4f}s")
+
             # If XGBoost is available, use the full two-branch pipeline
             if self.xgboost_model is not None:
                 logger.info("Using XGBoost two-branch model...")
-                
+                embed_start = time.perf_counter()
+
                 # Get DeBERTa embeddings
                 deberta_embeddings = self.get_deberta_embeddings(text)
-                
+                embed_time = time.perf_counter() - embed_start
+                logger.info(f"DeBERTa embedding extraction took {embed_time:.4f}s")
+
                 # Combine features: DeBERTa embeddings + sentiment features
                 combined_features = np.concatenate([deberta_embeddings, sentiment_features])
                 
@@ -305,8 +361,11 @@ class AIDetectionModelHandler:
                 dmatrix = xgb.DMatrix(combined_features.reshape(1, -1))
                 
                 # Predict
+                xgb_start = time.perf_counter()
                 probability = float(self.xgboost_model.predict(dmatrix)[0])
-                
+                xgb_time = time.perf_counter() - xgb_start
+                logger.info(f"XGBoost prediction took {xgb_time:.4f}s")
+
             else:
                 # Fallback to DeBERTa only
                 logger.info("Using DeBERTa model only (XGBoost not found)...")
@@ -323,11 +382,16 @@ class AIDetectionModelHandler:
                 attention_mask = encoded['attention_mask'].to(self.device)
                 
                 with torch.no_grad():
+                    t0 = time.perf_counter()
                     outputs = self.deberta_model(input_ids=input_ids, attention_mask=attention_mask)
+                    t1 = time.perf_counter()
+                    logger.info(f"DeBERTa forward & classification took {t1 - t0:.4f}s")
                     logits = outputs["logits"]
                     probability = torch.sigmoid(logits).item()
             
             label = 1 if probability >= threshold else 0
+            overall_time = time.perf_counter() - overall_start
+            logger.info(f"Total prediction pipeline took {overall_time:.4f}s (prob={probability:.4f})")
             
             return {
                 "probability": probability,
@@ -355,6 +419,7 @@ class AIDetectionModelHandler:
             Tuple of (probability, label) where label is 0 for human, 1 for AI
         """
         try:
+            start_total = time.perf_counter()
             # Extract sentiment features
             sentiment_features = self.extract_sentiment_features(text)
             avg_polarity = float(sentiment_features[0])
@@ -362,18 +427,24 @@ class AIDetectionModelHandler:
             
             # If XGBoost is available, use the full two-branch pipeline
             if self.xgboost_model is not None:
+                embed_start = time.perf_counter()
                 # Get DeBERTa embeddings
                 deberta_embeddings = self.get_deberta_embeddings(text)
-                
+                embed_time = time.perf_counter() - embed_start
+                logger.info(f"DeBERTa embedding extraction took {embed_time:.4f}s")
+
                 # Combine features: DeBERTa embeddings + sentiment features
                 combined_features = np.concatenate([deberta_embeddings, sentiment_features])
                 
                 # Create DMatrix for XGBoost
                 dmatrix = xgb.DMatrix(combined_features.reshape(1, -1))
-                
+                xgb_start = time.perf_counter()
+
                 # Predict
                 probability = float(self.xgboost_model.predict(dmatrix)[0])
-                
+                xgb_time = time.perf_counter() - xgb_start
+                logger.info(f"XGBoost prediction (single) took {xgb_time:.4f}s")
+
             else:
                 # Fallback to DeBERTa only
                 encoded = self.tokenizer(
@@ -388,12 +459,16 @@ class AIDetectionModelHandler:
                 attention_mask = encoded['attention_mask'].to(self.device)
                 
                 with torch.no_grad():
+                    t0 = time.perf_counter()
                     outputs = self.deberta_model(input_ids=input_ids, attention_mask=attention_mask)
+                    t1 = time.perf_counter()
+                    logger.info(f"DeBERTa forward (single) took {t1 - t0:.4f}s")
                     logits = outputs["logits"]
                     probability = torch.sigmoid(logits).item()
             
             label = 1 if probability >= 0.5 else 0
-            
+            total = time.perf_counter() - start_total
+            logger.info(f"predict_single_text_xgboost total time: {total:.4f}s")
             return probability, label
             
         except Exception as e:
@@ -414,7 +489,7 @@ class AIDetectionModelHandler:
             Dictionary with prediction results and analysis details
             
         Note:
-            Input validation: Text must be 200-7000 words. Dynamic chunking: 4-5 sentences 
+            Input validation: Text must be 80-2000 words. Dynamic chunking: 4-5 sentences 
             analyzed as whole, then chunk size varies:
             - 6-10 sentences: 3 sentences per chunk
             - 11-20 sentences: 4 sentences per chunk  
@@ -424,11 +499,11 @@ class AIDetectionModelHandler:
         """
         # Get overall prediction (your current method)
         overall_prob, overall_label = self.predict_single_text_xgboost(text)
-        
+
         # Split text into sentences
         sentences = sent_tokenize(text)
         
-        # Validate input text length (80-7000 words)
+        # Validate input text length (80-2000 words)
         total_words = len(text.split())
         if total_words < 80:
             return {
@@ -440,17 +515,31 @@ class AIDetectionModelHandler:
                 'modified_probability': overall_prob,
                 'chunk_analysis': []
             }
-        elif total_words > 7000:
+        elif total_words > 2000:
             return {
                 'prediction': 'Human' if overall_label == 0 else 'AI',
                 'confidence': abs(overall_prob - 0.5) * 2,
                 'is_mixed': False,
-                'reason': f'Text too long for analysis ({total_words} words, maximum 7000 words allowed)',
+                'reason': f'Text too long for analysis ({total_words} words, maximum 2000 words allowed)',
                 'overall_probability': overall_prob,
                 'modified_probability': overall_prob,
                 'chunk_analysis': []
             }
         
+        # Compute sentence character offsets (start/end) to map back to original text
+        sentence_offsets: List[Tuple[int, int]] = []
+        search_start = 0
+        for sent in sentences:
+            # find the sentence occurrence starting from search_start
+            idx = text.find(sent, search_start)
+            if idx == -1:
+                # fallback: skip whitespace and set to previous end
+                idx = search_start
+            start_char = idx
+            end_char = start_char + len(sent)
+            sentence_offsets.append((start_char, end_char))
+            search_start = end_char
+
         # Dynamic chunking based on total sentence count
         total_sentences = len(sentences)
         
@@ -488,28 +577,34 @@ class AIDetectionModelHandler:
                 'chunk_analysis': []
             }
         
-        # Create overlapping chunks
-        chunks = []
-        chunk_predictions = []
-        chunk_probabilities = []
-        
+        # Create overlapping chunks and retain sentence index ranges
+        chunks = []  # textual chunks (for backward compat)
+        chunk_sentence_ranges: List[Tuple[int, int]] = []  # inclusive start, inclusive end sentence idx
+        chunk_predictions: List[Tuple[float, int]] = []
+        chunk_probabilities: List[float] = []
+
         logger.info(f"Analyzing text with {total_sentences} sentences using dynamic chunk size of {dynamic_chunk_size}...")
-        
+
         for i in range(0, len(sentences) - dynamic_chunk_size + 1, dynamic_chunk_size - overlap):
             # Create chunk from sentences
-            chunk_sentences = sentences[i:i + dynamic_chunk_size]
+            start_idx = i
+            end_idx = i + dynamic_chunk_size - 1
+            chunk_sentences = sentences[start_idx:end_idx + 1]
             chunk_text = ' '.join(chunk_sentences)
-            
+
             # Only analyze chunks that meet minimum length requirement
             if len(chunk_text.strip()) >= min_chunk_length:
                 chunks.append(chunk_text)
-                
+                chunk_sentence_ranges.append((start_idx, end_idx))
+
                 # Analyze this chunk
                 prob, label = self.predict_single_text_xgboost(chunk_text)
                 chunk_predictions.append((prob, label))
                 chunk_probabilities.append(prob)
-                
+
                 logger.info(f"  Chunk {len(chunks)}: {chunk_text[:60]}... → {'AI' if label == 1 else 'Human'} ({prob:.3f})")
+
+        
         
         if len(chunk_predictions) < 2:
             return {
@@ -519,6 +614,10 @@ class AIDetectionModelHandler:
                 'reason': 'Too few chunks for mixed analysis',
                 'overall_probability': overall_prob,
                 'modified_probability': overall_prob,
+                'chunk_probabilities': chunk_probabilities,
+                'raw_chunks': [],
+                'sentence_analysis': [],
+                'merged_spans': [],
                 'chunk_analysis': chunk_predictions
             }
         
@@ -530,68 +629,148 @@ class AIDetectionModelHandler:
         # Mixed text detection logic
         is_mixed = human_chunks > 0 and ai_chunks > 0
         mixed_ratio = min(human_chunks, ai_chunks) / total_chunks
+        chunk_avg_prob = float(np.mean(chunk_probabilities)) if chunk_probabilities else overall_prob
+        chunk_label = 'AI' if chunk_avg_prob >= 0.5 else 'Human'
         
         logger.info(f"\nChunk Analysis Summary:")
         logger.info(f"  Total chunks analyzed: {total_chunks}")
         logger.info(f"  Human chunks: {human_chunks}")
         logger.info(f"  AI chunks: {ai_chunks}")
         logger.info(f"  Mixed ratio: {mixed_ratio:.2f}")
+        logger.info(f"  Average chunk probability: {chunk_avg_prob:.3f}")
+        logger.info(f"  Chunk-derived label: {chunk_label}")
         
-        # MODIFY OVERALL PROBABILITY BASED ON CHUNK ANALYSIS
-        if is_mixed and mixed_ratio > 0.25:  # At least 25% of each type
-            # Calculate weighted average of chunk probabilities
-            # Weight by chunk length (longer chunks have more influence)
-            chunk_weights = [len(chunk) for chunk in chunks]
-            total_weight = sum(chunk_weights)
-            
-            # Calculate weighted average probability
-            weighted_prob = sum(prob * weight for prob, weight in zip(chunk_probabilities, chunk_weights)) / total_weight
-            
-            # Blend original overall probability with chunk-based probability
-            # More chunks = more influence from chunk analysis
-            chunk_influence = min(total_chunks / 5.0, 1.0)  # Max influence at 5+ chunks
-            modified_prob = (overall_prob * (1 - chunk_influence)) + (weighted_prob * chunk_influence)
-            
+        if is_mixed:
             final_prediction = 'Mixed'
-            confidence = 1.0 - mixed_ratio  # Lower confidence for mixed text
-            
-            logger.info(f"  → MIXED TEXT DETECTED!")
-            logger.info(f"  → Original overall probability: {overall_prob:.3f}")
-            logger.info(f"  → Weighted chunk probability: {weighted_prob:.3f}")
-            logger.info(f"  → Chunk influence factor: {chunk_influence:.3f}")
-            logger.info(f"  → Modified probability: {modified_prob:.3f}")
-            
+            modified_prob = chunk_avg_prob
+            confidence = 1.0 - mixed_ratio
+            logger.info("  → MIXED TEXT DETECTED (chunk-based)")
         else:
-            # Pure text - use chunk analysis to refine overall probability
-            chunk_avg_prob = np.mean(chunk_probabilities)
-            
-            # Blend overall and chunk probabilities (chunks have 30% influence for pure text)
-            modified_prob = (overall_prob * 0.7) + (chunk_avg_prob * 0.3)
-            
-            final_prediction = 'Human' if modified_prob < 0.5 else 'AI'
-            # Base confidence from modified probability (0..1)
-            base_confidence = abs(modified_prob - 0.5) * 2
-
-            # For short texts/few chunks, incorporate chunk-majority evidence to avoid
-            # under-confident results when the label is clear but probability is near 0.5.
-            if total_chunks > 0:
-                majority_ratio = max(human_chunks, ai_chunks) / total_chunks  # e.g., 3/4 => 0.75
-                combined_confidence = max(
-                    base_confidence,
-                    0.6 * majority_ratio + 0.4 * base_confidence
-                )
-                # If every chunk agrees, ensure a reasonable floor
-                if majority_ratio == 1.0 and total_chunks >= 3:
-                    combined_confidence = max(combined_confidence, 0.85)
-                confidence = min(0.99, combined_confidence)
+            final_prediction = chunk_label
+            modified_prob = chunk_avg_prob
+            confidence = abs(chunk_avg_prob - 0.5) * 2
+            logger.info(f"  → Pure {chunk_label} text based on chunk probabilities")
+
+        # Build detailed raw_chunks with character offsets
+        raw_chunks: List[Dict[str, Any]] = []
+        for idx, ((prob, label), (sent_start, sent_end)) in enumerate(zip(chunk_predictions, chunk_sentence_ranges)):
+            # Map sentence indices to char offsets
+            start_char = sentence_offsets[sent_start][0] if sent_start < len(sentence_offsets) else 0
+            end_char = sentence_offsets[sent_end][1] if sent_end < len(sentence_offsets) else len(text)
+            chunk_text = text[start_char:end_char]
+            raw_chunks.append({
+                'chunk_index': idx,
+                'start_char': start_char,
+                'end_char': end_char,
+                'text': chunk_text,
+                'probability': float(prob),
+                'label': 'ai' if label == 1 else 'human',
+                'sentence_range': [sent_start, sent_end]
+            })
+
+        # Compute per-sentence aggregated probabilities and labels (weighted by chunk presence)
+        sentence_analysis: List[Dict[str, Any]] = []
+        for si in range(len(sentences)):
+            # Find chunks covering this sentence
+            covering_probs: List[float] = []
+            covering_labels: List[int] = []
+            for (prob, label), (cs, ce) in zip(chunk_predictions, chunk_sentence_ranges):
+                if cs <= si <= ce:
+                    covering_probs.append(prob)
+                    covering_labels.append(label)
+            if covering_probs:
+                avg_prob = float(np.mean(covering_probs))
+                # Use weighted/average probability as primary signal, but also
+                # consider chunk label majority with a safety threshold.
+                # Tighten AI labeling by requiring a higher probability threshold
+                # to reduce false positives from noisy chunks.
+                label_frac = float(np.mean(covering_labels)) if covering_labels else 0.0
+                AI_PROB_THRESHOLD = 0.55
+                # If average probability is confidently AI, mark as AI.
+                if avg_prob >= AI_PROB_THRESHOLD:
+                    sentence_label = 'ai'
+                # Otherwise, if majority of covering chunks are labeled AI and
+                # probability is at least 0.5, mark as AI (minority case).
+                elif label_frac > 0.5 and avg_prob >= 0.5:
+                    sentence_label = 'ai'
+                else:
+                    sentence_label = 'human'
             else:
-                confidence = base_confidence
-            
-            logger.info(f"  → Pure {final_prediction} text")
-            logger.info(f"  → Original overall probability: {overall_prob:.3f}")
-            logger.info(f"  → Average chunk probability: {chunk_avg_prob:.3f}")
-            logger.info(f"  → Modified probability: {modified_prob:.3f}")
-        
+                # No covering chunks: use nearest-chunk fallback (prefer previous chunk,
+                # otherwise next chunk). This avoids falling back to the global overall_prob
+                # which can make trailing sentences inherit the global label.
+                nearest_prob = None
+                nearest_label = None
+                # find previous chunk index (the last chunk that ends before this sentence)
+                prev_idx = None
+                for idx, (cs, ce) in enumerate(chunk_sentence_ranges):
+                    if ce < si:
+                        prev_idx = idx
+                if prev_idx is not None:
+                    nearest_prob, nearest_label = chunk_predictions[prev_idx]
+                else:
+                    # find next chunk index (the first chunk that starts after this sentence)
+                    next_idx = None
+                    for idx, (cs, ce) in enumerate(chunk_sentence_ranges):
+                        if cs > si:
+                            next_idx = idx
+                            break
+                    if next_idx is not None:
+                        nearest_prob, nearest_label = chunk_predictions[next_idx]
+
+                if nearest_prob is not None:
+                    avg_prob = float(nearest_prob)
+                    sentence_label = 'ai' if nearest_label == 1 else 'human'
+                else:
+                    # Fallback to overall prediction if there are truly no chunks
+                    avg_prob = overall_prob
+                    sentence_label = 'ai' if overall_label == 1 else 'human'
+
+            start_c, end_c = sentence_offsets[si] if si < len(sentence_offsets) else (0, 0)
+            sentence_analysis.append({
+                'sentence_index': si,
+                'start_char': start_c,
+                'end_char': end_c,
+                'text': sentences[si],
+                'avg_probability': avg_prob,
+                'label': sentence_label
+            })
+
+        # Merge adjacent sentences with same label into non-overlapping spans for easy frontend rendering
+        merged_spans: List[Dict[str, Any]] = []
+        if sentence_analysis:
+            cur = sentence_analysis[0]
+            cur_start = cur['start_char']
+            cur_end = cur['end_char']
+            cur_label = cur['label']
+            cur_probs = [cur['avg_probability']]
+
+            for s in sentence_analysis[1:]:
+                if s['label'] == cur_label:
+                    # extend current span
+                    cur_end = s['end_char']
+                    cur_probs.append(s['avg_probability'])
+                else:
+                    merged_spans.append({
+                        'start_char': cur_start,
+                        'end_char': cur_end,
+                        'label': cur_label,
+                        'avg_probability': float(np.mean(cur_probs))
+                    })
+                    # start a new span
+                    cur_start = s['start_char']
+                    cur_end = s['end_char']
+                    cur_label = s['label']
+                    cur_probs = [s['avg_probability']]
+
+            # append final span
+            merged_spans.append({
+                'start_char': cur_start,
+                'end_char': cur_end,
+                'label': cur_label,
+                'avg_probability': float(np.mean(cur_probs))
+            })
+
         return {
             'prediction': final_prediction,
             'confidence': confidence,
@@ -604,9 +783,14 @@ class AIDetectionModelHandler:
             'modified_probability': modified_prob,
             'chunk_probabilities': chunk_probabilities,
             'chunk_analysis': chunk_predictions,
+            'raw_chunks': raw_chunks,
+            'sentence_analysis': sentence_analysis,
+            'merged_spans': merged_spans,
             'chunk_size': chunk_size,
             'overlap': overlap
         }
+        
+        
     
     def detect_ai(self, text: str) -> Dict[str, Any]:
         """
@@ -654,24 +838,24 @@ class AIDetectionModelHandler:
                 
         elif prediction == "AI":
             explanation = f"This text is classified as AI-Generated with {certainty}."
-            explanation += " The text exhibits patterns typical of AI-generated content, including consistent structure and predictable phrasing."
+            explanation += " The text is typically associated with AI-generated writing based on patterns, including uniform structure or predictable phrasing."
             if pol_var <= 0.10:
-                explanation += " Very low emotional variation which is typical of AI texts with uniform style."
+                explanation += "  Very low emotional variation which is common in more structured or machine-generated texts."
             elif pol_var <= 0.35:
-                explanation += " Low emotional variation which is common in AI-generated content."
+                explanation += " Low emotional variation which may align with AI patterns but can also occur in formal human writing."
             elif pol_var <= 0.60:
-                explanation += " Moderate emotional variation which is rare in AI, possibly presenting multiple viewpoints."
+                explanation += " Moderate emotional variation which is less typical for AI but still possible depending on the prompt or model."
             else:
-                explanation += " High emotional variation is unusual for AI, may indicate balanced argument structure."
+                explanation += " High emotional variation which is uncommon in AI outputs but may occur in certain complex or narrative prompts."
         else:  # Human
             explanation = f"This text is classified as Human-Authored with {certainty}."
-            explanation += " The text shows characteristics of human writing, such as natural variations and organic flow."
+            explanation += "  The text shows patterns frequently observed in human writing, such as natural variations and flexible sentence structures."
             if pol_var > 0.60:
-                explanation += " High emotional variation which is typical of human writing with emotional swings in debates, reviews, and narratives."
+                explanation += " High emotional variation which often reflects expressive or opinionated writing."
             elif pol_var >= 0.36:
-                explanation += " Moderate emotional variation which shows human-like sentiment shifts."
+                explanation += " Moderate emotional variation which shows natural shifts in tone."
             elif pol_var >= 0.11:
-                explanation += " Low emotional variation which may indicate formal or academic human writing."
+                explanation += " Low emotional variation which may indicate formal or academic writing."
             else:
                 explanation += " Very low emotional variation indicates consistent tone with focused perspective."
         
@@ -689,6 +873,7 @@ class AIDetectionModelHandler:
                 "avg_polarity": avg_pol,
                 "polarity_variance": pol_var
             },
+            
             "mixed_analysis": {
                 "is_mixed": chunk_result["is_mixed"],
                 "mixed_ratio": chunk_result.get("mixed_ratio", 0),
@@ -697,10 +882,16 @@ class AIDetectionModelHandler:
                 "total_chunks": chunk_result.get("total_chunks", 0),
                 "overall_probability": chunk_result["overall_probability"],
                 "modified_probability": chunk_result["modified_probability"]
-            }
+            },
+            "raw_chunks": chunk_result.get("raw_chunks", []),
+            "sentence_analysis": chunk_result.get("sentence_analysis", []),
+            "merged_spans": chunk_result.get("merged_spans", []),
+            "modelProcessingTime": time.perf_counter()
         }
+
     
     def analyze_text(self, text: str) -> Dict[str, Any]:
+        start_time = time.perf_counter()
         """
         Comprehensive text analysis combining AI detection with sentiment features
         
@@ -710,15 +901,34 @@ class AIDetectionModelHandler:
         Returns:
             Complete analysis results with model-based sentiment features
         """
-        # Validate input text length (80-7000 words)
+        # Validate input text length (80-2000 words)
         total_words = len(text.split())
         if total_words < 80:
             raise ValueError(f"Text too short for analysis ({total_words} words, minimum 80 words required)")
-        elif total_words > 7000:
-            raise ValueError(f"Text too long for analysis ({total_words} words, maximum 7000 words allowed)")
+        elif total_words > 2000:
+            raise ValueError(f"Text too long for analysis ({total_words} words, maximum 2000 words allowed)")
         
         # Get AI detection results (includes sentiment features from model)
         ai_detection = self.detect_ai(text)
+        mixed_analysis = ai_detection.get("mixed_analysis") or {}
+        modified_prob = mixed_analysis.get("modified_probability")
+        overall_prob = mixed_analysis.get("overall_probability")
+
+        primary_probability = None
+        for candidate in (modified_prob, overall_prob, ai_detection.get("probability")):
+            if isinstance(candidate, (int, float)):
+                primary_probability = float(candidate)
+                break
+        
+        if primary_probability is None:
+            primary_probability = 0.0
+        
+        ai_prob = max(0.0, min(1.0, primary_probability))
+        human_prob = 1.0 - ai_prob
+        probability_breakdown = {
+            "ai": ai_prob,
+            "human": human_prob
+        }
         model_sentiment = ai_detection.get("sentiment_features", {})
         
         # Perform basic text analysis
@@ -734,7 +944,6 @@ class AIDetectionModelHandler:
         # Determine complexity based on AI probability and text metrics
         is_ai = ai_detection["classification"] == "ai"
         is_mixed = ai_detection["classification"] == "mixed"
-        ai_prob = ai_detection["probability"]
         
         # Handle different prediction types
         if is_mixed:
@@ -757,7 +966,6 @@ class AIDetectionModelHandler:
         insights = []
         
         if is_mixed and ai_detection["confidence"] > 60:
-            mixed_analysis = ai_detection.get("mixed_analysis", {})
             insights.append({
                 "type": "observation",
                 "title": "Mixed Content Detected",
@@ -774,14 +982,14 @@ class AIDetectionModelHandler:
             insights.append({
                 "type": "observation",
                 "title": "AI-Generated Content Detected",
-                "description": f"This text shows strong indicators of AI generation ({ai_detection['confidence']:.1f}% confidence).",
-                "suggestion": "Consider adding personal anecdotes, varied sentence structures, or unique perspectives to make it more human-like."
+                "description": f"This text shows strong indicators associated with AI-generated writing ({ai_detection['confidence']:.1f}% confidence).",
+                "suggestion": "Consider adding personal insights, varied sentence structures, or unique perspectives to achieve a more unique voice."
             })
         elif not is_ai and ai_detection["confidence"] > 75:
             insights.append({
                 "type": "strength",
                 "title": "Human Writing Characteristics",
-                "description": f"This text exhibits clear human writing patterns ({ai_detection['confidence']:.1f}% confidence)."
+                "description": f"The text shows several features commonly found in human-authored writing ({ai_detection['confidence']:.1f}% confidence)."
             })
         
         # Sentence variety analysis
@@ -792,8 +1000,8 @@ class AIDetectionModelHandler:
                 insights.append({
                     "type": "improvement",
                     "title": "Sentence Variety",
-                    "description": "Sentences have similar lengths, which may indicate AI generation.",
-                    "suggestion": "Vary sentence lengths to create more natural rhythm."
+                    "description": "Sentences have similar lengths, which this pattern may indicate AI generation.",
+                    "suggestion": "Consider varying sentence length to create a more natural flow."
                 })
             else:
                 insights.append({
@@ -818,6 +1026,11 @@ class AIDetectionModelHandler:
         # Construct full analysis response with model sentiment features
         polarity_variance = model_sentiment.get("polarity_variance", 0)
         
+        end_time = time.perf_counter()
+        processing_seconds = round(end_time - start_time, 3)  # exact seconds (millisecond precision)
+        
+        logger.info(f"Model processing time for analyze_text: {processing_seconds:.3f}s")
+
         return {
             "advancedSentiment": {
                 "emotions": emotions,
@@ -856,7 +1069,13 @@ class AIDetectionModelHandler:
             },
             "aiOrHuman": ai_detection["classification"],
             "aiOrHumanConfidence": ai_detection["confidence"],
-            "aiOrHumanExplanation": ai_detection["explanation"]
+            "aiOrHumanExplanation": ai_detection["explanation"],
+            "mixedAnalysis": mixed_analysis,
+            "probabilityBreakdown": probability_breakdown,
+            "rawChunks": ai_detection.get("raw_chunks", []),
+            "sentenceAnalysis": ai_detection.get("sentence_analysis", []),
+            "mergedSpans": ai_detection.get("merged_spans", []),
+            "modelProcessingTime": processing_seconds
         }
     
     def get_model_info(self) -> Dict[str, Any]:
@@ -877,3 +1096,5 @@ class AIDetectionModelHandler:
             ],
             "description": "Two-branch model for detecting AI-Generated vs Human-Authored text using DeBERTa semantic embeddings combined with sentiment features"
         }
+
+#