Update app.py

app.py

@@ -1,16 +1,16 @@
 """
 FastAPI backend with optimized streaming for LFM2.5-1.2B-Instruct
-Enhanced with advanced intent detection (AshokGakr/intent_detector) 
+Enhanced with intent detection (AshokGakr/intent_detector) 
 and emotion detection (AshokGakr/emotions_detector) models
+Using LFM2.5's native tool calling capabilities
 """
 
-import os, json, re, traceback, asyncio, time, sys
+import os, json, traceback, asyncio, time, sys
 from typing import Optional, List, Dict, Any, AsyncGenerator
 from datetime import datetime, timezone
 from contextlib import asynccontextmanager
 
 import torch
-import numpy as np
 from fastapi.staticfiles import StaticFiles
 from fastapi import (
     FastAPI,
@@ -27,36 +27,21 @@ from fastapi.templating import Jinja2Templates
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForCausalLM, TextIteratorStreamer
 from threading import Thread
 
-# Import the tools module
-try:
-    from tools import web_search
-    print("✅ Tools module imported successfully")
-except ImportError as e:
-    print(f"⚠️ Could not import tools module: {e}")
-    def web_search(query: str) -> str:
-        return f"Search results for: {query} (tools module not available)"
-
 # ================== CONFIG =================
 ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
-DEBUG = ENVIRONMENT != "production"
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🔧 Using device: {DEVICE}")
-print(f"🔧 PyTorch version: {torch.__version__}")
-print(f"🔧 CUDA available: {torch.cuda.is_available()}")
-
-# Updated models from provided URLs
-INTENT_MODEL_NAME = "AshokGakr/intent_detector"  # 82 intent classes
-EMOTION_MODEL_NAME = "AshokGakr/emotions_detector"  # 28 emotion labels (multi-label)
 
-# LFM2.5-1.2B-Instruct model - Liquid AI
+# Models
+INTENT_MODEL_NAME = "AshokGakr/intent_detector"
+EMOTION_MODEL_NAME = "AshokGakr/emotions_detector"
 LFM_MODEL_NAME = "LiquidAI/LFM2.5-1.2B-Instruct"
 
 MAX_FILE_SIZE = 50 * 1024 * 1024
 MAX_TOKENS_DEFAULT = 1024
-MAX_TOKENS_HARD_LIMIT = 4096  # Conservative limit for stability
-DEFAULT_TEMPERATURE = 0.7  # LFM2.5 default is 0.1, but keep adjustable
-STREAM_DELAY = 0.02
-MAX_CONTEXT_LENGTH = 8192  # Safe context length for LFM2.5 (max 32768)
+MAX_TOKENS_HARD_LIMIT = 4096
+DEFAULT_TEMPERATURE = 0.7
+MAX_CONTEXT_LENGTH = 8192
 
 # Global model variables
 intent_tokenizer = None
@@ -75,105 +60,30 @@ os.makedirs(TEMPLATES_DIR, exist_ok=True)
 os.makedirs(STATIC_DIR, exist_ok=True)
 templates = Jinja2Templates(directory=TEMPLATES_DIR)
 
-# Intent mapping for the 82 classes from AshokGakr/intent_detector
-# Based on the training datasets mentioned in the model card
-INTENT_CATEGORIES = {
-    "general": [
-        "greeting", "goodbye", "thanks", "apology", "negation", 
-        "affirmation", "unknown", "other", "neutral", "oos"
-    ],
-    "assistant": [
-        "play_music", "pause_music", "next_track", "previous_track", 
-        "volume_up", "volume_down", "mute", "unmute", "shuffle", "repeat"
-    ],
-    "information": [
-        "weather", "time", "date", "calendar", "news", "facts", 
-        "definition", "search", "find", "lookup"
-    ],
-    "control": [
-        "turn_on", "turn_off", "open", "close", "start", "stop", 
-        "activate", "deactivate", "enable", "disable"
-    ],
-    "communication": [
-        "call", "message", "email", "sms", "video_call", 
-        "voice_message", "chat", "send", "receive"
-    ],
-    "navigation": [
-        "directions", "location", "map", "route", "traffic", 
-        "distance", "eta", "nearby", "find_place"
-    ],
-    "entertainment": [
-        "joke", "story", "quote", "fun_fact", "trivia", 
-        "game", "movie", "tv_show", "book", "music_recommendation"
-    ],
-    "productivity": [
-        "reminder", "alarm", "timer", "schedule", "todo", 
-        "notes", "list", "plan", "organize", "meeting"
-    ],
-    "shopping": [
-        "order", "buy", "purchase", "price", "discount", 
-        "delivery", "track_order", "return", "review", "recommendation"
-    ],
-    "food": [
-        "recipe", "restaurant", "reservation", "order_food", 
-        "ingredients", "cooking", "dietary", "nutrition", "delivery_food"
-    ]
-}
-
-# Emotion labels from the go_emotions dataset (28 classes)
-EMOTION_LABELS = [
-    "admiration", "amusement", "anger", "annoyance", "approval", 
-    "caring", "confusion", "curiosity", "desire", "disappointment", 
-    "disapproval", "disgust", "embarrassment", "excitement", "fear", 
-    "gratitude", "grief", "joy", "love", "nervousness", 
-    "optimism", "pride", "realization", "relief", "remorse", 
-    "sadness", "surprise", "neutral"
-]
-
-# Emotion tone mapping for response generation
-EMOTION_TONE_MAPPING = {
-    "positive": ["admiration", "amusement", "approval", "caring", "excitement", 
-                 "gratitude", "joy", "love", "optimism", "pride", "relief"],
-    "neutral": ["neutral", "curiosity", "confusion", "realization", "surprise"],
-    "negative": ["anger", "annoyance", "disappointment", "disapproval", "disgust", 
-                 "embarrassment", "fear", "grief", "nervousness", "remorse", "sadness"],
-    "desire": ["desire"]
-}
-
 # ================== MODEL LOADING =================
 
 async def load_models():
-    """Load and initialize all ML models with optimized settings for LFM2.5"""
+    """Load and initialize all ML models"""
     global intent_tokenizer, intent_model, emotion_tokenizer, emotion_model
     global lfm_tokenizer, lfm_model
     
     print("\n" + "="*50)
-    print("🔄 LOADING AI MODELS - ENHANCED WITH INTENT & EMOTION DETECTION")
+    print("🔄 LOADING AI MODELS")
     print("="*50)
     
-    # Load intent detection model (82 classes)
-    intent_success = False
+    # Load intent detection model
     try:
         print(f"📥 Loading intent detection model: {INTENT_MODEL_NAME}")
         intent_tokenizer = AutoTokenizer.from_pretrained(INTENT_MODEL_NAME)
         intent_model = AutoModelForSequenceClassification.from_pretrained(INTENT_MODEL_NAME)
         intent_model.to(DEVICE).eval()
-        print(f"✅ Intent model loaded successfully (82 classes)")
-        intent_success = True
+        print(f"✅ Intent model loaded successfully")
     except Exception as e:
-        print(f"⚠️ Intent model fallback to simpler model: {e}")
-        try:
-            # Fallback to a simpler intent model
-            intent_tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
-            intent_model = None
-            intent_success = False
-        except Exception as e2:
-            print(f"❌ Intent model fallback failed: {e2}")
-            intent_tokenizer = None
-            intent_model = None
+        print(f"❌ Intent model failed to load: {e}")
+        intent_tokenizer = None
+        intent_model = None
     
-    # Load emotion detection model (multi-label, 28 classes)
-    emotion_success = False
+    # Load emotion detection model
     try:
         print(f"📥 Loading emotion detection model: {EMOTION_MODEL_NAME}")
         emotion_tokenizer = AutoTokenizer.from_pretrained(EMOTION_MODEL_NAME)
@@ -183,40 +93,25 @@ async def load_models():
             num_labels=28
         )
         emotion_model.to(DEVICE).eval()
