refactore the code files to use TinyGPT2Model

agents/tools/llm_tools.py

@@ -1,12 +1,13 @@
 """
 Mistral LLM Tools for CrewAI (modular class version)
 """
-from models.mistral_model import MistralModel
+#from models.mistral_model import MistralModel
+from models.tinygpt2_model import TinyGPT2Model
 
 class LLMTools:
     def __init__(self, config=None):
         self.config = config
-        self.model = MistralModel()
+        self.model =TinyGPT2Model()
 
     def mistral_chat(self, prompt: str, context: dict = None) -> str:
         """Chat with Mistral AI for intelligent responses."""

agents/tools/voice_tools.py

@@ -5,7 +5,8 @@ from transformers import pipeline, AutoProcessor, AutoModelForSpeechSeq2Seq
 import asyncio
 import soundfile as sf
 import tempfile  # Added the import for tempfile!
-from models.mistral_model import MistralModel
+#from models.mistral_model import MistralModel
+from models.tinygpt2_model import TinyGPT2Model
 
 class MultilingualVoiceProcessor:
     def __init__(self, model_name="openai/whisper-base", device=None):
@@ -48,7 +49,7 @@ class VoiceTools:
         return {"text": text, "language": detected_lang}
 
     def detect_emotion(self, text: str) -> dict:
-        model = MistralModel()
+        model = TinyGPT2Model()
         prompt = f"""
         Analyze the emotional state in this text: "{text}"
         Identify:

agents/tools/voice_tools_openaiwhisper.py

@@ -3,7 +3,7 @@ Multilingual Voice Processing Tools - modular class version
 """
 import numpy as np
 import asyncio
-from models.mistral_model import MistralModel
+#from models.mistral_model import MistralModel
 import whisper
 import numpy as np
 from gtts import gTTS
@@ -15,6 +15,7 @@ from typing import Tuple, Optional
 import speech_recognition as sr
 from transformers import pipeline
 import whisper
+from models.tinygpt2_model import TinyGPT2Model
 
 # class MultilingualVoiceProcessor:
 #     """Handles multilingual STT and TTS"""
@@ -135,7 +136,7 @@ class VoiceTools:
 
     def detect_emotion(self, text: str) -> dict:
         """Detect emotional state from text using LLM."""
-        model = MistralModel()
+        model = TinyGPT2Model()
         prompt = f"""
         Analyze the emotional state in this text: "{text}"
         Identify:

models/_init_.py

@@ -12,6 +12,7 @@ __version__ = "1.0.0"
 # Lazy imports
 if TYPE_CHECKING:
     from .mistral_model import MistralModel, MistralConfig, MistralPromptFormatter
+    from .tiny_gpt2_model import TinyGPT2Model
 
 # Public API
 __all__ = [
@@ -19,12 +20,13 @@ __all__ = [
     "MistralModel",
     "MistralConfig", 
     "MistralPromptFormatter",
-    
+    "TinyGPT2Model",
+
     # Model management
     "load_model",
     "get_model_info",
     "clear_model_cache",
-    
+
     # Constants
     "AVAILABLE_MODELS",
     "MODEL_REQUIREMENTS",
@@ -46,6 +48,13 @@ AVAILABLE_MODELS = {
         "size": "7B", 
         "context_length": 32768,
         "languages": ["multilingual"]
+    },
+    "tiny-gpt2": {
+        "model_id": "sshleifer/tiny-gpt2",
+        "type": "tiny",
+        "size": "small",
+        "context_length": 256,
+        "languages": ["en"]
     }
 }
 
@@ -56,19 +65,25 @@ MODEL_REQUIREMENTS = {
         "vram": "8GB (GPU) or 16GB (CPU)",
         "disk": "15GB",
         "compute": "GPU recommended"
+    },
+    "tiny-gpt2": {
+        "ram": "≤1GB",
+        "vram": "CPU only",
+        "disk": "<1GB",
+        "compute": "CPU"
     }
 }
 
-# Default configuration
+# Default configuration: Set to CPU/float32
 DEFAULT_MODEL_CONFIG = {
-    "max_length": 2048,
+    "max_length": 256,
     "temperature": 0.7,
     "top_p": 0.95,
     "top_k": 50,
     "do_sample": True,
     "num_return_sequences": 1,
-    "device": "cuda" if torch.cuda.is_available() else "cpu",
-    "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32,
+    "device": "cpu",
+    "torch_dtype": torch.float32,
     "load_in_8bit": False,
     "cache_dir": ".cache/models"
 }
@@ -76,10 +91,10 @@ DEFAULT_MODEL_CONFIG = {
 # Model instance cache
 _model_cache: Dict[str, Any] = {}
 
-def load_model(model_name: str = "mistral-7b-instruct", config: Optional[Dict[str, Any]] = None):
+def load_model(model_name: str = "tiny-gpt2", config: Optional[Dict[str, Any]] = None):
     """
     Load a model with caching support
-    
+
     Args:
         model_name: Name of the model to load
         config: Optional configuration override
