Initialize AI models and agents with CPU-optimized models

config/config.py

@@ -6,22 +6,22 @@ def load_config() -> Dict:
     return {
         "MODEL_CONFIGS": {
             "conversation": {
-                "model_id": "TheBloke/Llama-2-7B-Chat-GGUF",
+                "model_id": "facebook/opt-125m",
                 "max_length": 2048,
                 "temperature": 0.7,
             },
             "emotion_detection": {
-                "model_id": "bhadresh-savani/bert-base-uncased-emotion",
+                "model_id": "j-hartmann/emotion-english-distilroberta-base",
             },
             "speech_to_text": {
-                "model_id": "openai/whisper-base",
+                "model_id": "openai/whisper-tiny",
             },
             "vision": {
-                "model_id": "microsoft/resnet-50",
+                "model_id": "microsoft/resnet-18",
             }
         },
         "INTERFACE_CONFIG": {
-            "theme": "light",
+            "theme": "soft",
             "supported_languages": ["en"],
             "max_file_size_mb": 10,
             "supported_file_types": [

interface/app.py

@@ -2,8 +2,13 @@ import os
 import torch
 import gradio as gr
 import logging
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
 from utils.log_manager import LogManager
 from utils.analytics_logger import AnalyticsLogger
+from agents.conversation_agent import ConversationAgent
+from agents.assessment_agent import AssessmentAgent
+from agents.mindfulness_agent import MindfulnessAgent
+from agents.crisis_agent import CrisisAgent
 
 # Force CPU-only mode
 torch.cuda.is_available = lambda: False
@@ -21,9 +26,65 @@ class WellnessInterface:
         self.device = "cpu"
         self.logger.info("Using CPU-only mode")
         
+        # Initialize models
+        self.initialize_models()
+        
+        # Initialize agents
+        self.initialize_agents()
+        
         # Initialize interface
         self.setup_interface()
         
+    def initialize_models(self):
+        """Initialize AI models"""
+        self.logger.info("Initializing AI models")
+        try:
+            # Initialize emotion detection model
+            self.emotion_model = pipeline(
+                "text-classification",
+                model=self.config["MODEL_CONFIGS"]["emotion_detection"]["model_id"],
+                device=self.device
+            )
+            
+            # Initialize conversation model
+            self.conversation_tokenizer = AutoTokenizer.from_pretrained(
+                self.config["MODEL_CONFIGS"]["conversation"]["model_id"]
+            )
+            self.conversation_model = AutoModelForCausalLM.from_pretrained(
+                self.config["MODEL_CONFIGS"]["conversation"]["model_id"],
+                device_map={"": self.device}
+            )
+            
+            self.logger.info("AI models initialized successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Error initializing models: {str(e)}")
+            raise
+            
+    def initialize_agents(self):
+        """Initialize AI agents"""
+        self.logger.info("Initializing AI agents")
+        try:
+            # Initialize all agents
+            self.conversation_agent = ConversationAgent(
+                model_config=self.config["MODEL_CONFIGS"]
+            )
+            self.assessment_agent = AssessmentAgent(
+                model_config=self.config["MODEL_CONFIGS"]
+            )
+            self.mindfulness_agent = MindfulnessAgent(
+                model_config=self.config["MODEL_CONFIGS"]
+            )
+            self.crisis_agent = CrisisAgent(
+                model_config=self.config["MODEL_CONFIGS"]
+            )
+            
+            self.logger.info("AI agents initialized successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Error initializing agents: {str(e)}")
+            raise
+            
     def setup_interface(self):
         """Setup the Gradio interface components"""
         self.logger.info("Setting up interface components")
@@ -171,13 +232,27 @@ class WellnessInterface:
                 }}
             )
             
-            # Process the input (placeholder)
-            response = "I understand and I'm here to help. Could you tell me more about how you're feeling?"
+            # Analyze emotion if text is present
+            emotion = None
+            if text:
+                emotion_result = self.emotion_model(text)
+                emotion = emotion_result[0] if emotion_result else None
+                self.logger.info(f"Detected emotion: {emotion}")
+            
+            # Route to appropriate agent based on content and emotion
+            if emotion and emotion.get("label") in ["anxiety", "fear", "panic"]:
+                response = self.crisis_agent.process_message(text)
+            elif "meditate" in text.lower() or "mindfulness" in text.lower():
+                response = self.mindfulness_agent.process_message(text)
+            elif "assess" in text.lower() or "check" in text.lower():
+                response = self.assessment_agent.process_message(text)
+            else:
+                response = self.conversation_agent.process_message(text)
             
             # Add to chat history using message format
             history = history or []
             history.append({"role": "user", "content": text if text else "Sent media"})
-            history.append({"role": "assistant", "content": response})
+            history.append({"role": "assistant", "content": response["message"]})
             
             return history, ""  # Return empty string to clear text input