-        print(f"✅ Emotion model loaded successfully (28 multi-label classes)")
-        emotion_success = True
+        print(f"✅ Emotion model loaded successfully")
     except Exception as e:
-        print(f"⚠️ Emotion model fallback: {e}")
-        try:
-            # Fallback to simpler emotion model
-            emotion_tokenizer = AutoTokenizer.from_pretrained("roberta-base")
-            emotion_model = None
-            emotion_success = False
-        except Exception as e2:
-            print(f"❌ Emotion model fallback failed: {e2}")
-            emotion_tokenizer = None
-            emotion_model = None
+        print(f"❌ Emotion model failed to load: {e}")
+        emotion_tokenizer = None
+        emotion_model = None
     
-    # ==== OPTIMIZED LFM2.5 LOADING ====
-    lfm_success = False
+    # Load LFM2.5 model
     try:
         print(f"📥 Loading LFM2.5-1.2B-Instruct model")
         
-        # Load tokenizer with correct settings
         lfm_tokenizer = AutoTokenizer.from_pretrained(
             LFM_MODEL_NAME,
-            padding_side="left",  # Essential for streaming
+            padding_side="left",
             trust_remote_code=False,
             use_fast=True
         )
         
-        # IMPORTANT: LFM2.5 uses special tokens <|im_start|> and <|im_end|>
-        # No need to set pad token separately as the tokenizer handles it
-        
         print(f"   Tokenizer loaded with vocab size: {lfm_tokenizer.vocab_size}")
-        print(f"   Chat template available: {lfm_tokenizer.chat_template is not None}")
         
-        # Configure model loading based on available hardware
         load_kwargs = {
             "torch_dtype": torch.bfloat16 if DEVICE == "cuda" else torch.float32,
             "trust_remote_code": False,
@@ -228,60 +123,37 @@ async def load_models():
             **load_kwargs
         )
         
-        # If device_map not used, manually move to device
         if DEVICE != "cuda" or load_kwargs.get("device_map") is None:
             lfm_model = lfm_model.to(DEVICE)
         
         lfm_model.eval()
-        
-        # Enable eval mode for inference optimizations
-        lfm_model.config.use_cache = True  # Enable KV cache for faster generation
+        lfm_model.config.use_cache = True
         
         print(f"✅ LFM2.5-1.2B-Instruct loaded successfully")
         print(f"   Model device: {lfm_model.device}")
-        print(f"   Model dtype: {lfm_model.dtype}")
-        print(f"   Model parameters: ~1.2B")
         print(f"   Context window: 32,768 tokens")
-        lfm_success = True
         
     except Exception as e:
         print(f"❌ Failed to load LFM2.5 model: {e}")
         traceback.print_exc()
-        
-        # Fallback: Try with simpler settings
-        try:
-            print("🔄 Trying simpler loading method...")
-            lfm_tokenizer = AutoTokenizer.from_pretrained(LFM_MODEL_NAME)
-            
-            lfm_model = AutoModelForCausalLM.from_pretrained(
-                LFM_MODEL_NAME,
-                torch_dtype=torch.float32
-            )
-            lfm_model.to(DEVICE).eval()
-            print(f"✅ LFM2.5 model loaded (fallback method)")
-            lfm_success = True
-        except Exception as e2:
-            print(f"❌ Fallback loading failed: {e2}")
-            lfm_tokenizer = None
-            lfm_model = None
+        lfm_tokenizer = None
+        lfm_model = None
     
     print("="*50)
     print(f"📊 MODEL LOADING SUMMARY:")
-    print(f"  • Intent Model (82-class): {'✅' if intent_success else '❌'}")
-    print(f"  • Emotion Model (28-label): {'✅' if emotion_success else '❌'}")
-    print(f"  • LFM2.5 Model: {'✅' if lfm_success else '❌'}")
+    print(f"  • Intent Model: {'✅' if intent_model else '❌'}")
+    print(f"  • Emotion Model: {'✅' if emotion_model else '❌'}")
+    print(f"  • LFM2.5 Model: {'✅' if lfm_model else '❌'}")
     print(f"  • Device: {DEVICE}")
-    print(f"  • Max Context: {MAX_CONTEXT_LENGTH} tokens")
     print("="*50 + "\n")
     
-    return lfm_success
+    return bool(lfm_model)
 
 async def cleanup_models():
     """Cleanup models on shutdown"""
     print("🧹 Cleaning up models...")
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
-        torch.cuda.synchronize()
     print("✅ Cleanup complete")
 
 # ================== LIFESPAN MANAGER =================
@@ -290,12 +162,8 @@ async def cleanup_models():
 async def lifespan(app: FastAPI):
     """Modern lifespan context manager for FastAPI"""
     print("\n" + "="*50)
-    print("🚀 STARTING GAKR AI ASSISTANT WITH INTENT & EMOTION DETECTION")
+    print("🚀 STARTING GAKR AI ASSISTANT")
     print("="*50)
-    print(f"📁 Working directory: {BASE_DIR}")
-    print(f"🐍 Python version: {sys.version}")
-    print(f"🔥 Torch version: {torch.__version__}")
-    print("="*50 + "\n")
     
     model_loaded = await load_models()
     if not model_loaded:
@@ -311,9 +179,9 @@ async def lifespan(app: FastAPI):
 # ================== APP SETUP =================
 
 app = FastAPI(
-    title="GAKR AI Assistant (Enhanced with Intent & Emotion Detection)",
-    description="Three-stage AI pipeline with advanced intent detection, emotion analysis, and LFM2.5-1.2B-Instruct",
-    version="5.0.0",
+    title="GAKR AI Assistant",
+    description="AI pipeline with intent detection, emotion analysis, and LFM2.5-1.2B-Instruct with native tool calling",
+    version="6.0.0",
     lifespan=lifespan
 )
 
@@ -327,39 +195,20 @@ app.add_middleware(
     allow_headers=["*"]
 )
 
-# ================== OPTIMIZED HELPERS =================
-
-def validate_prompt_length(prompt: str, max_length: int = MAX_CONTEXT_LENGTH) -> bool:
-    """Validate prompt doesn't exceed context window"""
-    if not lfm_tokenizer:
-        return True
-    
-    tokens = lfm_tokenizer.encode(prompt, truncation=False)
-    return len(tokens) <= max_length
-
-def get_truncated_prompt(prompt: str, max_tokens: int = 3072) -> str:
-    """Truncate prompt to fit within context window"""
-    if not lfm_tokenizer:
-        return prompt[:1000]
-    
-    tokens = lfm_tokenizer.encode(prompt, truncation=False)
-    if len(tokens) <= max_tokens:
-        return prompt
-    
-    # Truncate and add ellipsis
-    truncated_tokens = tokens[:max_tokens]
-    truncated_text = lfm_tokenizer.decode(truncated_tokens, skip_special_tokens=True)
-    return truncated_text + " [Content truncated...]"
-
-# ================== ENHANCED INTENT DETECTION =================
+# ================== INTENT DETECTION =================
 
-def detect_intent_enhanced(prompt: str) -> Dict[str, Any]:
+def detect_intent(prompt: str) -> Dict[str, Any]:
     """
-    Enhanced intent detection using AshokGakr/intent_detector (82 classes)
-    Returns detailed intent information
+    Intent detection using AshokGakr/intent_detector (82 classes)
+    No fallback logic - uses model output directly
     """
     if not intent_model or not intent_tokenizer:
-        return fallback_intent_detection(prompt)
+        return {
+            "intent_label": "model_not_loaded",
+            "confidence": 0.0,
+            "model": INTENT_MODEL_NAME,
+            "class_id": -1
+        }
     
     try:
         inputs = intent_tokenizer(
@@ -376,74 +225,50 @@ def detect_intent_enhanced(prompt: str) -> Dict[str, Any]:
             predicted_class = torch.argmax(probabilities, dim=-1).item()
             confidence = probabilities[0][predicted_class].item()
         
-        # Get intent label from model config
         intent_label = "unknown"
         if hasattr(intent_model.config, 'id2label'):
             intent_label = intent_model.config.id2label.get(predicted_class, "unknown")
         
-        # Map to broader categories
-        broad_category = "general"
-        for category, intents in INTENT_CATEGORIES.items():
-            if intent_label in intents:
-                broad_category = category
-                break
-        
-        print(f"🔍 Detected intent: {intent_label} (category: {broad_category}, confidence: {confidence:.2%})")
+        print(f"🔍 Detected intent: {intent_label} (confidence: {confidence:.2%})")
         
         return {
             "intent_label": intent_label,
-            "broad_category": broad_category,
             "confidence": round(confidence, 4),
             "model": INTENT_MODEL_NAME,
             "class_id": predicted_class
         }
         
     except Exception as e:
-        print(f"⚠️ Enhanced intent detection error: {e}")
-        return fallback_intent_detection(prompt)
-
-def fallback_intent_detection(prompt: str) -> Dict[str, Any]:
-    """Fallback keyword-based intent detection when model fails"""
-    prompt_lower = prompt.lower()
-    
-    intent_keywords = {
-        "search_query": ["search", "find", "look up", "google", "internet", "web"],
-        "technical_query": ["code", "program", "function", "algorithm", "python", "javascript"],
-        "help_request": ["help", "how to", "tutorial", "guide", "explain"],
-        "analysis_request": ["analyze", "summarize", "explain", "translate"],
-        "creative_request": ["write", "create", "generate", "story", "poem"],
-        "question_query": ["what is", "who is", "where is", "when is", "why is", "how"],
-        "calculation_query": ["calculate", "solve", "math", "compute"],
-        "conversation": ["hello", "hi", "hey", "how are you"]
-    }
-    
-    detected_intent = "general_query"
-    for intent, keywords in intent_keywords.items():
-        for keyword in keywords:
-            if keyword in prompt_lower:
-                detected_intent = intent
-                break
-    
-    if "?" in prompt:
-        detected_intent = "question_query"
-    
-    return {
-        "intent_label": detected_intent,
-        "broad_category": "general",
-        "confidence": 0.5,
-        "model": "keyword_fallback",
-        "class_id": -1
-    }
+        print(f"⚠️ Intent detection error: {e}")
+        return {
+            "intent_label": "detection_error",
+            "confidence": 0.0,
+            "model": INTENT_MODEL_NAME,
+            "class_id": -1
+        }
 
 # ================== EMOTION DETECTION =================
 
-def detect_emotion_enhanced(prompt: str) -> Dict[str, Any]:
+def detect_emotion(prompt: str) -> Dict[str, Any]:
     """
-    Detect emotions using AshokGakr/emotions_detector (multi-label, 28 classes)
-    Returns primary emotion and emotional tone
+    Emotion detection using AshokGakr/emotions_detector (multi-label, 28 classes)
+    No fallback logic - uses model output directly
     """
+    EMOTION_LABELS = [
+        "admiration", "amusement", "anger", "annoyance", "approval", 
+        "caring", "confusion", "curiosity", "desire", "disappointment", 
+        "disapproval", "disgust", "embarrassment", "excitement", "fear", 
+        "gratitude", "grief", "joy", "love", "nervousness", 
+        "optimism", "pride", "realization", "relief", "remorse", 
+        "sadness", "surprise", "neutral"
+    ]
+    
     if not emotion_model or not emotion_tokenizer:
-        return fallback_emotion_detection(prompt)
+        return {
+            "primary_emotion": "model_not_loaded",
+            "primary_confidence": 0.0,
+            "model": EMOTION_MODEL_NAME
+        }
     
     try:
         inputs = emotion_tokenizer(
@@ -456,13 +281,9 @@ def detect_emotion_enhanced(prompt: str) -> Dict[str, Any]:
         
         with torch.no_grad():
             outputs = emotion_model(**inputs)
-            # Multi-label classification: use sigmoid
             probabilities = torch.sigmoid(outputs.logits)
         
-        # Get probabilities for each emotion
         emotion_probs = probabilities[0].cpu().numpy()
-        
-        # Apply threshold (0.3 based on model card optimization)
         threshold = 0.3
         detected_emotions = []
         
@@ -474,10 +295,8 @@ def detect_emotion_enhanced(prompt: str) -> Dict[str, Any]:
                     "label_id": idx
                 })
         