@@ -91,41 +106,39 @@ def load_model(model_name: str = "mistral-7b-instruct", config: Optional[Dict[st
     cache_key = f"{model_name}_{str(config)}"
     if cache_key in _model_cache:
         return _model_cache[cache_key]
-    
+
     # Import here to avoid circular imports
-    from .mistral_model import MistralModel, MistralConfig
-    
-    # Get model info
-    model_info = AVAILABLE_MODELS.get(model_name)
-    if not model_info:
+    if model_name == "tiny-gpt2":
+        from .tiny_gpt2_model import TinyGPT2Model
+        # No config needed for TinyGPT2, ignore config for now
+        model = TinyGPT2Model()
+    elif model_name in ["mistral-7b-instruct", "mistral-7b"]:
+        from .mistral_model import MistralModel, MistralConfig
+        model_info = AVAILABLE_MODELS.get(model_name)
+        if not model_info:
+            raise ValueError(f"Unknown model: {model_name}")
+        model_config = DEFAULT_MODEL_CONFIG.copy()
+        if config:
+            model_config.update(config)
+        mistral_config = MistralConfig(
+            model_id=model_info["model_id"],
+            **model_config
+        )
+        model = MistralModel(mistral_config)
+    else:
         raise ValueError(f"Unknown model: {model_name}")
-    
-    # Merge configurations
-    model_config = DEFAULT_MODEL_CONFIG.copy()
-    if config:
-        model_config.update(config)
-    
-    # Create config object
-    mistral_config = MistralConfig(
-        model_id=model_info["model_id"],
-        **model_config
-    )
-    
-    # Load model
-    model = MistralModel(mistral_config)
-    
+
     # Cache it
     _model_cache[cache_key] = model
-    
     return model
 
 def get_model_info(model_name: str) -> Optional[Dict[str, Any]]:
     """
     Get information about a model
-    
+
     Args:
         model_name: Name of the model
-        
+
     Returns:
         Model information dictionary or None
     """
@@ -133,23 +146,24 @@ def get_model_info(model_name: str) -> Optional[Dict[str, Any]]:
     if info:
         # Add requirements
         requirements = MODEL_REQUIREMENTS.get(model_name, {})
+        info = info.copy() # avoid mutating global dict!
         info["requirements"] = requirements
-        
+
         # Add loading status
         cache_keys = [k for k in _model_cache.keys() if k.startswith(model_name)]
         info["is_loaded"] = len(cache_keys) > 0
-        
+
     return info
 
 def clear_model_cache(model_name: Optional[str] = None):
     """
     Clear model cache to free memory
-    
+
     Args:
         model_name: Specific model to clear, or None for all
     """
     global _model_cache
-    
+
     if model_name:
         # Clear specific model
         keys_to_remove = [k for k in _model_cache.keys() if k.startswith(model_name)]
@@ -158,11 +172,11 @@ def clear_model_cache(model_name: Optional[str] = None):
     else:
         # Clear all
         _model_cache.clear()
-    
+
     # Force garbage collection
     import gc
     gc.collect()
-    
+
     # Clear GPU cache if using CUDA
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
@@ -171,20 +185,25 @@ def clear_model_cache(model_name: Optional[str] = None):
 def estimate_memory_usage(model_name: str) -> Dict[str, Any]:
     """
     Estimate memory usage for a model
-    
+
     Args:
         model_name: Name of the model
-        
+
     Returns:
         Memory estimation dictionary
     """
     model_info = AVAILABLE_MODELS.get(model_name)
     if not model_info:
         return {}
-    
+
     size = model_info.get("size", "7B")
-    size_gb = float(size.replace("B", ""))
-    
+    if size.endswith("B"):
+        size_gb = float(size.replace("B", ""))  # e.g. "7B"
+    elif size == "small":
+        size_gb = 0.02  # Arbitrary tiny model size in GB
+    else:
+        size_gb = 0.1  # catchall
+
     estimates = {
         "model_size_gb": size_gb,
         "fp32_memory_gb": size_gb * 4,  # 4 bytes per parameter
@@ -193,7 +212,7 @@ def estimate_memory_usage(model_name: str) -> Dict[str, Any]:
         "recommended_ram_gb": size_gb * 2.5,
         "recommended_vram_gb": size_gb * 1.5
     }
-    
+
     return estimates
 
 def get_device_info() -> Dict[str, Any]:
@@ -204,14 +223,14 @@ def get_device_info() -> Dict[str, Any]:
         "current_device": torch.cuda.current_device() if torch.cuda.is_available() else None,
         "device_name": torch.cuda.get_device_name() if torch.cuda.is_available() else "CPU"
     }
-    
+
     if torch.cuda.is_available():
         info["gpu_memory"] = {
             "allocated": torch.cuda.memory_allocated() / 1024**3,  # GB
             "reserved": torch.cuda.memory_reserved() / 1024**3,    # GB
             "total": torch.cuda.get_device_properties(0).total_memory / 1024**3  # GB
         }
-    
+
     return info
 
 # Module initialization