-        # Sort by confidence
         detected_emotions.sort(key=lambda x: x["confidence"], reverse=True)
         
-        # Determine primary emotion (highest confidence)
         primary_emotion = "neutral"
         primary_confidence = 0.0
         
@@ -485,134 +304,65 @@ def detect_emotion_enhanced(prompt: str) -> Dict[str, Any]:
             primary_emotion = detected_emotions[0]["emotion"]
             primary_confidence = detected_emotions[0]["confidence"]
         
-        # Determine emotional tone
-        emotional_tone = "neutral"
-        for tone, emotions in EMOTION_TONE_MAPPING.items():
-            if primary_emotion in emotions:
-                emotional_tone = tone
-                break
-        
-        print(f"😊 Detected emotion: {primary_emotion} (tone: {emotional_tone}, confidence: {primary_confidence:.2%})")
+        print(f"😊 Detected emotion: {primary_emotion} (confidence: {primary_confidence:.2%})")
         
         return {
             "primary_emotion": primary_emotion,
-            "emotional_tone": emotional_tone,
-            "all_emotions": detected_emotions[:5],  # Top 5 emotions
+            "all_emotions": detected_emotions[:5],
             "primary_confidence": round(primary_confidence, 4),
             "model": EMOTION_MODEL_NAME
         }
         
     except Exception as e:
-        print(f"⚠️ Enhanced emotion detection error: {e}")
-        return fallback_emotion_detection(prompt)
+        print(f"⚠️ Emotion detection error: {e}")
+        return {
+            "primary_emotion": "detection_error",
+            "primary_confidence": 0.0,
+            "model": EMOTION_MODEL_NAME
+        }
 
-def fallback_emotion_detection(prompt: str) -> Dict[str, Any]:
-    """Fallback emotion detection using keyword analysis"""
-    prompt_lower = prompt.lower()
-    
-    emotion_keywords = {
-        "joy": ["happy", "glad", "excited", "great", "wonderful", "awesome"],
-        "sadness": ["sad", "unhappy", "depressed", "cry", "tears", "mourn"],
-        "anger": ["angry", "mad", "furious", "annoyed", "irritated", "rage"],
-        "fear": ["scared", "afraid", "fearful", "terrified", "anxious", "nervous"],
-        "surprise": ["surprised", "shocked", "amazed", "astonished", "wow"],
-        "neutral": ["ok", "fine", "alright", "normal", "regular", "usual"]
-    }
-    
-    detected_emotion = "neutral"
-    confidence = 0.5
-    
-    for emotion, keywords in emotion_keywords.items():
-        for keyword in keywords:
-            if keyword in prompt_lower:
-                detected_emotion = emotion
-                confidence = 0.7
-                break
-    
-    # Determine emotional tone
-    emotional_tone = "neutral"
-    for tone, emotions in EMOTION_TONE_MAPPING.items():
-        if detected_emotion in emotions:
-            emotional_tone = tone
-            break
-    
-    return {
-        "primary_emotion": detected_emotion,
-        "emotional_tone": emotional_tone,
-        "all_emotions": [{"emotion": detected_emotion, "confidence": confidence, "label_id": -1}],
-        "primary_confidence": confidence,
-        "model": "keyword_fallback"
+# ================== TOOL DEFINITION FOR LFM2.5 =================
+# LFM2.5 has built-in tool calling capabilities. We'll define a web search tool
+# and let the model decide when to use it.
+
+TOOL_DEFINITION = {
+    "type": "function",
+    "function": {
+        "name": "web_search",
+        "description": "Search the web for current information, facts, or latest news.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The search query to look up"
+                }
+            },
+            "required": ["query"]
+        }
     }
+}
 
-# ================== TOOL DECISION WITH INTENT & EMOTION =================
+# Simple web search function (replace with actual implementation)
+def execute_web_search(query: str) -> str:
+    """Execute web search - placeholder implementation"""
+    return f"Search results for: '{query}'. [This is a placeholder - integrate with actual search API]"
 
-def enhanced_tool_decision(prompt: str, intent_info: Dict, emotion_info: Dict) -> Dict[str, Any]:
-    """
-    Enhanced tool decision based on intent, emotion, and content analysis
-    """
-    prompt_lower = prompt.lower()
-    intent_label = intent_info.get("intent_label", "")
-    broad_category = intent_info.get("broad_category", "")
-    emotional_tone = emotion_info.get("emotional_tone", "neutral")
-    
-    search_keywords = [
-        "search", "find", "look up", "google", "web", "internet",
-        "what is", "who is", "where is", "when is", "why is",
-        "current", "latest", "news", "update", "information about"
-    ]
-    
-    # Decision logic based on multiple factors
-    use_tool = False
-    tool_name = None
-    
-    # Factor 1: Intent-based decision
-    if intent_label in ["search", "find", "lookup"]:
-        use_tool = True
-        tool_name = "web_search"
-    
-    # Factor 2: Keyword-based decision
-    if not use_tool:
-        use_tool = any(keyword in prompt_lower for keyword in search_keywords)
-        if use_tool:
-            tool_name = "web_search"
-    
-    # Factor 3: Emotion-based adjustment (e.g., urgent queries might need search)
-    if emotional_tone == "negative" and "urgent" in prompt_lower:
-        use_tool = True
-        tool_name = "web_search"
-    
-    # Prepare query
-    query = prompt
-    if "?" in prompt:
-        query = prompt.split("?")[0] + "?"
-    query = query[:100]  # Limit query length
-    
-    return {
-        "use_tool": use_tool,
-        "tool": tool_name,
-        "args": {"query": query},
-        "decision_factors": {
-            "intent_based": intent_label in ["search", "find", "lookup"],
-            "keyword_based": use_tool and tool_name == "web_search",
-            "emotion_adjusted": emotional_tone == "negative" and "urgent" in prompt_lower
-        }
-    }
+# ================== STREAMING GENERATION WITH TOOL CALLING =================
 
-# ================== OPTIMIZED STREAMING GENERATION =================
-async def generate_reply_stream(
+async def generate_with_tool_calling(
     prompt: str, 
     files: List[UploadFile], 
     max_tokens: int, 
     temperature: float
 ) -> AsyncGenerator[str, None]:
-    """Stream the response with enhanced intent and emotion awareness"""
+    """Stream the response with LFM2.5 native tool calling"""
     
     print(f"\n🎯 Processing: '{prompt[:50]}...'")
-    print(f"⚙️ Parameters: max_tokens={max_tokens}, temperature={temperature}")
     
     # Validate models
     if not lfm_model or not lfm_tokenizer:
-        error_msg = "LFM2.5 model not available. Please check server health."
+        error_msg = "LFM2.5 model not available."
         print(f"❌ {error_msg}")
         yield json.dumps({
             "type": "error",
@@ -620,151 +370,90 @@ async def generate_reply_stream(
         }, ensure_ascii=False) + "\n\n"
         return
     
-    # Validate prompt length
-    if not validate_prompt_length(prompt, MAX_CONTEXT_LENGTH - max_tokens):
-        prompt = get_truncated_prompt(prompt, MAX_CONTEXT_LENGTH - max_tokens)
-        print(f"⚠️ Prompt truncated to fit context window")
+    # --- Stage 1: Intent Detection (no fallback) ---
+    intent_info = detect_intent(prompt)
+    print(f"🧠 Intent: {intent_info['intent_label']}")
     
-    # --- Stage 1: Intent Detection ---
-    intent_info = detect_intent_enhanced(prompt)
-    print(f"🧠 Intent: {intent_info['intent_label']} (Category: {intent_info['broad_category']})")
-    
-    # --- Stage 2: Emotion Detection ---
-    emotion_info = detect_emotion_enhanced(prompt)
-    print(f"😊 Emotion: {emotion_info['primary_emotion']} (Tone: {emotion_info['emotional_tone']})")
+    # --- Stage 2: Emotion Detection (no fallback) ---
+    emotion_info = detect_emotion(prompt)
+    print(f"😊 Emotion: {emotion_info['primary_emotion']}")
     
     # Send intent and emotion info to client
     yield json.dumps({
         "type": "context",
         "data": {
             "intent": intent_info,
-            "emotion": emotion_info,
-            "processing_stage": "intent_emotion_detected"
+            "emotion": emotion_info
         }
     }, ensure_ascii=False) + "\n\n"
     
     await asyncio.sleep(0.01)
     
-    # --- Stage 3: Tool Decision ---
-    tool_decision = enhanced_tool_decision(prompt, intent_info, emotion_info)
-    print(f"🔧 Tool decision: {tool_decision}")
-    
-    yield json.dumps({
-        "type": "context",
-        "data": {
-            "tool_decision": tool_decision,
-            "processing_stage": "tool_decision_made"
-        }
-    }, ensure_ascii=False) + "\n\n"
-    
-    await asyncio.sleep(0.01)
-    
-    # --- Stage 4: Tool Execution ---
-    tool_output = ""
-    if tool_decision.get("use_tool") and tool_decision.get("tool") == "web_search":
-        try:
-            query = tool_decision.get("args", {}).get("query", prompt[:50])
-            print(f"🔍 Executing web search: '{query}'")
-            tool_output = web_search(query)
-            print(f"✅ Search results: {len(tool_output)} chars")
-        except Exception as e:
-            print(f"⚠️ Tool error: {e}")
-            tool_output = f"Search error: {e}"
-    
-    # --- File Processing ---
+    # --- File Processing (unchanged) ---
     file_text = ""
     if files:
         for f in files:
             try:
-                content = await f.read(min(MAX_FILE_SIZE, 1024 * 1024))  # Max 1MB per file
+                content = await f.read(min(MAX_FILE_SIZE, 1024 * 1024))
                 file_text += f"\n--- File: {f.filename} ---\n"
                 file_text += content.decode('utf-8', errors='ignore')[:2000] + "\n"
                 print(f"✅ Processed file: {f.filename}")
             except Exception as e:
                 print(f"⚠️ File error {f.filename}: {e}")
     
-    # ==== ENHANCED LFM2.5 GENERATION WITH EMOTIONAL INTELLIGENCE ====
+    # ==== LFM2.5 GENERATION WITH TOOL CALLING ====
     try:
-        # Build system message with emotional intelligence
-        system_message = f"""You are GAKR AI, a helpful and knowledgeable assistant.
+        # Build system message with tool definition
+        system_message = f"""You are GAKR AI, a helpful assistant with access to tools.
 
-RESPONSE APPROACH:
-- Start with the most direct answer
-- Provide supporting details when helpful
-- Use simple formatting (bullets, bold) for clarity
-- Be accurate and acknowledge uncertainty
+# TOOLS AVAILABLE
+You have access to the following tool:
+- web_search(query): Search the web for current information
 
-CORE PRINCIPLES:
-1. Adapt your tone to match the user's emotional state
-2. Address the specific intent behind the query
-3. Provide accurate, helpful information
-4. Use appropriate formatting for clarity
-5. Acknowledge limitations when uncertain
+# TOOL USAGE INSTRUCTIONS
+1. Use web_search when you need current, factual, or up-to-date information
+2. If the user asks about recent events, news, or facts that may have changed
+3. For general knowledge questions that might benefit from web verification
 
-COMMUNICATION STYLE:
-- Clear and concise
-- Adapt to question complexity
-- Focus on practical usefulness
-- Avoid unnecessary repetition
-EMOTIONAL CONTEXT:
-- Detected user emotional tone: {emotion_info['emotional_tone'].upper()}
-- Primary emotion: {emotion_info['primary_emotion']}
+# CONTEXT
+User Intent: {intent_info['intent_label']} (confidence: {intent_info['confidence']:.1%})
+User Emotion: {emotion_info['primary_emotion']} (confidence: {emotion_info['primary_confidence']:.1%})
 
-INTENT CONTEXT:
-- User intent category: {intent_info['broad_category'].upper()}
-- Specific intent: {intent_info['intent_label']}
+# INSTRUCTIONS
+1. Analyze if the query needs web search
+2. If yes, call web_search with appropriate query
+3. If no, respond directly
+4. Adapt tone to detected emotion
+5. Address the specific intent
 
-Your goal: Provide the most helpful response possible."""
-        
-        
-        # Build context
-        context_parts = []
+File content will be provided separately if available."""
+
+        # Build user message
+        user_message = f"""USER QUERY: {prompt}"""
         
-        if tool_output:
-            context_parts.append(f"SEARCH RESULTS:\n{tool_output}")
         if file_text:
-            context_parts.append(f"FILE CONTENT:\n{file_text}")
-        
-        context = "\n\n".join(context_parts) if context_parts else "No additional context."
+            user_message += f"\n\nFILE CONTENT:{file_text}"
         
-        # Build full user message with all context
-        full_user_message = f"""USER QUERY: {prompt}
-
-ADDITIONAL CONTEXT:
-{context}
-
-USER ANALYSIS:
-- Detected Intent: {intent_info['intent_label']} (confidence: {intent_info['confidence']:.1%})
-- Detected Emotion: {emotion_info['primary_emotion']} (tone: {emotion_info['emotional_tone']})
-- Emotional Confidence: {emotion_info['primary_confidence']:.1%}
-
-Please provide a helpful response that:
-1. Addresses the specific intent ({intent_info['intent_label']})
-2. Appropriately responds to the emotional tone ({emotion_info['emotional_tone']})
-3. Incorporates relevant information from the context
-4. Provides practical, helpful assistance"""
-        
-        # Create messages for LFM2.5 chat template
-        # LFM2.5 uses ChatML format: <|im_start|>role\ncontent<|im_end|>
+        # Create messages with tool definition
         messages = [
             {"role": "system", "content": system_message},
-            {"role": "user", "content": full_user_message}
+            {"role": "user", "content": user_message}
         ]
         
-        print(f"📝 Messages prepared for LFM2.5 chat template")
-        
-        # ====== FIXED SECTION: Proper template application ======
-        # Apply chat template to format the messages
-        formatted_prompt = lfm_tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,  # Don't tokenize yet
-            add_generation_prompt=True,
-        )
+        # Apply chat template
+        try:
+            formatted_prompt = lfm_tokenizer.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=True,
+            )
+        except:
+            # Manual fallback template if apply_chat_template fails
+            formatted_prompt = f"<|im_start|>system\n{system_message}<|im_end|>\n<|im_start|>user\n{user_message}<|im_end|>\n<|im_start|>assistant\n"
         
-        print(f"🔍 Formatted prompt length: {len(formatted_prompt)} characters")
-        print(f"🔍 Sample formatted prompt: {formatted_prompt[:200]}...")
+        print(f"🔍 Formatted prompt length: {len(formatted_prompt)} chars")
         
-        # Tokenize the formatted prompt
+        # First generation pass - check if tool call is needed
         inputs = lfm_tokenizer(
             formatted_prompt,
             return_tensors="pt",
@@ -772,11 +461,7 @@ Please provide a helpful response that:
             max_length=MAX_CONTEXT_LENGTH - max_tokens,
         ).to(DEVICE)
         
-        input_length = inputs['input_ids'].shape[1]
-        print(f"🔍 Tokenized input: {input_length} tokens")
-        # ====== END FIX ======
-        
-        # Create streamer
+        # Create streamer for first pass
         streamer = TextIteratorStreamer(
             lfm_tokenizer,
             skip_prompt=True,
@@ -784,67 +469,180 @@ Please provide a helpful response that:
             timeout=300.0
         )
         
-        # LFM2.5 OPTIMIZED GENERATION PARAMETERS
-        # Based on official recommendations from model card
         generation_config = {
             **inputs,
-            "max_new_tokens": min(max_tokens, MAX_TOKENS_HARD_LIMIT),
+            "max_new_tokens": min(512, max_tokens),  # Limited for first pass
             "do_sample": temperature > 0,
             "temperature": max(0.1, min(temperature, 1.0)),
-            "top_p": 0.1,  # LFM2.5 default
-            "top_k": 50,   # LFM2.5 default
-            "repetition_penalty": 1.05,  # LFM2.5 default
-            "no_repeat_ngram_size": 3,
+            "top_p": 0.1,
+            "top_k": 50,
+            "repetition_penalty": 1.05,
             "pad_token_id": lfm_tokenizer.pad_token_id,
             "eos_token_id": lfm_tokenizer.eos_token_id,
             "streamer": streamer,
-            "use_cache": True,  # Enable KV cache
+            "use_cache": True,
         }
         
-        # For deterministic output when temperature is 0
         if temperature <= 0.1:
             generation_config["do_sample"] = False
-            generation_config.pop("temperature", None)
-            generation_config.pop("top_p", None)
-            generation_config.pop("top_k", None)
         
-        print(f"🔧 Generation params: max_new_tokens={generation_config['max_new_tokens']}, temp={temperature}")
-        print(f"📊 Model will generate with: top_p=0.1, top_k=50, repetition_penalty=1.05")
+        print("🔄 Starting generation (first pass)")
         
         # Start generation thread
         thread = Thread(target=lfm_model.generate, kwargs=generation_config)
         thread.start()
         
-        print("🔄 Started streaming generation")
+        # Collect first pass response
+        first_pass_response = ""
+        for text in streamer:
+            first_pass_response += text
+        
+        thread.join(timeout=2.0)
+        
+        print(f"📝 First pass response: {first_pass_response[:200]}...")
+        
+        # Check for tool call patterns in response
+        # LFM2.5 might format tool calls differently - checking common patterns
+        tool_call_detected = False
+        search_query = None
+        
+        # Check for potential tool call patterns
+        if "search" in first_pass_response.lower() or "look up" in first_pass_response.lower():
+            # Try to extract query from response
+            import re
+            search_patterns = [
+                r"search for ['\"]([^'\"]+)['\"]",
+                r"look up ['\"]([^'\"]+)['\"]",
+                r"query: ['\"]([^'\"]+)['\"]",
+            ]
+            
+            for pattern in search_patterns:
+                match = re.search(pattern, first_pass_response, re.IGNORECASE)
+                if match:
+                    search_query = match.group(1)
+                    tool_call_detected = True
+                    break
+        
+        # If tool call detected, execute and generate final response
+        if tool_call_detected and search_query:
+            print(f"🔍 Tool call detected: web_search('{search_query}')")
+            
+            # Send tool call event
+            yield json.dumps({
+                "type": "tool_call",
+                "data": {
+                    "tool": "web_search",
+                    "query": search_query,
+                    "timestamp": time.time()
+                }
+            }, ensure_ascii=False) + "\n\n"
+            
+            # Execute tool
+            try:
+                search_results = execute_web_search(search_query)
+                print(f"✅ Search executed: {len(search_results)} chars")
+                
+                # Send tool result event
+                yield json.dumps({
+                    "type": "tool_result",
+                    "data": {
+                        "tool": "web_search",
+                        "result_preview": search_results[:100] + "..." if len(search_results) > 100 else search_results,
+                        "timestamp": time.time()
+                    }
+                }, ensure_ascii=False) + "\n\n"
+                
+                # Prepare second generation with tool results
+                tool_message = f"I searched for '{search_query}' and found:\n{search_results}"
+                
+                second_pass_messages = messages + [
+                    {"role": "assistant", "content": first_pass_response},
+                    {"role": "user", "content": tool_message}
+                ]
+                
+                try:
+                    second_pass_prompt = lfm_tokenizer.apply_chat_template(
+                        second_pass_messages,
+                        tokenize=False,
+                        add_generation_prompt=True,
+                    )
+                except:
+                    second_pass_prompt = formatted_prompt + first_pass_response + f"\n<|im_end|>\n<|im_start|>user\n{tool_message}<|im_end|>\n<|im_start|>assistant\n"
+                
+            except Exception as e:
+                print(f"⚠️ Tool execution error: {e}")
+                # If tool fails, continue with original response
+                second_pass_prompt = formatted_prompt
+                tool_call_detected = False
+        
+        else:
+            # No tool call needed, use first pass response
+            print("✅ No tool call needed, using direct response")
+            second_pass_prompt = formatted_prompt
+            tool_call_detected = False
+        
+        # Final generation (streaming)
+        final_inputs = lfm_tokenizer(
+            second_pass_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=MAX_CONTEXT_LENGTH - max_tokens,
+        ).to(DEVICE)
+        
+        final_streamer = TextIteratorStreamer(
+            lfm_tokenizer,
+            skip_prompt=True,
+            skip_special_tokens=True,
+            timeout=300.0
+        )
+        
+        final_config = {
+            **final_inputs,
+            "max_new_tokens": min(max_tokens, MAX_TOKENS_HARD_LIMIT),
+            "do_sample": temperature > 0,
+            "temperature": max(0.1, min(temperature, 1.0)),
+            "top_p": 0.1,
+            "top_k": 50,
+            "repetition_penalty": 1.05,
+            "pad_token_id": lfm_tokenizer.pad_token_id,
+            "eos_token_id": lfm_tokenizer.eos_token_id,
+            "streamer": final_streamer,
+            "use_cache": True,
+        }
+        
+        if temperature <= 0.1:
+            final_config["do_sample"] = False
+        
+        print("🔄 Starting final generation")
         
         # Send streaming start signal
         yield json.dumps({
             "type": "streaming_start",
             "data": {
                 "timestamp": time.time(),
-                "intent": intent_info,
-                "emotion": emotion_info,
-                "model": LFM_MODEL_NAME
+                "tool_called": tool_call_detected
             }
         }, ensure_ascii=False) + "\n\n"
         
-        # Stream tokens
+        # Start final generation thread
+        final_thread = Thread(target=lfm_model.generate, kwargs=final_config)
+        final_thread.start()
+        
+        # Stream final response
         buffer = ""
         token_count = 0
         start_time = time.time()
         
-        for new_text in streamer:
+        for new_text in final_streamer:
             if new_text:
                 buffer += new_text
                 token_count += 1
                 
-                # Send token
                 yield json.dumps({
                     "type": "token",
                     "data": new_text
                 }, ensure_ascii=False) + "\n\n"
                 
-                # Small delay for smooth streaming
                 await asyncio.sleep(0.005)
         
         # Calculate stats
@@ -853,31 +651,23 @@ Please provide a helpful response that:
         
         print(f"✅ Generation complete: {token_count} tokens, {tokens_per_sec:.1f} t/s")
         
-        # Send completion with analysis
+        # Send completion
         yield json.dumps({
             "type": "done",
             "data": {
                 "tokens": token_count,
-                "chars": len(buffer),
                 "elapsed": round(elapsed, 2),
-                "tokens_per_sec": round(tokens_per_sec, 1),
+                "tool_used": "web_search" if tool_call_detected else None,
                 "intent": intent_info,
-                "emotion": emotion_info,
-                "tool_used": tool_decision.get("tool"),
-                "model": LFM_MODEL_NAME,
-                "response_characteristics": {
-                    "emotion_aware": True,
-                    "intent_aware": True,
-                    "context_informed": bool(tool_output or file_text)
-                }
+                "emotion": emotion_info
             }
         }, ensure_ascii=False) + "\n\n"
         
         # Clean up thread
-        thread.join(timeout=2.0)
+        final_thread.join(timeout=2.0)
         
     except torch.cuda.OutOfMemoryError:
-        error_msg = "CUDA out of memory. Try reducing max_tokens or using CPU."
+        error_msg = "CUDA out of memory. Try reducing max_tokens."
         print(f"❌ {error_msg}")
         yield json.dumps({
             "type": "error",
@@ -901,8 +691,6 @@ async def home(request: Request):
     return templates.TemplateResponse("index.html", {
         "request": request,
         "model_name": "LFM2.5-1.2B-Instruct",
-        "intent_model": INTENT_MODEL_NAME,
-        "emotion_model": EMOTION_MODEL_NAME,
         "environment": ENVIRONMENT
     })
 
@@ -914,23 +702,22 @@ async def analyze(
     temperature: float = Form(DEFAULT_TEMPERATURE),
 ):
     """
-    Main analysis endpoint with enhanced intent and emotion detection
+    Main analysis endpoint with LFM2.5 tool calling
     """
     if not prompt and not files:
         raise HTTPException(400, "Empty prompt and no files provided")
     
-    # Validate
     max_tokens = min(max_tokens, MAX_TOKENS_HARD_LIMIT)
     temperature = max(0.1, min(temperature, 2.0))
     
     print(f"\n📨 Request: '{prompt[:50]}...' | tokens={max_tokens} | temp={temperature}")
     
     if not lfm_model:
-        raise HTTPException(503, "LFM2.5 model not loaded. Check server health.")
+        raise HTTPException(503, "LFM2.5 model not loaded.")
     
     async def event_stream():
         try:
-            async for chunk in generate_reply_stream(prompt, files or [], max_tokens, temperature):
+            async for chunk in generate_with_tool_calling(prompt, files or [], max_tokens, temperature):
                 yield f"data: {chunk}\n\n"
         except Exception as e:
             yield f"data: {json.dumps({'type': 'error', 'data': str(e)[:200]}, ensure_ascii=False)}\n\n"
@@ -960,43 +747,12 @@ async def health():
             "lfm_loaded": lfm_model is not None
         },
         "device": DEVICE,
-        "cuda_available": torch.cuda.is_available(),
-        "max_context": MAX_CONTEXT_LENGTH,
         "timestamp": datetime.now(timezone.utc).isoformat()
     }
 
-@app.get("/api/config")
-async def config():
-    """Configuration endpoint"""
-    return {
-        "models": {
-            "main_model": LFM_MODEL_NAME,
-            "intent_model": INTENT_MODEL_NAME,
-            "emotion_model": EMOTION_MODEL_NAME
-        },
-        "capabilities": {
-            "intent_classes": 82,
-            "emotion_labels": 28,
-            "emotion_tone_mapping": list(EMOTION_TONE_MAPPING.keys())
-        },
-        "limits": {
-            "max_tokens": MAX_TOKENS_HARD_LIMIT,
-            "max_context": MAX_CONTEXT_LENGTH,
-            "default_temperature": DEFAULT_TEMPERATURE
-        },
-        "features": [
-            "intent_detection", 
-            "emotion_detection", 
-            "emotional_intelligence",
-            "tool_integration", 
-            "file_upload", 
-            "streaming"
-        ]
-    }
-
 @app.get("/api/model-info")
 async def model_info():
-    """Detailed model information"""
+    """Model information"""
     info = {
         "models": {
             "lfm2.5": {
@@ -1004,135 +760,23 @@ async def model_info():
                 "publisher": "Liquid AI",
                 "parameters": "1.2B",
                 "context_length": "32,768 tokens",
-                "license": "Apache 2.0",
-                "description": "Hybrid model designed for on-device deployment with extended pre-training and reinforcement learning",
-                "capabilities": ["Reasoning", "Coding", "Mathematics", "Multilingual (8 languages)", "Tool Use"],
-                "optimized_for": ["Edge deployment", "Low-latency applications", "Memory-constrained environments"],
-                "default_generation_params": {
-                    "temperature": 0.1,
-                    "top_p": 0.1,
-                    "top_k": 50,
-                    "repetition_penalty": 1.05
-                },
-                "chat_template": "ChatML format (<|im_start|>role\\ncontent<|im_end|>)",
-                "special_tokens": ["<|im_start|>", "<|im_end|>", "<|endoftext|>"]
+                "tool_calling": "native",
+                "description": "Model with built-in tool calling capabilities"
             },
             "intent_detector": {
                 "name": "AshokGakr/intent_detector",
-                "classes": 82,
-                "accuracy": "98.04% (validation)",
-                "datasets": [
-                    "mteb/amazon_massive_intent",
-                    "mteb/mtop_intent", 
-                    "sonos-nlu-benchmark/snips_built_in_intents",
-                    "Mozilla/smart_intent_dataset",
-                    "Bhuvaneshwari/intent_classification",
-                    "clinc/clinc_oos"
-                ]
+                "classes": 82
             },
             "emotion_detector": {
                 "name": "AshokGakr/emotions_detector",
                 "labels": 28,
-                "type": "multi-label classification",
-                "base_model": "roberta-base",
-                "dataset": "go_emotions (Reddit data)",
-                "best_f1": "0.611 (weighted)"
+                "type": "multi-label classification"
             }
         }
     }
     
-    if lfm_model:
-        info["models"]["lfm2.5"].update({
-            "loaded": True,
-            "device": str(lfm_model.device),
-            "dtype": str(lfm_model.dtype),
-            "tokenizer_chat_template": lfm_tokenizer.chat_template is not None
-        })
-    
-    if intent_model:
-        info["models"]["intent_detector"]["loaded"] = True
-    
-    if emotion_model:
-        info["models"]["emotion_detector"]["loaded"] = True
-    
     return info
 
-@app.post("/api/detect-intent")
-async def detect_intent_endpoint(text: str = Form(...)):
-    """Standalone intent detection endpoint"""
-    if not text:
-        raise HTTPException(400, "Text is required")
-    
-    result = detect_intent_enhanced(text)
-    return result
-
-@app.post("/api/detect-emotion")
-async def detect_emotion_endpoint(text: str = Form(...)):
-    """Standalone emotion detection endpoint"""
-    if not text:
-        raise HTTPException(400, "Text is required")
-    
-    result = detect_emotion_enhanced(text)
-    return result
-
-@app.post("/api/test-lfm-template")
-async def test_lfm_template(text: str = Form(...), system_prompt: str = Form(None)):
-    """Test LFM2.5 chat template formatting"""
-    if not lfm_tokenizer:
-        raise HTTPException(503, "LFM2.5 tokenizer not loaded")
-    
-    system_msg = system_prompt or "You are a helpful AI assistant."
-    
-    messages = [
-        {"role": "system", "content": system_msg},
-        {"role": "user", "content": text}
-    ]
-    
-    try:
-        # Apply chat template
-        formatted = lfm_tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True
-        )
-        
-        # Decode to see the format
-        decoded = lfm_tokenizer.decode(lfm_tokenizer.encode(formatted), skip_special_tokens=False)
-        
-        return {
-            "formatted_template": formatted,
-            "decoded": decoded,
-            "messages": messages,
-            "special_tokens": {
-                "im_start": "<|im_start|>",
-                "im_end": "<|im_end|>",
-                "eos_token": lfm_tokenizer.eos_token,
-                "pad_token": lfm_tokenizer.pad_token
-            }
-        }
-    except Exception as e:
-        raise HTTPException(500, f"Template error: {str(e)}")
-
-@app.get("/api/debug-stream")
-async def debug_stream():
-    """Test streaming with intent/emotion simulation"""
-    async def event_stream():
-        yield f"data: {json.dumps({'type': 'context', 'data': {'test': 'LFM2.5 streaming test', 'intent': {'intent_label': 'greeting', 'confidence': 0.95}, 'emotion': {'primary_emotion': 'joy', 'emotional_tone': 'positive'}}}, ensure_ascii=False)}\n\n"
-        
-        test_msg = "This is a streaming test from LFM2.5-1.2B-Instruct backend with intent and emotion awareness. "
-        words = test_msg.split()
-        
-        for i, word in enumerate(words):
-            yield f"data: {json.dumps({'type': 'token', 'data': word + ' '}, ensure_ascii=False)}\n\n"
-            await asyncio.sleep(0.1)
-        
-        yield f"data: {json.dumps({'type': 'done', 'data': {'test': 'complete', 'intent_aware': True, 'emotion_aware': True}}, ensure_ascii=False)}\n\n"
-    
-    return StreamingResponse(
-        event_stream(),
-        media_type="text/event-stream"
-    )
-
 # ================== ERROR HANDLERS =================
 
 @app.exception_handler(HTTPException)
@@ -1145,7 +789,6 @@ async def http_exception_handler(request: Request, exc: HTTPException):
 @app.exception_handler(Exception)
 async def generic_exception_handler(request: Request, exc: Exception):
     print(f"❌ Unhandled: {exc}")
-    traceback.print_exc()
     return JSONResponse(
         status_code=500,
         content={"error": "Internal server error"}
@@ -1157,13 +800,11 @@ if __name__ == "__main__":
     import uvicorn
     
     print("\n" + "="*50)
-    print("🔧 ENHANCED GAKR AI - LFM2.5 WITH INTENT & EMOTION DETECTION")
+    print("🔧 GAKR AI - LFM2.5 WITH TOOL CALLING")
     print("="*50)
-    print(f"🎯 Intent Model: {INTENT_MODEL_NAME} (82 classes)")
-    print(f"😊 Emotion Model: {EMOTION_MODEL_NAME} (28 labels)")
     print(f"🧠 LFM2.5 Model: {LFM_MODEL_NAME}")
     print(f"⚡ Context Window: 32,768 tokens")
-    print(f"🏗️ Chat Template: ChatML format")
+    print(f"🛠️ Tool Calling: Native")
     print("="*50)
     
     uvicorn.run(