Refactor: Remove smoke tests, fix Pi-3.1 API calls, update dependencies

- Removed all smoke tests from AI agents
- Fixed Pi-3.1 API calls (removed System type, use Human/Assistant only)
- Updated transformers to 4.57.1 (fixes resume_download warning)
- Updated PyTorch to 2.8.0 (fixes pytree compatibility)
- Improved error handling in LLM wrapper
- Refactored codebase into modular agent structure

agents/__init__.py

@@ -0,0 +1,17 @@
+"""Agents package"""
+from .memory_agent import MemoryAgent
+from .gemini_agent import GeminiThinkingAgent
+from .pi_agent import PiResponseAgent
+from .emotional_agent import EmotionalStateAgent
+from .azure_agent import AzureTextAnalyticsAgent
+from .sentiment_agent import SentimentAgent
+
+__all__ = [
+    'MemoryAgent',
+    'GeminiThinkingAgent',
+    'PiResponseAgent',
+    'EmotionalStateAgent',
+    'AzureTextAnalyticsAgent',
+    'SentimentAgent'
+]
+

agents/azure_agent.py

@@ -0,0 +1,64 @@
+"""Azure Text Analytics Agent - responsible for Azure Text Analytics sentiment analysis"""
+import os
+import sys
+import logging
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import MODEL_CONFIG
+
+class AzureTextAnalyticsAgent:
+    """Agent responsible for Azure Text Analytics sentiment analysis"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.azure_available = False
+        self.client = None
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize Azure Text Analytics client"""
+        try:
+            from azure.ai.textanalytics import TextAnalyticsClient
+            from azure.core.credentials import AzureKeyCredential
+            
+            key = os.getenv("AZURE_TEXT_ANALYTICS_KEY")
+            endpoint = os.getenv("AZURE_TEXT_ANALYTICS_ENDPOINT")
+            
+            if key and endpoint:
+                try:
+                    credential = AzureKeyCredential(key)
+                    self.client = TextAnalyticsClient(endpoint=endpoint, credential=credential)
+                    self.azure_available = True
+                    logging.info("[AzureTextAnalyticsAgent] ✓ Initialized and ready")
+                except Exception as e:
+                    logging.warning(f"[AzureTextAnalyticsAgent] Failed to create client: {e}")
+                    self.azure_available = False
+            else:
+                logging.warning("[AzureTextAnalyticsAgent] ✗ Azure credentials not found")
+                self.azure_available = False
+        except ImportError:
+            logging.warning("[AzureTextAnalyticsAgent] ✗ Azure SDK not installed")
+            self.azure_available = False
+    
+    def analyze(self, text):
+        """Analyze sentiment using Azure Text Analytics"""
+        if not self.azure_available or not self.client:
+            return None
+        
+        try:
+            result = self.client.analyze_sentiment(documents=[text])[0]
+            if result.sentiment == 'positive':
+                return result.confidence_scores.positive
+            elif result.sentiment == 'negative':
+                return -result.confidence_scores.negative
+            else:
+                return 0.0
+        except Exception as e:
+            logging.error(f"[AzureTextAnalyticsAgent] Error: {e}")
+            return None
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.azure_available
+

agents/emotional_agent.py

@@ -0,0 +1,100 @@
+"""Emotional State Agent - responsible for managing and updating emotional state"""
+import os
+import sys
+import random
+import logging
+import requests
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import MODEL_CONFIG
+
+class EmotionalStateAgent:
+    """Agent responsible for managing and updating emotional state"""
+    
+    def __init__(self, initial_state=None, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.emotional_state = initial_state or {"joy": 0.2, "sadness": 0.2, "anger": 0.2, "fear": 0.2, "curiosity": 0.2}
+        self.learning_rate = 0.05
+        self.quantum_random_available = False
+        self.quantum_api_key = None
+        self._initialize_quantum()
+    
+    def _initialize_quantum(self):
+        """Initialize quantum randomness availability"""
+        quantum_key = os.getenv("ANU_QUANTUM_API_KEY")
+        if quantum_key:
+            self.quantum_api_key = quantum_key
+            self.quantum_random_available = True
+            logging.info("[EmotionalStateAgent] ✓ Quantum randomness available")
+        else:
+            logging.warning("[EmotionalStateAgent] Quantum randomness unavailable")
+    
+    def get_quantum_random_float(self, min_val=0.0, max_val=1.0):
+        """Get a quantum random float between min_val and max_val"""
+        if not self.quantum_random_available:
+            return random.uniform(min_val, max_val)
+        
+        try:
+            quantum_config = self.config.get('quantum', {}) if self.config else {}
+            url = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
+            headers = {"x-api-key": self.quantum_api_key}
+            params = {"length": 1, "type": "uint8"}
+            
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get('success') and 'data' in result and len(result['data']) > 0:
+                    normalized = result['data'][0] / 255.0
+                    return min_val + (max_val - min_val) * normalized
+        except Exception as e:
+            logging.warning(f"[EmotionalStateAgent] Quantum API failed: {e}")
+        
+        return random.uniform(min_val, max_val)
+    
+    def update_with_sentiment(self, sentiment_score):
+        """Update emotional state based on sentiment"""
+        # Enhanced Emotion Update (decay and normalization with quantum randomness)
+        decay_factor = 0.9
+        if self.quantum_random_available:
+            quantum_decay_variation = self.get_quantum_random_float(0.85, 0.95)
+            decay_factor = quantum_decay_variation
+        
+        for emotion in self.emotional_state:
+            # Decay emotions (more realistic fading with quantum variation)
+            self.emotional_state[emotion] *= decay_factor
+            # Normalize
+            self.emotional_state[emotion] = max(0.0, min(1.0, self.emotional_state[emotion]))
+
+        # Apply sentiment with quantum-enhanced learning rate variation
+        learning_rate = self.learning_rate
+        if self.quantum_random_available:
+            quantum_lr_variation = self.get_quantum_random_float(0.03, 0.07)
+            learning_rate = quantum_lr_variation
+        
+        self.emotional_state["joy"] += sentiment_score * learning_rate
+        self.emotional_state["sadness"] -= sentiment_score * learning_rate
+        
+        # Add quantum randomness to curiosity (making responses more unpredictable)
+        if self.quantum_random_available:
+            quantum_curiosity_boost = self.get_quantum_random_float(-0.05, 0.05)
+            self.emotional_state["curiosity"] = max(0.0, min(1.0, 
+                self.emotional_state["curiosity"] + quantum_curiosity_boost))
+
+        # Re-normalize
+        total_emotion = sum(self.emotional_state.values())
+        for emotion in self.emotional_state:
+            self.emotional_state[emotion] = self.emotional_state[emotion] / total_emotion if total_emotion > 0 else 0.2
+        
+        logging.info(f"[EmotionalStateAgent] Updated emotional state: {self.emotional_state}")
+        return self.emotional_state
+    
+    def get_state(self):
+        """Get current emotional state"""
+        return self.emotional_state.copy()
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return True  # Emotional state is always ready
+

agents/gemini_agent.py

@@ -0,0 +1,113 @@
+"""Gemini Thinking Agent - responsible for thinking and analysis using Gemini"""
+import os
+import sys
+import logging
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import MODEL_CONFIG
+from llm_wrapper import LLMWrapper
+
+class GeminiThinkingAgent:
+    """Agent responsible for thinking and analysis using Gemini"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.gemini_available = False
+        
+        # Get model from config
+        gemini_config = self.config.get('gemini', {}) if self.config else {}
+        gemini_model = gemini_config.get('model', 'gemini-2.0-flash-exp')
+        
+        # Initialize LLM wrapper with the model
+        self.llm_wrapper = LLMWrapper(gemini_model=gemini_model, config=self.config)
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize Gemini API availability"""
+        gemini_key = os.getenv("GEMINI_API_KEY")
+        if gemini_key:
+            self.gemini_available = True
+            logging.info("[GeminiThinkingAgent] ✓ Initialized and ready")
+        else:
+            logging.warning("[GeminiThinkingAgent] ✗ GEMINI_API_KEY not found")
+    
+    def think(self, user_input, emotional_state, conversation_history, retrieved_memories=None):
+        """Think about and analyze the conversation context"""
+        if not self.gemini_available:
+            logging.warning("[GeminiThinkingAgent] Not available")
+            return None
+        
+        try:
+            # Build thinking prompt with conversation context
+            emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
+            
+            # Prepare conversation context for thinking
+            context_summary = ""
+            if conversation_history:
+                recent_history = conversation_history[-6:]  # Last 3 exchanges
+                context_summary = "\nRecent conversation:\n"
+                for msg in recent_history:
+                    role = "User" if msg["role"] == "user" else "Galatea"
+                    context_summary += f"{role}: {msg['content']}\n"
+            
+            # Add retrieved memories if available
+            memory_context = ""
+            if retrieved_memories and len(retrieved_memories) > 0:
+                memory_context = "\n\nRelevant memories from past conversations:\n"
+                for i, memory in enumerate(retrieved_memories[:3], 1):  # Top 3 most relevant
+                    memory_context += f"{i}. {memory['text'][:200]}...\n"
+            
+            thinking_prompt = f"""You are the internal reasoning system for Galatea, an AI assistant.
+
+Current emotional state: {emotions_text}
+{context_summary}
+{memory_context}
+Current user message: "{user_input}"
+
+Analyze this conversation and provide:
+1. Key insights about what the user is asking or discussing
+2. Important context from the conversation history and retrieved memories
+3. How Galatea should respond emotionally and contextually
+4. Any important details to remember or reference
+
+Keep your analysis concise (2-3 sentences). Focus on what matters for crafting an appropriate response."""
+            
+            messages = [
+                {"role": "system", "content": "You are an internal reasoning system. Analyze conversations and provide insights."},
+                {"role": "user", "content": thinking_prompt}
+            ]
+            
+            logging.info("[GeminiThinkingAgent] Processing thinking request...")
+            
+            # Get hyperparameters from config
+            gemini_config = self.config.get('gemini', {}) if self.config else {}
+            temperature = gemini_config.get('temperature', 0.5)
+            max_tokens = gemini_config.get('max_tokens', 200)
+            
+            # Call Gemini model (model is set in wrapper initialization)
+            try:
+                thinking_result = self.llm_wrapper.call_gemini(
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens
+                )
+                
+                if thinking_result and len(thinking_result) > 0:
+                    logging.info("[GeminiThinkingAgent] ✓ Thinking completed")
+                    return thinking_result
+                else:
+                    logging.error("[GeminiThinkingAgent] Model returned empty result")
+                    return None
+            except Exception as e:
+                logging.error(f"[GeminiThinkingAgent] Model {self.llm_wrapper.gemini_model} failed: {e}")
+                return None
+            
+        except Exception as e:
+            logging.error(f"[GeminiThinkingAgent] Error: {e}")
+            return None
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.gemini_available
+

agents/memory_agent.py

@@ -0,0 +1,44 @@
+"""Memory Agent - responsible for memory retrieval and storage"""
+import os
+import sys
+import logging
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import MODEL_CONFIG
+
+class MemoryAgent:
+    """Agent responsible for memory retrieval and storage"""
+    
+    def __init__(self, memory_system, config=None):
+        self.memory_system = memory_system
+        self.config = config or MODEL_CONFIG or {}
+    
+    def retrieve_memories(self, query, n_results=None):
+        """Retrieve relevant memories for a query"""
+        if n_results is None:
+            max_memories = self.config.get('memory', {}).get('retrieval', {}).get('max_retrieved_memories', 5) if self.config else 5
+        else:
+            max_memories = n_results
+        
+        try:
+            memories = self.memory_system.retrieve_relevant_memories(query, n_results=max_memories)
+            if memories:
+                logging.info(f"[MemoryAgent] Retrieved {len(memories)} relevant memories")
+            return memories
+        except Exception as e:
+            logging.error(f"[MemoryAgent] Error retrieving memories: {e}")
+            return []
+    
+    def store_memory(self, text, metadata=None, memory_type="conversation"):
+        """Store a memory"""
+        try:
+            self.memory_system.store_memory(text, metadata, memory_type)
+            logging.info(f"[MemoryAgent] Stored memory: {memory_type}")
+        except Exception as e:
+            logging.error(f"[MemoryAgent] Error storing memory: {e}")
+    
+    def is_ready(self):
+        """Check if memory agent is ready"""
+        return self.memory_system.is_ready() if self.memory_system else False
+

agents/pi_agent.py

@@ -0,0 +1,99 @@
+"""Pi Response Agent - responsible for generating human-facing responses using Pi-3.1"""
+import os
+import sys
+import logging
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import MODEL_CONFIG
+from llm_wrapper import LLMWrapper
+
+class PiResponseAgent:
+    """Agent responsible for generating human-facing responses using Pi-3.1"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.inflection_ai_available = False
+        
+        # Get model from config
+        inflection_config = self.config.get('inflection_ai', {}) if self.config else {}
+        inflection_model = inflection_config.get('model', 'Pi-3.1')
+        
+        # Initialize LLM wrapper with the model
+        self.llm_wrapper = LLMWrapper(inflection_model=inflection_model, config=self.config)
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize Inflection AI API availability"""
+        inflection_key = os.getenv("INFLECTION_AI_API_KEY")
+        if inflection_key:
+            self.inflection_ai_available = True
+            logging.info("[PiResponseAgent] ✓ Initialized and ready")
+        else:
+            logging.warning("[PiResponseAgent] ✗ INFLECTION_AI_API_KEY not found")
+    
+    def respond(self, user_input, emotional_state, thinking_context=None, conversation_history=None, retrieved_memories=None):
+        """Generate response using Pi-3.1 with thinking context and emotional state"""
+        if not self.inflection_ai_available:
+            logging.warning("[PiResponseAgent] Not available")
+            return None
+
+        try:
+            # Create context with emotional state
+            emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
+            
+            # Build comprehensive context - Inflection AI API only accepts "Human" and "Assistant" types
+            # We'll incorporate system instructions into the first Human message
+            context_parts = []
+            
+            # Build system instructions as part of the user input context
+            system_instructions = f"[Context: You are Galatea, an AI assistant. Emotional state: {emotions_text}. "
+            
+            # Add thinking context from Gemini if available
+            if thinking_context:
+                system_instructions += f"Internal analysis: {thinking_context}. "
+            
+            # Add retrieved memories if available
+            if retrieved_memories and len(retrieved_memories) > 0:
+                memory_text = "Relevant memories: "
+                for i, memory in enumerate(retrieved_memories[:3], 1):  # Top 3 most relevant
+                    memory_text += f"{i}. {memory['text'][:100]}; "
+                system_instructions += memory_text
+            
+            system_instructions += "Keep response concise (under 50 words) and reflect emotional state.]"
+            
+            # Add conversation history as context messages (Human/Assistant only)
+            if conversation_history and len(conversation_history) > 0:
+                # Include recent conversation history
+                for msg in conversation_history[-6:]:  # Last 3 exchanges (6 messages)
+                    context_parts.append({
+                        "text": msg["content"],
+                        "type": "Human" if msg["role"] == "user" else "Assistant"
+                    })
+            
+            # Add current user input with system context prepended
+            enhanced_user_input = f"{system_instructions}\n\n{user_input}"
+            context_parts.append({
+                "text": enhanced_user_input,
+                "type": "Human"
+            })
+
+            logging.info("[PiResponseAgent] Sending request to Pi-3.1 API...")
+            # Model is set in wrapper initialization
+            response = self.llm_wrapper.call_inflection_ai(context_parts)
+            
+            if response:
+                logging.info("[PiResponseAgent] ✓ Response received")
+                return response
+            else:
+                logging.error("[PiResponseAgent] API call failed")
+                return None
+
+        except Exception as e:
+            logging.error(f"[PiResponseAgent] Error: {e}")
+            return None
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.inflection_ai_available
+

agents/sentiment_agent.py

@@ -0,0 +1,94 @@
+"""Sentiment Agent - responsible for sentiment analysis (uses Azure, Hugging Face, or NLTK fallback)"""
+import os
+import sys
+import logging
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import MODEL_CONFIG
+from agents.azure_agent import AzureTextAnalyticsAgent
+
+# Import transformers with error handling
+try:
+    from transformers import pipeline
+    transformers_available = True
+except ImportError:
+    logging.warning("Transformers library not available. Using fallback sentiment analysis.")
+    transformers_available = False
+
+class SentimentAgent:
+    """Agent responsible for sentiment analysis (uses Azure, Hugging Face, or NLTK fallback)"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.azure_agent = AzureTextAnalyticsAgent(config=self.config)
+        self.sentiment_analyzer = None
+        self.ready = False
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize sentiment analyzer"""
+        # Try Azure first
+        if self.azure_agent.is_ready():
+            self.ready = True
+            logging.info("[SentimentAgent] Using Azure Text Analytics")
+            return
+        
+        # Fallback to Hugging Face
+        sentiment_model = self.config.get('sentiment', {}).get('primary_model', 'distilbert/distilbert-base-uncased-finetuned-sst-2-english') if self.config else 'distilbert/distilbert-base-uncased-finetuned-sst-2-english'
+        
+        if transformers_available:
+            try:
+                logging.info("[SentimentAgent] Initializing Hugging Face sentiment analyzer...")
+                self.sentiment_analyzer = pipeline("sentiment-analysis", model=sentiment_model)
+                self.ready = True
+                logging.info("[SentimentAgent] ✓ Initialized successfully")
+            except Exception as e:
+                logging.warning(f"[SentimentAgent] Hugging Face model failed: {e}, using fallback")
+                self.sentiment_analyzer = None
+                self.ready = True  # Fallback available
+        else:
+            self.ready = True  # Fallback available
+    
+    def analyze(self, text):
+        """Analyze sentiment of text (tries Azure, then Hugging Face, then NLTK)"""
+        # Try Azure first
+        if self.azure_agent.is_ready():
+            result = self.azure_agent.analyze(text)
+            if result is not None:
+                return result
+        
+        # Fallback to Hugging Face
+        if self.sentiment_analyzer:
+            try:
+                result = self.sentiment_analyzer(text)[0]
+                label = result['label'].lower()
+                score = result['score']
+                
+                if 'positive' in label:
+                    return score
+                elif 'negative' in label:
+                    return -score
+                else:
+                    return 0.0
+            except Exception as e:
+                logging.error(f"[SentimentAgent] Error: {e}")
+                return self._fallback_analyze(text)
+        else:
+            return self._fallback_analyze(text)
+    
+    def _fallback_analyze(self, text):
+        """Fallback sentiment analysis using NLTK VADER"""
+        try:
+            from nltk.sentiment import SentimentIntensityAnalyzer
+            analyzer = SentimentIntensityAnalyzer()
+            scores = analyzer.polarity_scores(text)
+            return scores['compound']  # Returns value between -1 and 1
+        except Exception as e:
+            logging.error(f"[SentimentAgent] Fallback failed: {e}")
+            return 0.0
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.ready
+

app.py

@@ -76,6 +76,8 @@ initializing = False
 gemini_initialized = False
 max_init_retries = 3
 current_init_retry = 0
+init_script_running = False
+init_script_complete = False
 
 # Check for required environment variables
 required_env_vars = ['GEMINI_API_KEY']
@@ -119,13 +121,70 @@ def initialize_gemini():
         logging.error(f"Error initializing Gemini API: {e}")
         return False
 
+def run_init_script():
+    """Run the initialization script in parallel"""
+    global init_script_running, init_script_complete
+    
+    if init_script_running or init_script_complete:
+        return
+    
+    init_script_running = True
+    logging.info("=" * 70)
+    logging.info("RUNNING PARALLEL INITIALIZATION SCRIPT")
+    logging.info("=" * 70)
+    
+    try:
+        import subprocess
+        import sys
+        
+        # Run the initialization script
+        script_path = os.path.join(os.path.dirname(__file__), 'initialize_galatea.py')
+        result = subprocess.run(
+            [sys.executable, script_path],
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        if result.returncode == 0:
+            logging.info("✓ Initialization script completed successfully")
+            init_script_complete = True
+        else:
+            logging.error(f"✗ Initialization script failed with code {result.returncode}")
+            logging.error(f"Error output: {result.stderr}")
+            # Still mark as complete to allow app to continue
+            init_script_complete = True
+    except subprocess.TimeoutExpired:
+        logging.error("✗ Initialization script timed out")
+        init_script_complete = True
+    except Exception as e:
+        logging.error(f"✗ Error running initialization script: {e}")
+        init_script_complete = True
+    finally:
+        init_script_running = False
+        logging.info("=" * 70)
+
 def initialize_components():
-    """Initialize Galatea components"""
+    """Initialize Galatea components (runs after init script completes)"""
     global galatea_ai, dialogue_engine, avatar_engine, is_initialized, initializing
-    global current_init_retry, gemini_initialized
+    global current_init_retry, gemini_initialized, init_script_complete
     
     if initializing or is_initialized:
         return
+    
+    # Wait for initialization script to complete (poll every 2 seconds)
+    max_wait_time = 300  # 5 minutes
+    wait_start = time.time()
+    while not init_script_complete:
+        elapsed = time.time() - wait_start
+        if elapsed > max_wait_time:
+            logging.warning("Initialization script timeout - proceeding anyway")
+            break
+        logging.info(f"Waiting for initialization script to complete... ({elapsed:.0f}s)")
+        time.sleep(2)
+    
+    if not init_script_complete:
+        logging.warning("Proceeding with component initialization despite init script not completing")
 
     if missing_gemini_key:
         logging.error("Initialization aborted: GEMINI_API_KEY missing")
@@ -136,31 +195,69 @@ def initialize_components():
     
     try:
         # Import here to avoid circular imports and ensure errors are caught
-        from import_random import GalateaAI, DialogueEngine, AvatarEngine
+        from galatea_ai import GalateaAI
+        from dialogue import DialogueEngine
+        from avatar import AvatarEngine
         
         # Initialize components
+        logging.info("=" * 60)
+        logging.info("INITIALIZING GALATEA AI SYSTEM")
+        logging.info("=" * 60)
+        
         galatea_ai = GalateaAI()
         dialogue_engine = DialogueEngine(galatea_ai)
         avatar_engine = AvatarEngine()
         avatar_engine.update_avatar(galatea_ai.emotional_state)
         
-        # Try to initialize Gemini specifically
-        gemini_initialized = initialize_gemini()
+        # Check if all components are fully initialized
+        init_status = galatea_ai.get_initialization_status()
         
-        is_initialized = True
-        logging.info(f"Galatea components initialized successfully. Gemini status: {gemini_initialized}")
-        logging.info(f"Emotions initialized: {galatea_ai.emotional_state}")
-    except Exception as e:
-        logging.error(f"Error initializing Galatea: {e}")
-        print(f"Error initializing Galatea: {e}")
+        logging.info("=" * 60)
+        logging.info("INITIALIZATION STATUS")
+        logging.info("=" * 60)
+        logging.info(f"Memory System (JSON): {init_status['memory_system']}")
+        logging.info(f"Sentiment Analyzer: {init_status['sentiment_analyzer']}")
+        logging.info(f"Models Ready: {init_status['models']}")
+        logging.info(f"  - Gemini available: {init_status['gemini_available']}")
+        logging.info(f"  - Inflection AI available: {init_status['inflection_ai_available']}")
+        logging.info(f"API Keys Valid: {init_status['api_keys']}")
+        logging.info(f"Fully Initialized: {init_status['fully_initialized']}")
+        logging.info("=" * 60)
         
-        # Retry logic for initialization failures
-        current_init_retry += 1
-        if current_init_retry < max_init_retries:
-            logging.info(f"Retrying initialization (attempt {current_init_retry}/{max_init_retries})...")
-            time.sleep(2)  # Wait before retrying
-            initializing = False
-            Thread(target=initialize_components).start()
+        # CRITICAL: Only mark as initialized if ALL components are ready
+        # If any component fails, EXIT the application immediately
+        if init_status['fully_initialized']:
+            is_initialized = True
+            logging.info("✓ Galatea AI system fully initialized and ready")
+            logging.info(f"Emotions initialized: {galatea_ai.emotional_state}")
+        else:
+            logging.error("=" * 60)
+            logging.error("❌ INITIALIZATION FAILED - EXITING APPLICATION")
+            logging.error("=" * 60)
+            logging.error("One or more critical components failed to initialize:")
+            if not init_status['memory_system']:
+                logging.error("  ✗ Memory System (JSON) - FAILED")
+            if not init_status['sentiment_analyzer']:
+                logging.error("  ✗ Sentiment Analyzer - FAILED")
+            if not init_status['models']:
+                logging.error("  ✗ Models - FAILED")
+            if not init_status['api_keys']:
+                logging.error("  ✗ API Keys - FAILED")
+            logging.error("=" * 60)
+            logging.error("EXITING APPLICATION - All systems must be operational")
+            logging.error("=" * 60)
+            import sys
+            sys.exit(1)  # Exit immediately - no retries, no partial functionality
+    except Exception as e:
+        logging.error("=" * 60)
+        logging.error(f"❌ CRITICAL ERROR INITIALIZING GALATEA: {e}")
+        logging.error("=" * 60)
+        logging.error("EXITING APPLICATION - Cannot continue with initialization failure")
+        logging.error("=" * 60)
+        print(f"CRITICAL ERROR: {e}")
+        print("Application exiting due to initialization failure")
+        import sys
+        sys.exit(1)  # Exit immediately - no retries
     finally:
         initializing = False
 
@@ -168,9 +265,13 @@ def initialize_components():
 def home():
     # Add error handling for template rendering
     try:
-        # Start initialization in background if not already started
+        # Start initialization script in background if not already started
+        if not init_script_complete and not init_script_running:
+            Thread(target=run_init_script, daemon=True).start()
+        
+        # Start component initialization after init script (will wait if script not done)
         if not is_initialized and not initializing and not missing_gemini_key:
-            Thread(target=initialize_components).start()
+            Thread(target=initialize_components, daemon=True).start()
             
         return render_template('index.html')
     except Exception as e:
@@ -179,24 +280,21 @@ def home():
 
 @app.route('/api/chat', methods=['POST'])
 def chat():
-    # Check if components are initialized
+    # CRITICAL: Do not allow chat if system is not fully initialized
+    if not is_initialized:
+        return jsonify({
+            'error': 'System is not initialized yet. Please wait for initialization to complete.',
+            'is_initialized': False,
+            'status': 'initializing'
+        }), 503  # Service Unavailable
+    
+    # Check if API key is missing
     if missing_gemini_key:
         return jsonify({
             'error': 'GEMINI_API_KEY is missing. Chat is unavailable.',
-            'status': 'missing_gemini_key'
-        }), 503
-
-    if not is_initialized:
-        # Start initialization if not already started
-        if not initializing and not missing_gemini_key:
-            Thread(target=initialize_components).start()
-            
-        return jsonify({
-            'response': 'I am still initializing. Please try again in a moment.',
-            'avatar_shape': 'Circle',
-            'emotions': {'joy': 0.2, 'sadness': 0.2, 'anger': 0.2, 'fear': 0.2, 'curiosity': 0.2},
+            'status': 'missing_gemini_key',
             'is_initialized': False
-        })
+        }), 503
     
     data = request.json
     user_input = data.get('message', '')
@@ -208,6 +306,15 @@ def chat():
         # Process the message through Galatea
         response = dialogue_engine.get_response(user_input)
         
+        # CRITICAL: If response is None, Pi-3.1 failed - exit application
+        if response is None:
+            error_msg = "CRITICAL: Pi-3.1 (PHI) model failed to generate response. Application cannot continue."
+            logging.error("=" * 60)
+            logging.error(error_msg)
+            logging.error("=" * 60)
+            import sys
+            sys.exit(1)  # Exit immediately
+        
         # Update avatar
         avatar_engine.update_avatar(galatea_ai.emotional_state)
         avatar_shape = avatar_engine.avatar_model
@@ -223,12 +330,24 @@ def chat():
             'emotions': emotions,
             'is_initialized': True
         })
+    except RuntimeError as e:
+        # CRITICAL: RuntimeError means a system failure - exit application
+        error_msg = f"CRITICAL SYSTEM FAILURE: {e}"
+        logging.error("=" * 60)
+        logging.error(error_msg)
+        logging.error("EXITING APPLICATION")
+        logging.error("=" * 60)
+        import sys
+        sys.exit(1)  # Exit immediately
     except Exception as e:
-        logging.error(f"Error processing chat: {e}")
-        return jsonify({
-            'error': 'Failed to process your message',
-            'details': str(e)
-        }), 500
+        # Any other exception is also critical - exit application
+        error_msg = f"CRITICAL ERROR processing chat: {e}"
+        logging.error("=" * 60)
+        logging.error(error_msg)
+        logging.error("EXITING APPLICATION")
+        logging.error("=" * 60)
+        import sys
+        sys.exit(1)  # Exit immediately
 
 # Import Azure Text Analytics with fallback to NLTK VADER
 try:
@@ -439,16 +558,56 @@ def availability():
 @app.route('/api/is_initialized')
 def is_initialized_endpoint():
     """Lightweight endpoint for polling initialization progress"""
-    payload = {
-        'is_initialized': is_initialized,
-        'initializing': initializing,
-        'missing_gemini_key': missing_gemini_key
-    }
-
+    global init_script_running, init_script_complete
+    
+    # Determine current initialization state
     if missing_gemini_key:
-        payload['error_page'] = url_for('error_page')
-
-    return jsonify(payload)
+        return jsonify({
+            'is_initialized': False,
+            'initializing': False,
+            'missing_gemini_key': True,
+            'error_page': url_for('error_page'),
+            'status': 'missing_api_key'
+        })
+    
+    # Check if init script is still running
+    if init_script_running:
+        return jsonify({
+            'is_initialized': False,
+            'initializing': True,
+            'missing_gemini_key': False,
+            'status': 'running_init_script',
+            'message': 'Running parallel initialization...'
+        })
+    
+    # Check if components are initializing
+    if initializing:
+        return jsonify({
+            'is_initialized': False,
+            'initializing': True,
+            'missing_gemini_key': False,
+            'status': 'initializing_components',
+            'message': 'Initializing AI components...'
+        })
+    
+    # Check if fully initialized
+    if is_initialized:
+        return jsonify({
+            'is_initialized': True,
+            'initializing': False,
+            'missing_gemini_key': False,
+            'status': 'ready',
+            'message': 'System ready'
+        })
+    
+    # Still waiting
+    return jsonify({
+        'is_initialized': False,
+        'initializing': True,
+        'missing_gemini_key': False,
+        'status': 'waiting',
+        'message': 'Waiting for initialization...'
+    })
 
 @app.route('/status')
 def status():
@@ -468,7 +627,19 @@ def error_page():
 
 if __name__ == '__main__':
     print("Starting Galatea Web Interface...")
-    print("The chatbot will initialize in the background when first accessed.")
+    print("Initialization will begin automatically when the app starts.")
+    
+    # Start initialization script immediately when app starts
+    logging.info("=" * 70)
+    logging.info("STARTING GALATEA AI APPLICATION")
+    logging.info("=" * 70)
+    logging.info("Launching parallel initialization script...")
+    
+    # Start initialization script in background thread
+    Thread(target=run_init_script, daemon=True).start()
+    
+    # Start component initialization (will wait for init script)
+    Thread(target=initialize_components, daemon=True).start()
 
     # Add debug logs for avatar shape changes
     logging.info("Avatar system initialized with default shape.")
@@ -476,5 +647,8 @@ if __name__ == '__main__':
     # Get port from environment variable (for Hugging Face Spaces compatibility)
     port = int(os.environ.get('PORT', 7860))
 
+    logging.info(f"Flask server starting on port {port}...")
+    logging.info("Frontend will poll /api/is_initialized for status")
+    
     # Bind to 0.0.0.0 for external access (required for Hugging Face Spaces)
-    app.run(host='0.0.0.0', port=port, debug=False)
+    app.run(host='0.0.0.0', port=port, debug=True)

avatar.py

@@ -0,0 +1,34 @@
+"""Avatar Engine - manages avatar representation based on emotional state"""
+from enum import Enum
+
+class AvatarShape(Enum): #create shape types for the avatar
+    CIRCLE = "Circle"
+    TRIANGLE = "Triangle"
+    SQUARE = "Square"
+
+class AvatarEngine:
+    def __init__(self):
+        self.avatar_model = "Circle"  # Start with a basic shape
+        self.expression_parameters = {}
+
+    def update_avatar(self, emotional_state):
+        # Map emotions to avatar parameters (facial expressions, color)
+        joy_level = emotional_state["joy"]
+        sadness_level = emotional_state["sadness"]
+
+        # Simple mapping (placeholder)
+        self.avatar_model = self.change_avatar_shape(joy_level, sadness_level)
+
+    def change_avatar_shape(self, joy, sad):
+        #determine shape based on feelings
+        if joy > 0.5:
+            return AvatarShape.CIRCLE.value
+        elif sad > 0.5:
+            return AvatarShape.TRIANGLE.value
+        else:
+            return AvatarShape.SQUARE.value
+            
+    def render_avatar(self):
+        # Simple console rendering of the avatar state
+        print(f"Avatar shape: {self.avatar_model}")
+

check_models.py

@@ -1,48 +0,0 @@
-import os
-import logging
-from dotenv import load_dotenv
-import google.generativeai as genai
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# Load environment variables
-load_dotenv()
-
-def check_available_models():
-    """Check and print all available Gemini models"""
-    try:
-        # Get API key from environment variable 
-        api_key = os.getenv("GEMINI_API_KEY")
-        
-        if not api_key:
-            print("Gemini API key not found in environment variables.")
-            api_key = input("Enter your Gemini API key: ")
-        
-        # Configure the Gemini API
-        genai.configure(api_key=api_key)
-        
-        # List available models
-        print("Fetching available models...")
-        models = genai.list_models()
-        
-        print("\n===== AVAILABLE GOOGLE AI MODELS =====")
-        for model in models:
-            print(f"- {model.name}")
-            
-        print("\n===== RECOMMENDED MODELS TO USE =====")
-        for model in models:
-            if "gemini-1.5" in model.name:
-                print(f"✓ {model.name}")
-                
-        return [model.name for model in models]
-    
-    except Exception as e:
-        print(f"Error checking models: {e}")
-        return []
-
-if __name__ == "__main__":
-    check_available_models()
-    print("\nYou can use any of these models in your application.")
-    print("To fix your application, update the model name in initialize_gemini() method.")
-    print("Example usage: self.gemini_model = genai.GenerativeModel('models/gemini-1.5-flash')")

check_website.py

@@ -1,129 +0,0 @@
-import os
-import sys
-import subprocess
-
-def check_python_imports():
-    """Check if required Python packages are installed"""
-    required_packages = ['flask', 'dotenv', 'nltk', 'transformers', 'google-generativeai']
-    missing_packages = []
-    
-    for package in required_packages:
-        try:
-            if package == 'dotenv':
-                __import__('python_dotenv')
-            else:
-                __import__(package)
-        except ImportError:
-            missing_packages.append(package)
-    
-    return missing_packages
-
-def check_file_structure():
-    """Check if all required files and directories exist"""
-    expected_files = [
-        'app.py',
-        'import_random.py',
-        'templates/index.html',
-        'static/css/style.css',
-        'static/js/script.js',
-        '.env'
-    ]
-    
-    missing_files = []
-    for file_path in expected_files:
-        if not os.path.exists(file_path):
-            missing_files.append(file_path)
-    
-    return missing_files
-
-def check_env_file():
-    """Check if .env file has GEMINI_API_KEY"""
-    if not os.path.exists('.env'):
-        return False
-    
-    with open('.env', 'r') as f:
-        content = f.read()
-        
-    return 'GEMINI_API_KEY' in content
-
-def main():
-    print("=== Galatea Website Troubleshooter ===\n")
-    
-    # Check Python version
-    python_version = sys.version.split()[0]
-    print(f"Python Version: {python_version}")
-    
-    # Check required packages
-    print("\nChecking required packages...")
-    missing_packages = check_python_imports()
-    if missing_packages:
-        print("❌ The following packages need to be installed:")
-        for package in missing_packages:
-            install_name = 'python-dotenv' if package == 'dotenv' else package
-            print(f"  - {install_name}")
-        print("\nInstall them using: pip install package-name")
-    else:
-        print("✅ All required packages are installed.")
-    
-    # Check file structure
-    print("\nChecking file structure...")
-    missing_files = check_file_structure()
-    if missing_files:
-        print("❌ The following files/directories are missing:")
-        for file_path in missing_files:
-            print(f"  - {file_path}")
-    else:
-        print("✅ All required files and directories exist.")
-    
-    # Check .env file
-    print("\nChecking environment variables...")
-    if check_env_file():
-        print("✅ GEMINI_API_KEY found in .env file.")
-    else:
-        print("❌ GEMINI_API_KEY not found in .env file.")
-        print("   Create a .env file with: GEMINI_API_KEY=your_api_key_here")
-    
-    print("\n=== Conclusion ===")
-    if not missing_packages and not missing_files and check_env_file():
-        print("✅ Everything looks good! The website should work correctly.")
-        print("   Run 'python app.py' to start the server.")
-        print("   Then open http://127.0.0.1:5000 in your browser.")
-    else:
-        print("❌ Some issues were found that need to be addressed before the website will work.")
-    
-    print("\nWould you like to try fixing these issues automatically? (y/n)")
-    choice = input("> ")
-    
-    if choice.lower() == 'y':
-        # Install missing packages
-        if missing_packages:
-            print("\nInstalling missing packages...")
-            for package in missing_packages:
-                install_name = 'python-dotenv' if package == 'dotenv' else package
-                print(f"Installing {install_name}...")
-                subprocess.run([sys.executable, '-m', 'pip', 'install', install_name])
-        
-        # Create missing directories
-        missing_dirs = set()
-        for file_path in missing_files:
-            dir_path = os.path.dirname(file_path)
-            if dir_path and not os.path.exists(dir_path):
-                missing_dirs.add(dir_path)
-        
-        for dir_path in missing_dirs:
-            print(f"Creating directory: {dir_path}")
-            os.makedirs(dir_path, exist_ok=True)
-        
-        # Create .env file if missing
-        if not check_env_file():
-            print("\nCreating .env file...")
-            api_key = input("Enter your Gemini API Key: ")
-            with open('.env', 'w') as f:
-                f.write(f"GEMINI_API_KEY={api_key}\n")
-        
-        print("\nFixes applied. Run 'python app.py' to start the server.")
-    
-    input("\nPress Enter to exit...")
-
-if __name__ == "__main__":
-    main()

config.py

@@ -0,0 +1,26 @@
+"""Configuration loading module"""
+import os
+import yaml
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def load_model_config(config_path="models.yaml"):
+    """Load model configuration from YAML file"""
+    try:
+        if os.path.exists(config_path):
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f)
+            logging.info(f"✓ Model configuration loaded from {config_path}")
+            return config
+        else:
+            logging.warning(f"⚠ Model configuration file {config_path} not found, using defaults")
+            return None
+    except Exception as e:
+        logging.error(f"✗ Error loading model configuration: {e}")
+        return None
+
+# Load configuration at module level
+MODEL_CONFIG = load_model_config()
+

dialogue.py

@@ -0,0 +1,26 @@
+"""Dialogue Engine - handles conversation flow and styling"""
+
+class DialogueEngine:
+    def __init__(self, ai_core):
+        self.ai_core = ai_core
+        self.last_user_message = ""
+
+    def get_response(self, user_input):
+        # Store the last message for sentiment analysis
+        self.last_user_message = user_input
+        
+        ai_response = self.ai_core.process_input(user_input)
+        styled_response = self.apply_style(ai_response, self.ai_core.emotional_state)
+        return styled_response
+
+    def apply_style(self, text, emotional_state):
+        style = self.get_style(emotional_state)
+        #selects styles based on emotions
+        #add style to text
+        styled_text = text # Remove the style suffix to make responses cleaner
+        return styled_text
+
+    def get_style(self, emotional_state):
+        #determine style based on the state of the AI
+        return "neutral"
+

galatea_ai.py

@@ -0,0 +1,416 @@
+"""Main GalateaAI class - orchestrates all agents"""
+import os
+import sys
+import nltk
+import logging
+
+# Add current directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from config import MODEL_CONFIG
+from systems import MemorySystem
+from agents import (
+    MemoryAgent, GeminiThinkingAgent, PiResponseAgent,
+    EmotionalStateAgent, SentimentAgent
+)
+
+# Download NLTK data (only needs to be done once)
+try:
+    nltk.data.find("tokenizers/punkt")
+except LookupError:
+    nltk.download('punkt')
+    
+# Make sure punkt is downloaded before importing the rest
+nltk.download('punkt', quiet=True)
+
+class GalateaAI:
+    def __init__(self):
+        # Load model configuration first
+        self.config = MODEL_CONFIG or {}
+        
+        self.knowledge_base = {}
+        self.response_model = "A generic response" #Place Holder for the ML model
+        
+        # Conversation history for context
+        self.conversation_history = []  # List of {"role": "user"/"assistant", "content": "..."}
+        # Get max history length from config or use default
+        self.max_history_length = self.config.get('conversation', {}).get('max_history_length', 20)
+        
+        # Initialize memory system
+        logging.info("Initializing memory system (JSON)...")
+        try:
+            self.memory_system = MemorySystem(config=self.config)
+            self.memory_system_ready = self.memory_system.is_ready()
+            if not self.memory_system_ready:
+                raise Exception("Memory system failed to initialize")
+            logging.info("✓ Memory system initialized")
+        except Exception as e:
+            logging.error(f"Failed to initialize memory system: {e}")
+            self.memory_system_ready = False
+            raise
+        
+        # Initialize agents
+        logging.info("Initializing agents...")
+        self.memory_agent = MemoryAgent(self.memory_system, config=self.config)
+        self.gemini_agent = GeminiThinkingAgent(config=self.config)
+        self.pi_agent = PiResponseAgent(config=self.config)
+        self.emotional_agent = EmotionalStateAgent(config=self.config)
+        self.sentiment_agent = SentimentAgent(config=self.config)
+        
+        # Run end-to-end chat simulation test - CRITICAL: Tests full workflow as if in a real chat
+        logging.info("Running end-to-end chat simulation test...")
+        self._run_chat_simulation_test()
+        
+        # Track initialization status
+        self.memory_system_ready = self.memory_agent.is_ready()
+        self.sentiment_analyzer_ready = self.sentiment_agent.is_ready()
+        self.models_ready = self.gemini_agent.is_ready() or self.pi_agent.is_ready()
+        self.api_keys_valid = self.gemini_agent.is_ready() or self.pi_agent.is_ready()
+        
+        # CRITICAL: Verify all critical systems are ready, raise exception if not
+        if not self.memory_system_ready:
+            raise RuntimeError("Memory system failed to initialize - application cannot continue")
+        if not self.sentiment_analyzer_ready:
+            raise RuntimeError("Sentiment analyzer failed to initialize - application cannot continue")
+        if not self.models_ready:
+            raise RuntimeError("No AI models available (Gemini or Pi-3.1) - application cannot continue")
+        if not self.api_keys_valid:
+            raise RuntimeError("API keys are invalid or missing - application cannot continue")
+        if not self.pi_agent.is_ready():
+            raise RuntimeError("Pi-3.1 (PHI) model is not available - application cannot continue")
+        if not self.gemini_agent.is_ready():
+            raise RuntimeError("Gemini model is not available - application cannot continue")
+        
+        # Legacy compatibility
+        self.gemini_available = self.gemini_agent.is_ready()
+        self.inflection_ai_available = self.pi_agent.is_ready()
+        self.quantum_random_available = self.emotional_agent.quantum_random_available
+        
+        logging.info("✓ All agents initialized and verified")
+    
+    def _run_chat_simulation_test(self):
+        """Run a full end-to-end chat simulation test - simulates real chat interaction"""
+        logging.info("=" * 60)
+        logging.info("RUNNING END-TO-END CHAT SIMULATION TEST")
+        logging.info("=" * 60)
+        
+        test_messages = [
+            "Hello, how are you?",
+            "What can you help me with?",
+            "Tell me something interesting."
+        ]
+        
+        test_results = {
+            'sentiment_analysis': False,
+            'emotional_state_update': False,
+            'memory_retrieval': False,
+            'gemini_thinking': False,
+            'pi_response': False,
+            'full_workflow': False
+        }
+        
+        try:
+            # Test with first message
+            test_input = test_messages[0]
+            logging.info(f"[Chat Simulation] Testing with message: '{test_input}'")
+            
+            # Step 1: Test sentiment analysis
+            try:
+                sentiment_score = self.sentiment_agent.analyze(test_input)
+                if sentiment_score is not None and isinstance(sentiment_score, (int, float)):
+                    test_results['sentiment_analysis'] = True
+                    logging.info(f"[Chat Simulation] ✓ Sentiment analysis: {sentiment_score:.3f}")
+                else:
+                    raise RuntimeError("Sentiment analysis returned invalid result")
+            except Exception as e:
+                logging.error(f"[Chat Simulation] ✗ Sentiment analysis failed: {e}")
+                raise RuntimeError(f"Sentiment analysis failed during chat simulation: {e}")
+            
+            # Step 2: Test emotional state update
+            try:
+                initial_state = self.emotional_agent.get_state().copy()
+                self.emotional_agent.update_with_sentiment(sentiment_score)
+                updated_state = self.emotional_agent.get_state()
+                if updated_state and isinstance(updated_state, dict) and len(updated_state) > 0:
+                    test_results['emotional_state_update'] = True
+                    logging.info(f"[Chat Simulation] ✓ Emotional state updated: {updated_state}")
+                else:
+                    raise RuntimeError("Emotional state update returned invalid state")
+            except Exception as e:
+                logging.error(f"[Chat Simulation] ✗ Emotional state update failed: {e}")
+                raise RuntimeError(f"Emotional state update failed during chat simulation: {e}")
+            
+            # Step 3: Test memory retrieval
+            try:
+                keywords = self.extract_keywords(test_input)
+                retrieved_memories = self.memory_agent.retrieve_memories(test_input)
+                if retrieved_memories is not None:
+                    test_results['memory_retrieval'] = True
+                    logging.info(f"[Chat Simulation] ✓ Memory retrieval: {len(retrieved_memories)} memories found")
+                else:
+                    raise RuntimeError("Memory retrieval returned None")
+            except Exception as e:
+                logging.error(f"[Chat Simulation] ✗ Memory retrieval failed: {e}")
+                raise RuntimeError(f"Memory retrieval failed during chat simulation: {e}")
+            
+            # Step 4: Test Gemini thinking
+            try:
+                current_emotional_state = self.emotional_agent.get_state()
+                thinking_context = self.gemini_agent.think(
+                    test_input,
+                    current_emotional_state,
+                    self.conversation_history,
+                    retrieved_memories=retrieved_memories
+                )
+                if thinking_context and len(thinking_context) > 0:
+                    test_results['gemini_thinking'] = True
+                    logging.info(f"[Chat Simulation] ✓ Gemini thinking: {thinking_context[:100]}...")
+                else:
+                    raise RuntimeError("Gemini thinking returned empty or None")
+            except Exception as e:
+                logging.error(f"[Chat Simulation] ✗ Gemini thinking failed: {e}")
+                raise RuntimeError(f"Gemini thinking failed during chat simulation: {e}")
+            
+            # Step 5: Test Pi-3.1 response generation
+            try:
+                response = self.pi_agent.respond(
+                    test_input,
+                    current_emotional_state,
+                    thinking_context=thinking_context,
+                    conversation_history=self.conversation_history,
+                    retrieved_memories=retrieved_memories
+                )
+                if response and len(response) > 0:
+                    test_results['pi_response'] = True
+                    logging.info(f"[Chat Simulation] ✓ Pi-3.1 response: {response[:100]}...")
+                else:
+                    raise RuntimeError("Pi-3.1 response returned empty or None")
+            except Exception as e:
+                logging.error(f"[Chat Simulation] ✗ Pi-3.1 response failed: {e}")
+                raise RuntimeError(f"Pi-3.1 response generation failed during chat simulation: {e}")
+            
+            # Step 6: Test full workflow using process_input
+            try:
+                # Reset conversation history for clean test
+                original_history = self.conversation_history.copy()
+                self.conversation_history = []
+                
+                full_response = self.process_input(test_input)
+                if full_response and len(full_response) > 0:
+                    test_results['full_workflow'] = True
+                    logging.info(f"[Chat Simulation] ✓ Full workflow test: {full_response[:100]}...")
+                else:
+                    raise RuntimeError("Full workflow test returned empty or None")
+                
+                # Restore conversation history
+                self.conversation_history = original_history
+            except Exception as e:
+                logging.error(f"[Chat Simulation] ✗ Full workflow test failed: {e}")
+                raise RuntimeError(f"Full workflow test failed during chat simulation: {e}")
+            
+            # Print summary
+            logging.info("=" * 60)
+            logging.info("CHAT SIMULATION TEST SUMMARY")
+            logging.info("=" * 60)
+            for test_name, result in test_results.items():
+                status = "✓ PASSED" if result else "✗ FAILED"
+                logging.info(f"{status} - {test_name.upper().replace('_', ' ')}")
+            logging.info("=" * 60)
+            
+            # CRITICAL: Verify all tests passed
+            if not all(test_results.values()):
+                failed_tests = [name for name, result in test_results.items() if not result]
+                error_msg = f"CRITICAL: Chat simulation tests failed for: {', '.join(failed_tests).upper()}. Application cannot continue."
+                logging.error("=" * 60)
+                logging.error(error_msg)
+                logging.error("=" * 60)
+                raise RuntimeError(error_msg)
+            
+            logging.info("✓ All chat simulation tests passed - system ready for production use")
+            
+        except RuntimeError:
+            # Re-raise RuntimeError as-is (already has proper error message)
+            raise
+        except Exception as e:
+            error_msg = f"CRITICAL: Chat simulation test failed with unexpected error: {e}"
+            logging.error("=" * 60)
+            logging.error(error_msg)
+            logging.error("=" * 60)
+            raise RuntimeError(error_msg)
+    
+    def _check_pre_initialization(self):
+        """Check if components were pre-initialized by initialize_galatea.py"""
+        # Check if JSON memory exists
+        if os.path.exists("./memory.json"):
+            logging.info("✓ Pre-initialized JSON memory detected")
+            return True
+        
+        return False
+    
+    def is_fully_initialized(self):
+        """Check if all components are fully initialized"""
+        return (
+            self.memory_system_ready and
+            self.sentiment_analyzer_ready and
+            self.models_ready and
+            self.api_keys_valid
+        )
+    
+    def get_initialization_status(self):
+        """Get detailed initialization status"""
+        return {
+            "memory_system": self.memory_system_ready,
+            "sentiment_analyzer": self.sentiment_analyzer_ready,
+            "models": self.models_ready,
+            "api_keys": self.api_keys_valid,
+            "gemini_available": self.gemini_agent.is_ready() if hasattr(self, 'gemini_agent') else False,
+            "inflection_ai_available": self.pi_agent.is_ready() if hasattr(self, 'pi_agent') else False,
+            "azure_text_analytics_available": self.sentiment_agent.azure_agent.is_ready() if hasattr(self, 'sentiment_agent') else False,
+            "fully_initialized": self.is_fully_initialized()
+        }
+    
+    @property
+    def emotional_state(self):
+        """Get current emotional state from EmotionalStateAgent"""
+        return self.emotional_agent.get_state() if hasattr(self, 'emotional_agent') else {"joy": 0.2, "sadness": 0.2, "anger": 0.2, "fear": 0.2, "curiosity": 0.2}
+    
+    def update_conversation_history(self, user_input, assistant_response):
+        """Update conversation history, maintaining max length"""
+        # Add user message
+        self.conversation_history.append({"role": "user", "content": user_input})
+        # Add assistant response
+        self.conversation_history.append({"role": "assistant", "content": assistant_response})
+        
+        # Trim history if too long
+        if len(self.conversation_history) > self.max_history_length:
+            # Keep the most recent messages
+            self.conversation_history = self.conversation_history[-self.max_history_length:]
+    
+    def _store_important_memory(self, user_input, assistant_response, intent, keywords):
+        """Store important conversation snippets in memory system"""
+        try:
+            # Determine if this conversation is worth storing
+            # Store if: question, contains important keywords, or is a significant exchange
+            should_store = False
+            memory_type = "conversation"
+            
+            if intent == "question":
+                should_store = True
+                memory_type = "question"
+            elif len(keywords) > 3:  # Substantial conversation
+                should_store = True
+            elif any(keyword in ["remember", "important", "note", "save"] for keyword in keywords):
+                should_store = True
+                memory_type = "important"
+            
+            if should_store:
+                # Create a memory entry combining user input and response
+                memory_text = f"User: {user_input}\nGalatea: {assistant_response}"
+                
+                metadata = {
+                    "intent": intent,
+                    "keywords": keywords[:5],  # Top 5 keywords
+                    "emotions": {k: round(v, 2) for k, v in self.emotional_agent.get_state().items()}
+                }
+                
+                # Store in memory system
+                self.memory_system.store_memory(
+                    text=memory_text,
+                    metadata=metadata,
+                    memory_type=memory_type
+                )
+                logging.info(f"Stored important memory: {memory_type} - {user_input[:50]}...")
+        except Exception as e:
+            logging.error(f"Error storing memory: {e}")
+    
+    def is_thinking_mode(self, intent, user_input, keywords):
+        """Determine if the request requires thinking mode (use Gemini for complex reasoning)"""
+        # Always use thinking mode now - Gemini always thinks, Pi-3.1 always responds
+        return True
+
+    def process_input(self, user_input):
+        """Process user input through the agent chain workflow: PHI(GEMINI(User inputs, read with past memory), emotionalstate)"""
+        # Step 1: Analyze sentiment
+        sentiment_score = self.sentiment_agent.analyze(user_input)
+        
+        # Step 2: Extract keywords and determine intent
+        keywords = self.extract_keywords(user_input)
+        intent = self.determine_intent(user_input)
+        
+        # Step 3: Update emotional state based on sentiment
+        self.emotional_agent.update_with_sentiment(sentiment_score)
+        current_emotional_state = self.emotional_agent.get_state()
+        
+        # Step 4: Retrieve memories
+        retrieved_memories = self.memory_agent.retrieve_memories(user_input)
+        
+        # Step 5: Chain workflow: PHI(GEMINI(User inputs, read with past memory), emotionalstate)
+        # Step 5a: GEMINI(User inputs, read with past memory)
+        thinking_context = self.gemini_agent.think(
+            user_input,
+            current_emotional_state,
+            self.conversation_history,
+            retrieved_memories=retrieved_memories
+        )
+        
+        # Step 5b: PHI(GEMINI result, emotionalstate)
+        response = self.pi_agent.respond(
+            user_input,
+            current_emotional_state,
+            thinking_context=thinking_context,
+            conversation_history=self.conversation_history,
+            retrieved_memories=retrieved_memories
+        )
+        
+        # CRITICAL: Pi-3.1 (PHI) model must generate response - raise exception if it fails
+        if not response:
+            error_msg = "[GalateaAI] CRITICAL: Pi-3.1 (PHI) model failed to generate response. Application cannot continue."
+            logging.error("=" * 60)
+            logging.error(error_msg)
+            logging.error("=" * 60)
+            raise RuntimeError(error_msg)
+        
+        # Update conversation history
+        self.update_conversation_history(user_input, response)
+        
+        # Store important memories
+        self._store_important_memory(user_input, response, intent, keywords)
+        
+        # Update knowledge base
+        self.update_knowledge(keywords, user_input)
+        
+        return response
+
+    def extract_keywords(self, text):
+        try:
+            # Try using NLTK's tokenizer
+            tokens = nltk.word_tokenize(text)
+            keywords = [word.lower() for word in tokens if word.isalnum()]
+            return keywords
+        except Exception:
+            # Fall back to a simple split-based approach if NLTK fails
+            words = text.split()
+            # Clean up words (remove punctuation)
+            keywords = [word.lower().strip('.,!?;:()[]{}""\'') for word in words]
+            # Filter out empty strings
+            keywords = [word for word in keywords if word and word.isalnum()]
+            return keywords
+
+    def determine_intent(self, text):
+        # More comprehensive intent recognition (using keywords)
+        text = text.lower()
+        if "what" in text or "how" in text or "why" in text:
+            return "question"
+        elif "thank" in text:
+            return "gratitude"
+        elif "goodbye" in text or "bye" in text:
+            return "farewell"
+        else:
+            return "statement"
+
+
+    def update_knowledge(self, keywords, user_input):
+        #for new key words remember them
+        for keyword in keywords:
+            if keyword not in self.knowledge_base:
+                self.knowledge_base[keyword] = user_input
+

import_random.py

@@ -1,9 +1,13 @@
 import random
 import nltk
 import os
+import json
+import yaml
 from dotenv import load_dotenv
-import google.generativeai as genai
 import logging
+import requests
+from litellm import completion
+from datetime import datetime
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -11,6 +15,25 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 # Load environment variables from .env file
 load_dotenv()
 
+# Load model configuration from YAML
+def load_model_config(config_path="models.yaml"):
+    """Load model configuration from YAML file"""
+    try:
+        if os.path.exists(config_path):
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f)
+            logging.info(f"✓ Model configuration loaded from {config_path}")
+            return config
+        else:
+            logging.warning(f"⚠ Model configuration file {config_path} not found, using defaults")
+            return None
+    except Exception as e:
+        logging.error(f"✗ Error loading model configuration: {e}")
+        return None
+
+# Load configuration at module level
+MODEL_CONFIG = load_model_config()
+
 # Download NLTK data (only needs to be done once)
 try:
     nltk.data.find("tokenizers/punkt")
@@ -30,36 +53,848 @@ except ImportError:
 
 from enum import Enum
 
+# ChromaDB removed - using JSON-only memory
+
+# --- Memory System (JSON only) ---
+class MemorySystem:
+    """Memory system using JSON for simple key-value storage"""
+    
+    def __init__(self, json_db_path=None, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        # Get paths from config or use defaults
+        memory_config = self.config.get('memory', {}) if self.config else {}
+        self.json_db_path = json_db_path or memory_config.get('json_path', './memory.json')
+        self.json_memory = {}
+        
+        # Initialize JSON database
+        self.load_json_memory()
+    
+    def is_ready(self):
+        """Check if memory system is fully initialized"""
+        return self.json_memory is not None
+    
+    def load_json_memory(self):
+        """Load JSON memory database"""
+        try:
+            if os.path.exists(self.json_db_path):
+                with open(self.json_db_path, 'r', encoding='utf-8') as f:
+                    self.json_memory = json.load(f)
+                logging.info(f"Loaded JSON memory with {len(self.json_memory)} entries")
+            else:
+                self.json_memory = {}
+                logging.info("Created new JSON memory database")
+        except Exception as e:
+            logging.error(f"Error loading JSON memory: {e}")
+            self.json_memory = {}
+    
+    def save_json_memory(self):
+        """Save JSON memory database"""
+        try:
+            with open(self.json_db_path, 'w', encoding='utf-8') as f:
+                json.dump(self.json_memory, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            logging.error(f"Error saving JSON memory: {e}")
+    
+    def store_memory(self, text, metadata=None, memory_type="conversation"):
+        """Store a memory in JSON"""
+        timestamp = datetime.now().isoformat()
+        
+        # Store in JSON
+        memory_id = f"{memory_type}_{timestamp}"
+        self.json_memory[memory_id] = {
+            "text": text,
+            "metadata": metadata or {},
+            "type": memory_type,
+            "timestamp": timestamp
+        }
+        self.save_json_memory()
+        logging.info(f"Stored memory in JSON: {memory_id[:20]}...")
+    
+    def retrieve_relevant_memories(self, query, n_results=5):
+        """Retrieve relevant memories using keyword search in JSON"""
+        relevant_memories = []
+        
+        # Simple keyword search in JSON
+        if self.json_memory:
+            query_lower = query.lower()
+            query_words = set(query_lower.split())
+            
+            for memory_id, memory_data in self.json_memory.items():
+                text_lower = memory_data.get("text", "").lower()
+                text_words = set(text_lower.split())
+                
+                # Simple overlap check
+                overlap = len(query_words & text_words)
+                if overlap > 0:
+                    relevant_memories.append({
+                        "text": memory_data["text"],
+                        "metadata": memory_data.get("metadata", {}),
+                        "distance": 1.0 - (overlap / max(len(query_words), len(text_words)))
+                    })
+            
+            # Sort by relevance (lower distance = more relevant)
+            relevant_memories.sort(key=lambda x: x.get("distance", 1.0))
+            relevant_memories = relevant_memories[:n_results]
+            logging.info(f"Retrieved {len(relevant_memories)} relevant memories from JSON DB")
+        
+        return relevant_memories
+    
+    def get_json_memory(self, key):
+        """Get a specific memory by key from JSON database"""
+        return self.json_memory.get(key)
+    
+    def set_json_memory(self, key, value, metadata=None):
+        """Set a key-value memory in JSON database"""
+        self.json_memory[key] = {
+            "value": value,
+            "metadata": metadata or {},
+            "timestamp": datetime.now().isoformat()
+        }
+        self.save_json_memory()
+    
+    def get_all_json_memories(self):
+        """Get all JSON memories"""
+        return self.json_memory.copy()
+
+# --- Agent Classes ---
+class MemoryAgent:
+    """Agent responsible for memory retrieval and storage"""
+    
+    def __init__(self, memory_system, config=None):
+        self.memory_system = memory_system
+        self.config = config or MODEL_CONFIG or {}
+    
+    def retrieve_memories(self, query, n_results=None):
+        """Retrieve relevant memories for a query"""
+        if n_results is None:
+            max_memories = self.config.get('memory', {}).get('retrieval', {}).get('max_retrieved_memories', 5) if self.config else 5
+        else:
+            max_memories = n_results
+        
+        try:
+            memories = self.memory_system.retrieve_relevant_memories(query, n_results=max_memories)
+            if memories:
+                logging.info(f"[MemoryAgent] Retrieved {len(memories)} relevant memories")
+            return memories
+        except Exception as e:
+            logging.error(f"[MemoryAgent] Error retrieving memories: {e}")
+            return []
+    
+    def store_memory(self, text, metadata=None, memory_type="conversation"):
+        """Store a memory"""
+        try:
+            self.memory_system.store_memory(text, metadata, memory_type)
+            logging.info(f"[MemoryAgent] Stored memory: {memory_type}")
+        except Exception as e:
+            logging.error(f"[MemoryAgent] Error storing memory: {e}")
+    
+    def smoke_test(self):
+        """Perform smoke test to verify memory system is working"""
+        try:
+            # Test storing
+            test_text = "Smoke test memory entry"
+            self.store_memory(test_text, {"test": True}, "test")
+            
+            # Test retrieving
+            memories = self.retrieve_memories("smoke test", n_results=1)
+            if memories is not None:
+                logging.info("[MemoryAgent] ✓ Smoke test passed")
+                return True
+            else:
+                logging.warning("[MemoryAgent] ⚠ Smoke test failed - retrieve returned None")
+                return False
+        except Exception as e:
+            logging.error(f"[MemoryAgent] ✗ Smoke test failed: {e}")
+            return False
+    
+    def is_ready(self):
+        """Check if memory agent is ready"""
+        return self.memory_system.is_ready() if self.memory_system else False
+
+class GeminiThinkingAgent:
+    """Agent responsible for thinking and analysis using Gemini"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.gemini_available = False
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize Gemini API availability"""
+        gemini_key = os.getenv("GEMINI_API_KEY")
+        if gemini_key:
+            os.environ["GEMINI_API_KEY"] = gemini_key
+            self.gemini_available = True
+            logging.info("[GeminiThinkingAgent] ✓ Initialized and ready")
+        else:
+            logging.warning("[GeminiThinkingAgent] ✗ GEMINI_API_KEY not found")
+    
+    def think(self, user_input, emotional_state, conversation_history, retrieved_memories=None):
+        """Think about and analyze the conversation context"""
+        if not self.gemini_available:
+            logging.warning("[GeminiThinkingAgent] Not available")
+            return None
+        
+        try:
+            # Build thinking prompt with conversation context
+            emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
+            
+            # Prepare conversation context for thinking
+            context_summary = ""
+            if conversation_history:
+                recent_history = conversation_history[-6:]  # Last 3 exchanges
+                context_summary = "\nRecent conversation:\n"
+                for msg in recent_history:
+                    role = "User" if msg["role"] == "user" else "Galatea"
+                    context_summary += f"{role}: {msg['content']}\n"
+            
+            # Add retrieved memories if available
+            memory_context = ""
+            if retrieved_memories and len(retrieved_memories) > 0:
+                memory_context = "\n\nRelevant memories from past conversations:\n"
+                for i, memory in enumerate(retrieved_memories[:3], 1):  # Top 3 most relevant
+                    memory_context += f"{i}. {memory['text'][:200]}...\n"
+            
+            thinking_prompt = f"""You are the internal reasoning system for Galatea, an AI assistant.
+
+Current emotional state: {emotions_text}
+{context_summary}
+{memory_context}
+Current user message: "{user_input}"
+
+Analyze this conversation and provide:
+1. Key insights about what the user is asking or discussing
+2. Important context from the conversation history and retrieved memories
+3. How Galatea should respond emotionally and contextually
+4. Any important details to remember or reference
+
+Keep your analysis concise (2-3 sentences). Focus on what matters for crafting an appropriate response."""
+            
+            messages = [
+                {"role": "system", "content": "You are an internal reasoning system. Analyze conversations and provide insights."},
+                {"role": "user", "content": thinking_prompt}
+            ]
+            
+            logging.info("[GeminiThinkingAgent] Processing thinking request...")
+            
+            # Get Gemini models from config
+            gemini_config = self.config.get('gemini', {}) if self.config else {}
+            gemini_models = gemini_config.get('thinking_models', [
+                "gemini/gemini-2.0-flash-exp",
+                "gemini/gemini-2.0-flash",
+                "gemini/gemini-1.5-flash-latest",
+                "gemini/gemini-1.5-flash"
+            ])
+            
+            # Get thinking settings from config
+            thinking_config = gemini_config.get('thinking', {})
+            thinking_temp = thinking_config.get('temperature', 0.5)
+            thinking_max_tokens = thinking_config.get('max_tokens', 200)
+            
+            for model in gemini_models:
+                try:
+                    response = completion(
+                        model=model,
+                        messages=messages,
+                        temperature=thinking_temp,
+                        max_tokens=thinking_max_tokens
+                    )
+                    
+                    if response and 'choices' in response and len(response['choices']) > 0:
+                        thinking_result = response['choices'][0]['message']['content']
+                        logging.info("[GeminiThinkingAgent] ✓ Thinking completed")
+                        return thinking_result.strip()
+                except Exception as e:
+                    logging.warning(f"[GeminiThinkingAgent] Model {model} failed: {e}, trying next...")
+                    continue
+
+            logging.error("[GeminiThinkingAgent] All models failed")
+            return None
+            
+        except Exception as e:
+            logging.error(f"[GeminiThinkingAgent] Error: {e}")
+            return None
+    
+    def smoke_test(self):
+        """Perform smoke test to verify Gemini is working"""
+        if not self.gemini_available:
+            return False
+        
+        try:
+            test_result = self.think(
+                "test",
+                {"joy": 0.5, "sadness": 0.3, "anger": 0.1, "fear": 0.1, "curiosity": 0.5},
+                [],
+                retrieved_memories=None
+            )
+            if test_result and len(test_result) > 0:
+                logging.info("[GeminiThinkingAgent] ✓ Smoke test passed")
+                return True
+            else:
+                logging.warning("[GeminiThinkingAgent] ⚠ Smoke test failed - no result")
+                return False
+        except Exception as e:
+            logging.error(f"[GeminiThinkingAgent] ✗ Smoke test failed: {e}")
+            return False
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.gemini_available
+
+class PiResponseAgent:
+    """Agent responsible for generating human-facing responses using Pi-3.1"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.inflection_ai_available = False
+        self.inflection_ai_api_key = None
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize Inflection AI API availability"""
+        inflection_key = os.getenv("INFLECTION_AI_API_KEY")
+        if inflection_key:
+            self.inflection_ai_api_key = inflection_key
+            self.inflection_ai_available = True
+            logging.info("[PiResponseAgent] ✓ Initialized and ready")
+        else:
+            logging.warning("[PiResponseAgent] ✗ INFLECTION_AI_API_KEY not found")
+    
+    def respond(self, user_input, emotional_state, thinking_context=None, conversation_history=None, retrieved_memories=None):
+        """Generate response using Pi-3.1 with thinking context and emotional state"""
+        if not self.inflection_ai_available:
+            logging.warning("[PiResponseAgent] Not available")
+            return None
+
+        try:
+            # Create context with emotional state
+            emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
+            
+            # Get endpoint and config from YAML
+            inflection_config = self.config.get('inflection_ai', {}) if self.config else {}
+            url = inflection_config.get('api_endpoint', 'https://api.inflection.ai/external/api/inference')
+            model_config = inflection_config.get('model_config', 'Pi-3.1')
+            
+            headers = {
+                "Authorization": f"Bearer {self.inflection_ai_api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            # Build comprehensive context with thinking insights, conversation history, and retrieved memories
+            context_parts = []
+            
+            # Base system context
+            base_context = f"You are Galatea, an AI assistant with the following emotional state: {emotions_text}. Respond in character as Galatea. Keep your response concise (under 50 words) and reflect your emotional state in your tone."
+            
+            # Add thinking context from Gemini if available
+            if thinking_context:
+                base_context += f"\n\nInternal analysis: {thinking_context}"
+            
+            # Add retrieved memories if available
+            if retrieved_memories and len(retrieved_memories) > 0:
+                memory_text = "\n\nRelevant context from past conversations:\n"
+                for i, memory in enumerate(retrieved_memories[:3], 1):  # Top 3 most relevant
+                    memory_text += f"{i}. {memory['text'][:150]}...\n"
+                base_context += memory_text
+            
+            # Add conversation history context
+            if conversation_history and len(conversation_history) > 0:
+                recent_history = conversation_history[-4:]  # Last 2 exchanges
+                history_text = "\n\nRecent conversation context:\n"
+                for msg in recent_history:
+                    role = "User" if msg["role"] == "user" else "You (Galatea)"
+                    history_text += f"{role}: {msg['content']}\n"
+                base_context += history_text
+            
+            context_parts.append({
+                "text": base_context,
+                "type": "System"
+            })
+            
+            # Add conversation history as context messages
+            if conversation_history and len(conversation_history) > 4:
+                # Add older messages as context (but not the most recent ones we already included)
+                for msg in conversation_history[-8:-4]:
+                    context_parts.append({
+                        "text": msg["content"],
+                        "type": "Human" if msg["role"] == "user" else "Assistant"
+                    })
+            
+            # Add current user input
+            context_parts.append({
+                "text": user_input,
+                "type": "Human"
+            })
+            
+            data = {
+                "context": context_parts,
+                "config": model_config
+            }
+
+            logging.info("[PiResponseAgent] Sending request to Pi-3.1 API...")
+            response = requests.post(url, headers=headers, json=data, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                # Extract the response text from the API response
+                if isinstance(result, dict):
+                    if 'output' in result:
+                        text = result['output']
+                    elif 'text' in result:
+                        text = result['text']
+                    elif 'response' in result:
+                        text = result['response']
+                    elif 'message' in result:
+                        text = result['message']
+                    else:
+                        text = str(result)
+                elif isinstance(result, str):
+                    text = result
+                else:
+                    text = str(result)
+                
+                logging.info("[PiResponseAgent] ✓ Response received")
+                return text.strip()
+            else:
+                logging.error(f"[PiResponseAgent] API returned status code {response.status_code}: {response.text}")
+                return None
+
+        except Exception as e:
+            logging.error(f"[PiResponseAgent] Error: {e}")
+            return None
+    
+    def smoke_test(self):
+        """Perform smoke test to verify Pi-3.1 is working"""
+        if not self.inflection_ai_available:
+            return False
+        
+        try:
+            test_result = self.respond(
+                "Hello",
+                {"joy": 0.5, "sadness": 0.3, "anger": 0.1, "fear": 0.1, "curiosity": 0.5},
+                thinking_context="Test thinking context",
+                conversation_history=[],
+                retrieved_memories=None
+            )
+            if test_result and len(test_result) > 0:
+                logging.info("[PiResponseAgent] ✓ Smoke test passed")
+                return True
+            else:
+                logging.warning("[PiResponseAgent] ⚠ Smoke test failed - no result")
+                return False
+        except Exception as e:
+            logging.error(f"[PiResponseAgent] ✗ Smoke test failed: {e}")
+            return False
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.inflection_ai_available
+
+class EmotionalStateAgent:
+    """Agent responsible for managing and updating emotional state"""
+    
+    def __init__(self, initial_state=None, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.emotional_state = initial_state or {"joy": 0.2, "sadness": 0.2, "anger": 0.2, "fear": 0.2, "curiosity": 0.2}
+        self.learning_rate = 0.05
+        self.quantum_random_available = False
+        self.quantum_api_key = None
+        self._initialize_quantum()
+    
+    def _initialize_quantum(self):
+        """Initialize quantum randomness availability"""
+        quantum_key = os.getenv("ANU_QUANTUM_API_KEY")
+        if quantum_key:
+            self.quantum_api_key = quantum_key
+            self.quantum_random_available = True
+            logging.info("[EmotionalStateAgent] ✓ Quantum randomness available")
+        else:
+            logging.warning("[EmotionalStateAgent] Quantum randomness unavailable")
+    
+    def get_quantum_random_float(self, min_val=0.0, max_val=1.0):
+        """Get a quantum random float between min_val and max_val"""
+        if not self.quantum_random_available:
+            return random.uniform(min_val, max_val)
+        
+        try:
+            quantum_config = self.config.get('quantum', {}) if self.config else {}
+            url = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
+            headers = {"x-api-key": self.quantum_api_key}
+            params = {"length": 1, "type": "uint8"}
+            
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get('success') and 'data' in result and len(result['data']) > 0:
+                    normalized = result['data'][0] / 255.0
+                    return min_val + (max_val - min_val) * normalized
+        except Exception as e:
+            logging.warning(f"[EmotionalStateAgent] Quantum API failed: {e}")
+        
+        return random.uniform(min_val, max_val)
+    
+    def update_with_sentiment(self, sentiment_score):
+        """Update emotional state based on sentiment"""
+        # Enhanced Emotion Update (decay and normalization with quantum randomness)
+        decay_factor = 0.9
+        if self.quantum_random_available:
+            quantum_decay_variation = self.get_quantum_random_float(0.85, 0.95)
+            decay_factor = quantum_decay_variation
+        
+        for emotion in self.emotional_state:
+            # Decay emotions (more realistic fading with quantum variation)
+            self.emotional_state[emotion] *= decay_factor
+            # Normalize
+            self.emotional_state[emotion] = max(0.0, min(1.0, self.emotional_state[emotion]))
+
+        # Apply sentiment with quantum-enhanced learning rate variation
+        learning_rate = self.learning_rate
+        if self.quantum_random_available:
+            quantum_lr_variation = self.get_quantum_random_float(0.03, 0.07)
+            learning_rate = quantum_lr_variation
+        
+        self.emotional_state["joy"] += sentiment_score * learning_rate
+        self.emotional_state["sadness"] -= sentiment_score * learning_rate
+        
+        # Add quantum randomness to curiosity (making responses more unpredictable)
+        if self.quantum_random_available:
+            quantum_curiosity_boost = self.get_quantum_random_float(-0.05, 0.05)
+            self.emotional_state["curiosity"] = max(0.0, min(1.0, 
+                self.emotional_state["curiosity"] + quantum_curiosity_boost))
+
+        # Re-normalize
+        total_emotion = sum(self.emotional_state.values())
+        for emotion in self.emotional_state:
+            self.emotional_state[emotion] = self.emotional_state[emotion] / total_emotion if total_emotion > 0 else 0.2
+        
+        logging.info(f"[EmotionalStateAgent] Updated emotional state: {self.emotional_state}")
+        return self.emotional_state
+    
+    def get_state(self):
+        """Get current emotional state"""
+        return self.emotional_state.copy()
+    
+    def smoke_test(self):
+        """Perform smoke test to verify emotional state system is working"""
+        try:
+            # Test quantum randomness if available
+            if self.quantum_random_available:
+                test_float = self.get_quantum_random_float(0.0, 1.0)
+                if not isinstance(test_float, float) or test_float < 0.0 or test_float > 1.0:
+                    logging.warning("[EmotionalStateAgent] ⚠ Smoke test failed - invalid quantum random")
+                    return False
+            
+            # Test state update
+            initial_state = self.get_state().copy()
+            updated_state = self.update_with_sentiment(0.5)
+            if updated_state and isinstance(updated_state, dict):
+                logging.info("[EmotionalStateAgent] ✓ Smoke test passed")
+                return True
+            else:
+                logging.warning("[EmotionalStateAgent] ⚠ Smoke test failed - invalid state")
+                return False
+        except Exception as e:
+            logging.error(f"[EmotionalStateAgent] ✗ Smoke test failed: {e}")
+            return False
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return True  # Emotional state is always ready
+
+class AzureTextAnalyticsAgent:
+    """Agent responsible for Azure Text Analytics sentiment analysis"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.azure_available = False
+        self.client = None
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize Azure Text Analytics client"""
+        try:
+            from azure.ai.textanalytics import TextAnalyticsClient
+            from azure.core.credentials import AzureKeyCredential
+            
+            key = os.getenv("AZURE_TEXT_ANALYTICS_KEY")
+            endpoint = os.getenv("AZURE_TEXT_ANALYTICS_ENDPOINT")
+            
+            if key and endpoint:
+                try:
+                    credential = AzureKeyCredential(key)
+                    self.client = TextAnalyticsClient(endpoint=endpoint, credential=credential)
+                    self.azure_available = True
+                    logging.info("[AzureTextAnalyticsAgent] ✓ Initialized and ready")
+                except Exception as e:
+                    logging.warning(f"[AzureTextAnalyticsAgent] Failed to create client: {e}")
+                    self.azure_available = False
+            else:
+                logging.warning("[AzureTextAnalyticsAgent] ✗ Azure credentials not found")
+                self.azure_available = False
+        except ImportError:
+            logging.warning("[AzureTextAnalyticsAgent] ✗ Azure SDK not installed")
+            self.azure_available = False
+    
+    def analyze(self, text):
+        """Analyze sentiment using Azure Text Analytics"""
+        if not self.azure_available or not self.client:
+            return None
+        
+        try:
+            result = self.client.analyze_sentiment(documents=[text])[0]
+            if result.sentiment == 'positive':
+                return result.confidence_scores.positive
+            elif result.sentiment == 'negative':
+                return -result.confidence_scores.negative
+            else:
+                return 0.0
+        except Exception as e:
+            logging.error(f"[AzureTextAnalyticsAgent] Error: {e}")
+            return None
+    
+    def smoke_test(self):
+        """Perform smoke test to verify Azure Text Analytics is working"""
+        if not self.azure_available:
+            return False
+        
+        try:
+            test_text = "This is a test message for sentiment analysis."
+            result = self.analyze(test_text)
+            if result is not None:
+                logging.info("[AzureTextAnalyticsAgent] ✓ Smoke test passed")
+                return True
+            else:
+                logging.warning("[AzureTextAnalyticsAgent] ⚠ Smoke test failed - analyze returned None")
+                return False
+        except Exception as e:
+            logging.error(f"[AzureTextAnalyticsAgent] ✗ Smoke test failed: {e}")
+            return False
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.azure_available
+
+class SentimentAgent:
+    """Agent responsible for sentiment analysis (uses Azure, Hugging Face, or NLTK fallback)"""
+    
+    def __init__(self, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        self.azure_agent = AzureTextAnalyticsAgent(config=self.config)
+        self.sentiment_analyzer = None
+        self.ready = False
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize sentiment analyzer"""
+        # Try Azure first
+        if self.azure_agent.is_ready():
+            self.ready = True
+            logging.info("[SentimentAgent] Using Azure Text Analytics")
+            return
+        
+        # Fallback to Hugging Face
+        sentiment_model = self.config.get('sentiment', {}).get('primary_model', 'distilbert/distilbert-base-uncased-finetuned-sst-2-english') if self.config else 'distilbert/distilbert-base-uncased-finetuned-sst-2-english'
+        
+        if transformers_available:
+            try:
+                logging.info("[SentimentAgent] Initializing Hugging Face sentiment analyzer...")
+                self.sentiment_analyzer = pipeline("sentiment-analysis", model=sentiment_model)
+                self.ready = True
+                logging.info("[SentimentAgent] ✓ Initialized successfully")
+            except Exception as e:
+                logging.warning(f"[SentimentAgent] Hugging Face model failed: {e}, using fallback")
+                self.sentiment_analyzer = None
+                self.ready = True  # Fallback available
+        else:
+            self.ready = True  # Fallback available
+    
+    def analyze(self, text):
+        """Analyze sentiment of text (tries Azure, then Hugging Face, then NLTK)"""
+        # Try Azure first
+        if self.azure_agent.is_ready():
+            result = self.azure_agent.analyze(text)
+            if result is not None:
+                return result
+        
+        # Fallback to Hugging Face
+        if self.sentiment_analyzer:
+            try:
+                result = self.sentiment_analyzer(text)[0]
+                label = result['label'].lower()
+                score = result['score']
+                
+                if 'positive' in label:
+                    return score
+                elif 'negative' in label:
+                    return -score
+                else:
+                    return 0.0
+            except Exception as e:
+                logging.error(f"[SentimentAgent] Error: {e}")
+                return self._fallback_analyze(text)
+        else:
+            return self._fallback_analyze(text)
+    
+    def _fallback_analyze(self, text):
+        """Fallback sentiment analysis using NLTK VADER"""
+        try:
+            from nltk.sentiment import SentimentIntensityAnalyzer
+            analyzer = SentimentIntensityAnalyzer()
+            scores = analyzer.polarity_scores(text)
+            return scores['compound']  # Returns value between -1 and 1
+        except Exception as e:
+            logging.error(f"[SentimentAgent] Fallback failed: {e}")
+            return 0.0
+    
+    def smoke_test(self):
+        """Perform smoke test to verify sentiment analysis is working"""
+        try:
+            test_text = "I am happy and excited!"
+            result = self.analyze(test_text)
+            if result is not None and isinstance(result, (int, float)):
+                logging.info("[SentimentAgent] ✓ Smoke test passed")
+                return True
+            else:
+                logging.warning("[SentimentAgent] ⚠ Smoke test failed - invalid result")
+                return False
+        except Exception as e:
+            logging.error(f"[SentimentAgent] ✗ Smoke test failed: {e}")
+            return False
+    
+    def is_ready(self):
+        """Check if agent is ready"""
+        return self.ready
+
 # --- 1. AI Core ---
 class GalateaAI:
     def __init__(self):
-        self.emotional_state = {"joy": 0.2, "sadness": 0.2, "anger": 0.2, "fear": 0.2, "curiosity": 0.2}
+        # Load model configuration first
+        self.config = MODEL_CONFIG or {}
+        
         self.knowledge_base = {}
-        self.learning_rate = 0.05 # Reduced learning rate
         self.response_model = "A generic response" #Place Holder for the ML model
         
-        # Initialize sentiment analyzer with fallback
-        self.initialize_sentiment_analyzer()
+        # Conversation history for context
+        self.conversation_history = []  # List of {"role": "user"/"assistant", "content": "..."}
+        # Get max history length from config or use default
+        self.max_history_length = self.config.get('conversation', {}).get('max_history_length', 20)
+        
+        # Initialize memory system
+        logging.info("Initializing memory system (JSON)...")
+        try:
+            self.memory_system = MemorySystem(config=self.config)
+            self.memory_system_ready = self.memory_system.is_ready()
+            if not self.memory_system_ready:
+                raise Exception("Memory system failed to initialize")
+            logging.info("✓ Memory system initialized")
+        except Exception as e:
+            logging.error(f"Failed to initialize memory system: {e}")
+            self.memory_system_ready = False
+            raise
+        
+        # Initialize agents
+        logging.info("Initializing agents...")
+        self.memory_agent = MemoryAgent(self.memory_system, config=self.config)
+        self.gemini_agent = GeminiThinkingAgent(config=self.config)
+        self.pi_agent = PiResponseAgent(config=self.config)
+        self.emotional_agent = EmotionalStateAgent(config=self.config)
+        self.sentiment_agent = SentimentAgent(config=self.config)
         
-        # Initialize Gemini API
-        self.initialize_gemini()
+        # Track initialization status
+        self.memory_system_ready = self.memory_agent.is_ready()
+        self.sentiment_analyzer_ready = self.sentiment_agent.is_ready()
+        self.models_ready = self.gemini_agent.is_ready() or self.pi_agent.is_ready()
+        self.api_keys_valid = self.gemini_agent.is_ready() or self.pi_agent.is_ready()
+        
+        # Legacy compatibility
+        self.gemini_available = self.gemini_agent.is_ready()
+        self.inflection_ai_available = self.pi_agent.is_ready()
+        self.quantum_random_available = self.emotional_agent.quantum_random_available
+        
+        logging.info("✓ All agents initialized")
+    
+    def _check_pre_initialization(self):
+        """Check if components were pre-initialized by initialize_galatea.py"""
+        # Check if ChromaDB directory exists and has collection
+        chromadb_path = "./chroma_db"
+        if os.path.exists(chromadb_path):
+            try:
+                import chromadb
+                from chromadb.config import Settings
+                vector_db = chromadb.PersistentClient(
+                    path=chromadb_path,
+                    settings=Settings(anonymized_telemetry=False)
+                )
+                collection = vector_db.get_collection("galatea_memory")
+                if collection:
+                    logging.info("✓ Pre-initialized ChromaDB detected")
+                    return True
+            except Exception:
+                pass
+        
+        # Check if JSON memory exists
+        if os.path.exists("./memory.json"):
+            logging.info("✓ Pre-initialized JSON memory detected")
+            return True
+        
+        return False
+    
+    def is_fully_initialized(self):
+        """Check if all components are fully initialized"""
+        return (
+            self.memory_system_ready and
+            self.sentiment_analyzer_ready and
+            self.models_ready and
+            self.api_keys_valid
+        )
+    
+    def get_initialization_status(self):
+        """Get detailed initialization status"""
+        smoke_tests = getattr(self, 'smoke_test_results', {})
+        return {
+            "memory_system": self.memory_system_ready,
+            "sentiment_analyzer": self.sentiment_analyzer_ready,
+            "models": self.models_ready,
+            "api_keys": self.api_keys_valid,
+            "gemini_available": self.gemini_agent.is_ready() if hasattr(self, 'gemini_agent') else False,
+            "inflection_ai_available": self.pi_agent.is_ready() if hasattr(self, 'pi_agent') else False,
+            "azure_text_analytics_available": self.sentiment_agent.azure_agent.is_ready() if hasattr(self, 'sentiment_agent') else False,
+            "smoke_tests": smoke_tests,
+            "fully_initialized": self.is_fully_initialized()
+        }
+    
+    @property
+    def emotional_state(self):
+        """Get current emotional state from EmotionalStateAgent"""
+        return self.emotional_agent.get_state() if hasattr(self, 'emotional_agent') else {"joy": 0.2, "sadness": 0.2, "anger": 0.2, "fear": 0.2, "curiosity": 0.2}
         
     def initialize_sentiment_analyzer(self):
         """Initialize sentiment analysis with fallback options"""
+        self.sentiment_analyzer_ready = False
+        # Get sentiment model from config
+        sentiment_model = self.config.get('sentiment', {}).get('primary_model', 'distilbert/distilbert-base-uncased-finetuned-sst-2-english') if self.config else 'distilbert/distilbert-base-uncased-finetuned-sst-2-english'
+        
         if transformers_available:
             try:
                 logging.info("Attempting to initialize Hugging Face sentiment analyzer")
                 # Try to initialize the pipeline with specific parameters
                 self.sentiment_analyzer = pipeline(
                     "sentiment-analysis", 
-                    model="distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+                    model=sentiment_model
                 )
-                logging.info("Hugging Face sentiment analyzer loaded successfully")
+                self.sentiment_analyzer_ready = True
+                logging.info("✓ Hugging Face sentiment analyzer loaded successfully")
             except Exception as e:
                 logging.error(f"Failed to initialize Hugging Face sentiment analyzer: {e}")
                 self.sentiment_analyzer = None
+                # Still mark as ready since we have fallback
+                self.sentiment_analyzer_ready = True
+                logging.info("✓ Using fallback sentiment analyzer")
         else:
             self.sentiment_analyzer = None
+            self.sentiment_analyzer_ready = True  # Fallback available
+            logging.info("✓ Using fallback sentiment analyzer")
             
     def analyze_sentiment(self, text):
         # Use Hugging Face if available
@@ -92,102 +927,407 @@ class GalateaAI:
                 
         return max(-1.0, min(1.0, sentiment_score))  # Clamp between -1 and 1
         
-    def initialize_gemini(self):
-        """Initialize the Gemini API with API key from .env file"""
-        self.gemini_available = False  # Default to False
+    def initialize_litellm(self):
+        """Initialize LiteLLM for unified model management"""
+        self.gemini_available = False
+        self.inflection_ai_available = False
+        self.quantum_random_available = False
+        self.models_ready = False
+        self.api_keys_valid = False
+        
+        # Check for Gemini API key
+        gemini_key = os.getenv("GEMINI_API_KEY")
+        if gemini_key:
+            os.environ["GEMINI_API_KEY"] = gemini_key
+            self.gemini_available = True
+            logging.info("✓ Gemini API key found - Gemini models available via LiteLLM")
+        else:
+            logging.warning("GEMINI_API_KEY not found - Gemini models unavailable")
+        
+        # Check for Inflection AI API key
+        inflection_key = os.getenv("INFLECTION_AI_API_KEY")
+        if inflection_key:
+            self.inflection_ai_api_key = inflection_key
+            self.inflection_ai_available = True
+            logging.info("✓ Inflection AI API key found - Pi-3.1 model available")
+        else:
+            logging.warning("INFLECTION_AI_API_KEY not found - Pi-3.1 model unavailable")
+        
+        # Check for Quantum Random Numbers API key
+        quantum_key = os.getenv("ANU_QUANTUM_API_KEY")
+        if quantum_key:
+            self.quantum_api_key = quantum_key
+            self.quantum_random_available = True
+            logging.info("✓ ANU Quantum Numbers API key found - Quantum randomness available")
+        else:
+            logging.warning("ANU_QUANTUM_API_KEY not found - Quantum randomness unavailable")
+        
+        # Verify API keys are valid (at least one model API key must be present)
+        self.api_keys_valid = self.gemini_available or self.inflection_ai_available
+        if self.api_keys_valid:
+            logging.info("✓ API keys validated - at least one model API key is available")
+        else:
+            logging.error("✗ No valid API keys found - models unavailable")
+        
+        # Models are ready if at least one is available
+        self.models_ready = self.gemini_available or self.inflection_ai_available
+        if self.models_ready:
+            logging.info("✓ Models ready for use")
+        else:
+            logging.warning("⚠ No models available")
+    
+    def get_quantum_random_numbers(self, length=None, number_type=None):
+        """Fetch quantum random numbers from ANU Quantum Numbers API"""
+        if not self.quantum_random_available:
+            logging.warning("Quantum random numbers unavailable, using fallback")
+            return None
+        
+        # Get defaults from config
+        quantum_config = self.config.get('quantum', {}) if self.config else {}
+        if length is None:
+            length = quantum_config.get('default_length', 128)
+        if number_type is None:
+            number_type = quantum_config.get('default_type', 'uint8')
+        
+        try:
+            url = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
+            headers = {
+                "x-api-key": self.quantum_api_key
+            }
+            params = {
+                "length": length,
+                "type": number_type
+            }
+            
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get('success') and 'data' in result:
+                    logging.info(f"✓ Retrieved {len(result['data'])} quantum random numbers")
+                    return result['data']
+                else:
+                    logging.warning("Quantum API returned success but no data")
+                    return None
+            else:
+                logging.error(f"Quantum API returned status code {response.status_code}: {response.text}")
+                return None
+                
+        except Exception as e:
+            logging.error(f"Error fetching quantum random numbers: {e}")
+            return None
+    
+    def get_quantum_random_float(self, min_val=0.0, max_val=1.0):
+        """Get a quantum random float between min_val and max_val"""
+        quantum_nums = self.get_quantum_random_numbers(length=1, number_type='uint8')
+        if quantum_nums and len(quantum_nums) > 0:
+            # Normalize uint8 (0-255) to float range
+            normalized = quantum_nums[0] / 255.0
+            return min_val + (max_val - min_val) * normalized
+        # Fallback to regular random
+        return random.uniform(min_val, max_val)
+    
+    def call_inflection_ai(self, user_input, emotional_state, thinking_context=None, conversation_history=None, retrieved_memories=None):
+        """Call Inflection AI Pi-3.1 model API with conversation context, thinking insights, and retrieved memories"""
+        if not self.inflection_ai_available:
+            return None
 
         try:
-            # Get API key from environment variable
-            api_key = os.getenv("GEMINI_API_KEY")
+            # Create context with emotional state
+            emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
+            
+            # Format the request according to Inflection AI API
+            # Get endpoint and config from YAML
+            inflection_config = self.config.get('inflection_ai', {}) if self.config else {}
+            url = inflection_config.get('api_endpoint', 'https://api.inflection.ai/external/api/inference')
+            model_config = inflection_config.get('model_config', 'Pi-3.1')
+            
+            headers = {
+                "Authorization": f"Bearer {self.inflection_ai_api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            # Build comprehensive context with thinking insights, conversation history, and retrieved memories
+            context_parts = []
+            
+            # Base system context
+            base_context = f"You are Galatea, an AI assistant with the following emotional state: {emotions_text}. Respond in character as Galatea. Keep your response concise (under 50 words) and reflect your emotional state in your tone."
+            
+            # Add thinking context from Gemini if available
+            if thinking_context:
+                base_context += f"\n\nInternal analysis: {thinking_context}"
+            
+            # Add retrieved memories if available
+            if retrieved_memories and len(retrieved_memories) > 0:
+                memory_text = "\n\nRelevant context from past conversations:\n"
+                for i, memory in enumerate(retrieved_memories[:3], 1):  # Top 3 most relevant
+                    memory_text += f"{i}. {memory['text'][:150]}...\n"
+                base_context += memory_text
+            
+            # Add conversation history context
+            if conversation_history and len(conversation_history) > 0:
+                recent_history = conversation_history[-4:]  # Last 2 exchanges
+                history_text = "\n\nRecent conversation context:\n"
+                for msg in recent_history:
+                    role = "User" if msg["role"] == "user" else "You (Galatea)"
+                    history_text += f"{role}: {msg['content']}\n"
+                base_context += history_text
+            
+            context_parts.append({
+                "text": base_context,
+                "type": "System"
+            })
+            
+            # Add conversation history as context messages
+            if conversation_history and len(conversation_history) > 4:
+                # Add older messages as context (but not the most recent ones we already included)
+                for msg in conversation_history[-8:-4]:
+                    context_parts.append({
+                        "text": msg["content"],
+                        "type": "Human" if msg["role"] == "user" else "Assistant"
+                    })
+            
+            # Add current user input
+            context_parts.append({
+                "text": user_input,
+                "type": "Human"
+            })
+            
+            data = {
+                "context": context_parts,
+                "config": model_config
+            }
 
-            logging.info(f"Checking for GEMINI_API_KEY... Found: {bool(api_key)}")
+            logging.info("Sending request to Inflection AI Pi-3.1 API")
+            response = requests.post(url, headers=headers, json=data, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                # Extract the response text from the API response
+                if isinstance(result, dict):
+                    if 'output' in result:
+                        text = result['output']
+                    elif 'text' in result:
+                        text = result['text']
+                    elif 'response' in result:
+                        text = result['response']
+                    elif 'message' in result:
+                        text = result['message']
+                    else:
+                        text = str(result)
+                elif isinstance(result, str):
+                    text = result
+                else:
+                    text = str(result)
+                
+                logging.info("Inflection AI response received successfully")
+                return text.strip()
+            else:
+                logging.error(f"Inflection AI API returned status code {response.status_code}: {response.text}")
+                return None
 
-            if not api_key:
-                # Log error and fail gracefully (no input prompt for web deployment)
-                logging.error("GEMINI_API_KEY not found in environment variables.")
-                logging.error("Please set GEMINI_API_KEY in your environment or .env file")
-                logging.error("Bot will use fallback responses only.")
-                return
+        except Exception as e:
+            logging.error(f"Error calling Inflection AI API: {e}")
+            logging.error(f"Full error details: {type(e).__name__}: {str(e)}")
+            return None
 
-            # Configure the Gemini API
-            logging.info("Configuring Gemini API...")
-            genai.configure(api_key=api_key)
+    def gemini_think(self, user_input, emotional_state, conversation_history, retrieved_memories=None):
+        """Use Gemini to think about and analyze the conversation context with retrieved memories"""
+        if not self.gemini_available:
+            return None
+        
+        try:
+            # Build thinking prompt with conversation context
+            emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
             
-            # Use Gemini 2.0 Flash (latest and fastest model)
-            try:
-                # Try Gemini 2.0 Flash first (newest model)
-                preferred_models = [
-                    "gemini-2.0-flash-exp",
-                    "gemini-2.0-flash",
-                    "gemini-1.5-flash-latest",
-                    "gemini-1.5-flash",
-                ]
-
-                model_name = None
-                last_error = None
-
-                for model in preferred_models:
-                    try:
-                        logging.info(f"Attempting to initialize with model: {model}")
-                        self.gemini_model = genai.GenerativeModel(model)
-
-                        # Test the model with a simple prompt
-                        logging.info(f"Testing {model} with a simple prompt...")
-                        test_response = self.gemini_model.generate_content("Hello")
-
-                        if hasattr(test_response, 'text') and test_response.text:
-                            logging.info(f"✓ Test response received: {test_response.text[:50]}...")
-                            model_name = model
-                            self.gemini_available = True
-                            logging.info(f"✓ Gemini API initialized successfully with model: {model_name}")
-                            print(f"✓ Gemini API initialized successfully with model: {model_name}")
-                            break
-                        else:
-                            logging.warning(f"Model {model} returned empty response")
-                            continue
-
-                    except Exception as e:
-                        last_error = e
-                        logging.warning(f"Model {model} failed: {e}")
-                        continue
-
-                if not model_name:
-                    raise Exception(f"All models failed. Last error: {last_error}")
+            # Prepare conversation context for thinking
+            context_summary = ""
+            if conversation_history:
+                recent_history = conversation_history[-6:]  # Last 3 exchanges
+                context_summary = "\nRecent conversation:\n"
+                for msg in recent_history:
+                    role = "User" if msg["role"] == "user" else "Galatea"
+                    context_summary += f"{role}: {msg['content']}\n"
+            
+            # Add retrieved memories if available
+            memory_context = ""
+            if retrieved_memories and len(retrieved_memories) > 0:
+                memory_context = "\n\nRelevant memories from past conversations:\n"
+                for i, memory in enumerate(retrieved_memories[:3], 1):  # Top 3 most relevant
+                    memory_context += f"{i}. {memory['text'][:200]}...\n"
+            
+            thinking_prompt = f"""You are the internal reasoning system for Galatea, an AI assistant.
 
-            except Exception as e:
-                logging.error(f"Error initializing Gemini model: {e}")
-                logging.error(f"Full error: {type(e).__name__}: {str(e)}")
-                logging.error("Bot will use fallback responses only.")
-                self.gemini_available = False
+Current emotional state: {emotions_text}
+{context_summary}
+{memory_context}
+Current user message: "{user_input}"
+
+Analyze this conversation and provide:
+1. Key insights about what the user is asking or discussing
+2. Important context from the conversation history and retrieved memories
+3. How Galatea should respond emotionally and contextually
+4. Any important details to remember or reference
+
+Keep your analysis concise (2-3 sentences). Focus on what matters for crafting an appropriate response."""
+            
+            messages = [
+                {"role": "system", "content": "You are an internal reasoning system. Analyze conversations and provide insights."},
+                {"role": "user", "content": thinking_prompt}
+            ]
+            
+            logging.info("Using Gemini for thinking/analysis")
+            
+            # Get Gemini models from config
+            gemini_config = self.config.get('gemini', {}) if self.config else {}
+            gemini_models = gemini_config.get('thinking_models', [
+                "gemini/gemini-2.0-flash-exp",
+                "gemini/gemini-2.0-flash",
+                "gemini/gemini-1.5-flash-latest",
+                "gemini/gemini-1.5-flash"
+            ])
+            
+            # Get thinking settings from config
+            thinking_config = gemini_config.get('thinking', {})
+            thinking_temp = thinking_config.get('temperature', 0.5)
+            thinking_max_tokens = thinking_config.get('max_tokens', 200)
+            
+            for model in gemini_models:
+                try:
+                    response = completion(
+                        model=model,
+                        messages=messages,
+                        temperature=thinking_temp,
+                        max_tokens=thinking_max_tokens
+                    )
+                    
+                    if response and 'choices' in response and len(response['choices']) > 0:
+                        thinking_result = response['choices'][0]['message']['content']
+                        logging.info("✓ Gemini thinking completed")
+                        return thinking_result.strip()
+                except Exception as e:
+                    logging.warning(f"Gemini model {model} failed for thinking: {e}, trying next...")
+                    continue
 
+            logging.error("All Gemini models failed for thinking")
+            return None
+            
         except Exception as e:
-            logging.error(f"Failed to initialize Gemini API: {e}")
-            logging.error("Bot will use fallback responses only.")
-            print(f"✗ Failed to initialize Gemini API: {e}")
-            self.gemini_available = False
+            logging.error(f"Error in Gemini thinking: {e}")
+            return None
+    
+    def update_conversation_history(self, user_input, assistant_response):
+        """Update conversation history, maintaining max length"""
+        # Add user message
+        self.conversation_history.append({"role": "user", "content": user_input})
+        # Add assistant response
+        self.conversation_history.append({"role": "assistant", "content": assistant_response})
+        
+        # Trim history if too long
+        if len(self.conversation_history) > self.max_history_length:
+            # Keep the most recent messages
+            self.conversation_history = self.conversation_history[-self.max_history_length:]
+    
+    def store_important_memory(self, user_input, assistant_response, intent, keywords):
+        """Store important conversation snippets in memory system"""
+        try:
+            # Determine if this conversation is worth storing
+            # Store if: question, contains important keywords, or is a significant exchange
+            should_store = False
+            memory_type = "conversation"
+            
+            if intent == "question":
+                should_store = True
+                memory_type = "question"
+            elif len(keywords) > 3:  # Substantial conversation
+                should_store = True
+            elif any(keyword in ["remember", "important", "note", "save"] for keyword in keywords):
+                should_store = True
+                memory_type = "important"
+            
+            if should_store:
+                # Create a memory entry combining user input and response
+                memory_text = f"User: {user_input}\nGalatea: {assistant_response}"
+                
+                metadata = {
+                    "intent": intent,
+                    "keywords": keywords[:5],  # Top 5 keywords
+                    "emotions": {k: round(v, 2) for k, v in self.emotional_state.items()}
+                }
+                
+                # Store in memory system (both ChromaDB and JSON)
+                self.memory_system.store_memory(
+                    text=memory_text,
+                    metadata=metadata,
+                    memory_type=memory_type
+                )
+                logging.info(f"Stored important memory: {memory_type} - {user_input[:50]}...")
+        except Exception as e:
+            logging.error(f"Error storing memory: {e}")
+    
+    def is_thinking_mode(self, intent, user_input, keywords):
+        """Determine if the request requires thinking mode (use Gemini for complex reasoning)"""
+        # Always use thinking mode now - Gemini always thinks, Pi-3.1 always responds
+        return True
 
     def process_input(self, user_input):
-        sentiment_score = self.analyze_sentiment(user_input)
+        """Process user input through the agent chain workflow: PHI(GEMINI(User inputs, read with past memory), emotionalstate)"""
+        # Step 1: Analyze sentiment
+        sentiment_score = self.sentiment_agent.analyze(user_input)
+        
+        # Step 2: Extract keywords and determine intent
         keywords = self.extract_keywords(user_input)
         intent = self.determine_intent(user_input)
-
-        # Enhanced Emotion Update (decay and normalization)
-        for emotion in self.emotional_state:
-            # Decay emotions (more realistic fading)
-            self.emotional_state[emotion] *= 0.9  # Decay by 10% each turn
-            # Normalize
-            self.emotional_state[emotion] = max(0.0, min(1.0, self.emotional_state[emotion]))
-
-        self.emotional_state["joy"] += sentiment_score * self.learning_rate
-        self.emotional_state["sadness"] -= sentiment_score * self.learning_rate
-
-        # Re-normalize
-        total_emotion = sum(self.emotional_state.values())
-        for emotion in self.emotional_state:
-            self.emotional_state[emotion] = self.emotional_state[emotion] / total_emotion if total_emotion > 0 else 0.2
-
+        
+        # Step 3: Update emotional state based on sentiment
+        self.emotional_agent.update_with_sentiment(sentiment_score)
+        current_emotional_state = self.emotional_agent.get_state()
+        
+        # Step 4: Retrieve memories
+        retrieved_memories = self.memory_agent.retrieve_memories(user_input)
+        
+        # Step 5: Chain workflow: PHI(GEMINI(User inputs, read with past memory), emotionalstate)
+        # Step 5a: GEMINI(User inputs, read with past memory)
+        thinking_context = self.gemini_agent.think(
+            user_input,
+            current_emotional_state,
+            self.conversation_history,
+            retrieved_memories=retrieved_memories
+        )
+        
+        # Step 5b: PHI(GEMINI result, emotionalstate)
+        response = self.pi_agent.respond(
+            user_input,
+            current_emotional_state,
+            thinking_context=thinking_context,
+            conversation_history=self.conversation_history,
+            retrieved_memories=retrieved_memories
+        )
+        
+        # Fallback if Pi-3.1 is not available
+        if not response and self.gemini_agent.is_ready():
+            response = self._gemini_fallback_response(
+                user_input, 
+                current_emotional_state, 
+                thinking_context,
+                self.conversation_history
+            )
+        
+        # If still no response, use fallback
+        if not response:
+            response = self._generate_fallback_response(intent, keywords, current_emotional_state, user_input)
+        
+        # Update conversation history
+        if response:
+            self.update_conversation_history(user_input, response)
+            
+            # Store important memories
+            self._store_important_memory(user_input, response, intent, keywords)
+        
+        # Update knowledge base
         self.update_knowledge(keywords, user_input)
-        response = self.generate_response(intent, keywords, self.emotional_state, user_input)
+        
+        return response
         return response
 
     def extract_keywords(self, text):
@@ -217,70 +1357,133 @@ class GalateaAI:
         else:
             return "statement"
 
-    def generate_response(self, intent, keywords, emotional_state, original_input):
-        # Try to use Gemini API if available
-        if hasattr(self, 'gemini_available') and self.gemini_available:
-            try:
-                # Create a prompt that includes emotional context and intent
-                emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
-
-                # Create a character prompt for Gemini
-                prompt = f"""
-                You are Galatea, an AI assistant with the following emotional state:
-                {emotions_text}
-
-                User input: "{original_input}"
-
-                Respond in character as Galatea. Keep your response concise (under 50 words) and reflect your emotional state in your tone.
-                If you're feeling more joy, be more enthusiastic. If sad, be more melancholic.
-                """
-
-                logging.info("Sending request to Gemini API")
-                # Get response from Gemini with safety settings
-                generation_config = {
-                    "temperature": 0.7,
-                    "top_p": 0.8,
-                    "top_k": 40
-                }
-
-                response = self.gemini_model.generate_content(
-                    prompt,
-                    generation_config=generation_config
-                )
+    def _gemini_fallback_response(self, user_input, emotional_state, thinking_context, conversation_history):
+        """Fallback response using Gemini directly"""
+        try:
+            logging.info("[GalateaAI] Using Gemini fallback for direct response")
+            emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
 
-                # Check if response is valid and return it
-                if response and hasattr(response, 'text'):
-                    logging.info(f"Gemini response received successfully")
-                    return response.text.strip()
-                elif hasattr(response, 'parts'):
-                    # Try alternate access method
-                    logging.info(f"Gemini response received via parts")
-                    return response.parts[0].text.strip()
-                else:
-                    logging.warning(f"Unexpected response format: {response}")
-                    # Fall back to basic response
-                    return "I'm processing that..."
+            # Build messages with conversation history
+            messages = []
+            # Get system prompts from config
+            system_prompts = self.config.get('system_prompts', {}) if self.config else {}
+            identity = system_prompts.get('galatea_identity', 'You are Galatea, an AI assistant with emotional awareness and memory.')
+            style = system_prompts.get('response_style', 'Respond in character, keeping responses concise (under 50 words).')
+            
+            messages.append({
+                "role": "system", 
+                "content": f"{identity} Your emotional state: {emotions_text}. {style}"
+            })
+            
+            # Get fallback settings from config
+            gemini_config = self.config.get('gemini', {}) if self.config else {}
+            fallback_config = gemini_config.get('fallback', {})
+            max_history_exchanges = fallback_config.get('max_history_exchanges', 8)
+            fallback_model = gemini_config.get('fallback_model', 'gemini/gemini-1.5-flash')
+            
+            # Add conversation history
+            if conversation_history:
+                for msg in conversation_history[-max_history_exchanges:]:
+                    messages.append({
+                        "role": msg["role"],
+                        "content": msg["content"]
+                    })
+            
+            # Add current user input
+            messages.append({
+                "role": "user",
+                "content": user_input
+            })
+            
+            # Add thinking context if available
+            if thinking_context:
+                messages.append({
+                    "role": "system",
+                    "content": f"Internal analysis: {thinking_context}"
+                })
+            
+            # Use quantum randomness for temperature
+            base_temperature = fallback_config.get('temperature_base', 0.7)
+            temp_range = fallback_config.get('temperature_variation_range', [0.0, 0.3])
+            quantum_temp_variation = self.emotional_agent.get_quantum_random_float(temp_range[0], temp_range[1])
+            temperature = base_temperature + quantum_temp_variation
+            
+            response = completion(
+                model=fallback_model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=fallback_config.get('max_tokens', 150)
+            )
+            
+            if response and 'choices' in response and len(response['choices']) > 0:
+                text = response['choices'][0]['message']['content']
+                logging.info("[GalateaAI] ✓ Gemini fallback response received")
+                return text.strip()
+        except Exception as e:
+            logging.error(f"[GalateaAI] Gemini fallback failed: {e}")
+        
+        return None
+    
+    def _generate_fallback_response(self, intent, keywords, emotional_state, original_input):
+        """Generate final fallback response when all systems fail"""
+        logging.info(f"[GalateaAI] Using final fallback response. Intent: {intent}, Keywords: {keywords[:5]}")
 
-            except Exception as e:
-                logging.error(f"Error using Gemini API: {e}")
-                logging.error(f"Full error details: {type(e).__name__}: {str(e)}")
-                print(f"Error using Gemini API: {e}")
-                # Fall back to basic response logic
+        # Determine which systems are not working
+        unavailable_systems = []
+        system_descriptions = {
+            'inflection_ai': ('Pi-3.1', 'my conversation model'),
+            'gemini': ('Gemini', 'my thinking model'),
+            'quantum_random': ('Quantum Random Numbers API', 'my quantum randomness source'),
+            'memory': ('Memory System', 'my memory system')
+        }
+        
+        if not getattr(self, 'inflection_ai_available', False):
+            unavailable_systems.append(system_descriptions['inflection_ai'])
+        if not getattr(self, 'gemini_available', False):
+            unavailable_systems.append(system_descriptions['gemini'])
+        if not getattr(self, 'quantum_random_available', False):
+            unavailable_systems.append(system_descriptions['quantum_random'])
+        if not getattr(self, 'memory_system_ready', False):
+            unavailable_systems.append(system_descriptions['memory'])
+        
+        # Generate natural, conversational error message
+        if unavailable_systems:
+            if len(unavailable_systems) == 1:
+                system_name, system_desc = unavailable_systems[0]
+                system_msg = f"{system_desc} ({system_name}) is not working right now"
+            elif len(unavailable_systems) == 2:
+                sys1_name, sys1_desc = unavailable_systems[0]
+                sys2_name, sys2_desc = unavailable_systems[1]
+                system_msg = f"{sys1_desc} ({sys1_name}) and {sys2_desc} ({sys2_name}) are not working"
+            else:
+                # For 3+ systems, list them naturally
+                system_list = []
+                for sys_name, sys_desc in unavailable_systems[:-1]:
+                    system_list.append(f"{sys_desc} ({sys_name})")
+                last_name, last_desc = unavailable_systems[-1]
+                system_msg = f"{', '.join(system_list)}, and {last_desc} ({last_name}) are not working"
         else:
-            logging.warning("Gemini API not available - using fallback responses")
-
-        # Original response generation logic as fallback
-        logging.info(f"Using fallback response. Intent: {intent}, Keywords: {keywords[:5]}")
-
+            system_msg = "some of my systems encountered an error"
+        
+        fallback_response = None
         if intent == "question":
             if "you" in keywords:
-                return "I am still learning about myself. My Gemini AI is not responding right now."
+                fallback_response = f"I'm still learning about myself, but I'm having technical difficulties. {system_msg.capitalize()}. I apologize for the inconvenience."
             else:
-                return "I'd love to help with that, but my AI system isn't responding at the moment."
+                fallback_response = f"I'd love to help with that, but {system_msg}. Please check my system status or try again in a moment."
         elif intent == "gratitude":
-            return "You're welcome!"
+            fallback_response = "You're welcome!"
         else:
-            return "I hear you, though my full AI capabilities aren't active right now. Please check if my API key is configured."
+            if unavailable_systems:
+                fallback_response = f"I hear you, but {system_msg}. This might be due to missing API keys or network issues. Please check my configuration."
+            else:
+                fallback_response = "I hear you, though my full AI capabilities aren't active right now. Please check if my API keys are configured."
+        
+        # Update conversation history even for fallback
+        if fallback_response:
+            self.update_conversation_history(original_input, fallback_response)
+        
+        return fallback_response
 
     def update_knowledge(self, keywords, user_input):
         #for new key words remember them

initialize_galatea.py

@@ -0,0 +1,400 @@
+#!/usr/bin/env python3
+"""
+Galatea AI Initialization Script
+Handles parallel initialization of all components
+"""
+
+import os
+import sys
+import time
+import logging
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dotenv import load_dotenv
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('initialization.log')
+    ]
+)
+
+# Check NumPy version before proceeding
+try:
+    import numpy as np
+    np_version = np.__version__
+    if np_version.startswith('2.'):
+        logging.error("=" * 70)
+        logging.error("NUM PY COMPATIBILITY ERROR")
+        logging.error("=" * 70)
+        logging.error(f"NumPy {np_version} is installed, but required libraries need NumPy < 2.0")
+        logging.error("")
+        logging.error("SOLUTION:")
+        logging.error("  Option 1: Run the fix script:")
+        logging.error("    python fix_numpy.py")
+        logging.error("")
+        logging.error("  Option 2: Manually downgrade:")
+        logging.error("    pip install 'numpy<2.0.0'")
+        logging.error("")
+        logging.error("  Option 3: Reinstall all dependencies:")
+        logging.error("    pip install -r requirements.txt")
+        logging.error("")
+        logging.error("This will downgrade NumPy to a compatible version.")
+        logging.error("=" * 70)
+        logging.warning("⚠ Continuing with initialization, but some components may fail...")
+        logging.warning("⚠ Please fix NumPy version for full functionality")
+    else:
+        logging.info(f"✓ NumPy version check passed: {np_version}")
+except ImportError:
+    logging.warning("NumPy not installed - will be installed as dependency")
+except Exception as e:
+    logging.warning(f"Could not check NumPy version: {e}")
+
+# Load environment variables
+load_dotenv()
+
+# Global status tracking
+init_status = {
+    'json_memory': {'ready': False, 'error': None},
+    'sentiment_analyzer': {'ready': False, 'error': None},
+    'gemini_api': {'ready': False, 'error': None},
+    'inflection_api': {'ready': False, 'error': None},
+    'quantum_api': {'ready': False, 'error': None},
+}
+
+# ChromaDB and embedding model removed - using JSON-only memory
+
+def initialize_sentiment_analyzer():
+    """Initialize sentiment analyzer"""
+    try:
+        logging.info("🔄 [Sentiment Analyzer] Starting initialization...")
+        print("🔄 [Sentiment Analyzer] Starting initialization...")
+        try:
+            from transformers import pipeline
+            analyzer = pipeline(
+                "sentiment-analysis",
+                model="distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+            )
+            # Test it
+            result = analyzer("test")
+            logging.info("✓ [Sentiment Analyzer] Hugging Face model loaded")
+            print("✓ [Sentiment Analyzer] Hugging Face model loaded")
+            init_status['sentiment_analyzer']['ready'] = True
+            return True
+        except ImportError:
+            logging.info("✓ [Sentiment Analyzer] Using fallback (NLTK VADER)")
+            print("✓ [Sentiment Analyzer] Using fallback (NLTK VADER)")
+            init_status['sentiment_analyzer']['ready'] = True
+            return True
+        except Exception as e:
+            error_msg = str(e)
+            # Check for NumPy compatibility issues
+            if 'np.float_' in error_msg or 'NumPy 2' in error_msg or '_ARRAY_API' in error_msg:
+                logging.warning(f"⚠ [Sentiment Analyzer] NumPy compatibility issue - using fallback")
+                print("⚠ [Sentiment Analyzer] NumPy compatibility issue - using fallback")
+                init_status['sentiment_analyzer']['ready'] = True  # Fallback available
+                return True
+            else:
+                raise
+    except Exception as e:
+        error_msg = f"Sentiment analyzer initialization failed: {e}"
+        logging.warning(f"⚠ [Sentiment Analyzer] {error_msg} - using fallback")
+        print(f"⚠ [Sentiment Analyzer] Using fallback")
+        init_status['sentiment_analyzer']['error'] = str(e)
+        # Still mark as ready since we have fallback
+        init_status['sentiment_analyzer']['ready'] = True
+        return True
+
+def validate_gemini_api():
+    """Validate Gemini API key"""
+    try:
+        logging.info("🔄 [Gemini API] Validating API key...")
+        print("🔄 [Gemini API] Validating API key...")
+        api_key = os.getenv("GEMINI_API_KEY")
+        
+        if not api_key:
+            logging.warning("⚠ [Gemini API] API key not found")
+            print("⚠ [Gemini API] API key not found")
+            init_status['gemini_api']['ready'] = False
+            return False
+        
+        # Try to use custom LLM wrapper to validate
+        try:
+            from llm_wrapper import LLMWrapper
+            # Initialize wrapper with test model
+            wrapper = LLMWrapper(gemini_model="gemini-1.5-flash")
+            response = wrapper.call_gemini(
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=5
+            )
+            if response:
+                logging.info("✓ [Gemini API] API key validated")
+                print("✓ [Gemini API] API key validated")
+                init_status['gemini_api']['ready'] = True
+                return True
+            else:
+                logging.warning("⚠ [Gemini API] Validation failed - no response")
+                print("⚠ [Gemini API] Validation failed - key exists, may be network issue")
+                return False
+        except Exception as e:
+            logging.warning(f"⚠ [Gemini API] Validation failed: {e}")
+            print("⚠ [Gemini API] Validation failed - key exists, may be network issue")
+            # Still mark as available if key exists (might be network issue)
+            init_status['gemini_api']['ready'] = True
+            return True
+    except Exception as e:
+        error_msg = f"Gemini API validation failed: {e}"
+        logging.error(f"✗ [Gemini API] {error_msg}")
+        print(f"✗ [Gemini API] {error_msg}")
+        init_status['gemini_api']['error'] = str(e)
+        return False
+
+def validate_inflection_api():
+    """Validate Inflection AI API key"""
+    try:
+        logging.info("🔄 [Inflection AI] Validating API key...")
+        print("🔄 [Inflection AI] Validating API key...")
+        api_key = os.getenv("INFLECTION_AI_API_KEY")
+        
+        if not api_key:
+            logging.warning("⚠ [Inflection AI] API key not found")
+            print("⚠ [Inflection AI] API key not found")
+            init_status['inflection_api']['ready'] = False
+            return False
+        
+        # Test API key by making a simple request
+        import requests
+        url = "https://api.inflection.ai/external/api/inference"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        data = {
+            "context": [{"text": "test", "type": "Human"}],
+            "config": "Pi-3.1"
+        }
+        
+        response = requests.post(url, headers=headers, json=data, timeout=10)
+        if response.status_code == 200:
+            logging.info("✓ [Inflection AI] API key validated")
+            print("✓ [Inflection AI] API key validated")
+            init_status['inflection_api']['ready'] = True
+            return True
+        else:
+            logging.warning(f"⚠ [Inflection AI] Validation failed: {response.status_code}")
+            print(f"⚠ [Inflection AI] Validation failed: {response.status_code}")
+            init_status['inflection_api']['ready'] = False
+            return False
+    except Exception as e:
+        error_msg = f"Inflection AI validation failed: {e}"
+        logging.warning(f"⚠ [Inflection AI] {error_msg}")
+        print(f"⚠ [Inflection AI] {error_msg}")
+        # Don't fail initialization if this fails
+        init_status['inflection_api']['ready'] = False
+        return False
+
+def validate_quantum_api():
+    """Validate Quantum Random Numbers API key"""
+    try:
+        logging.info("🔄 [Quantum API] Validating API key...")
+        print("🔄 [Quantum API] Validating API key...")
+        api_key = os.getenv("ANU_QUANTUM_API_KEY")
+        
+        if not api_key:
+            logging.warning("⚠ [Quantum API] API key not found")
+            print("⚠ [Quantum API] API key not found")
+            init_status['quantum_api']['ready'] = False
+            return False
+        
+        # Test API key
+        import requests
+        url = "https://api.quantumnumbers.anu.edu.au"
+        headers = {"x-api-key": api_key}
+        params = {"length": 1, "type": "uint8"}
+        
+        response = requests.get(url, headers=headers, params=params, timeout=10)
+        if response.status_code == 200:
+            logging.info("✓ [Quantum API] API key validated")
+            print("✓ [Quantum API] API key validated")
+            init_status['quantum_api']['ready'] = True
+            return True
+        else:
+            logging.warning(f"⚠ [Quantum API] Validation failed: {response.status_code}")
+            print(f"⚠ [Quantum API] Validation failed: {response.status_code}")
+            init_status['quantum_api']['ready'] = False
+            return False
+    except Exception as e:
+        error_msg = f"Quantum API validation failed: {e}"
+        logging.warning(f"⚠ [Quantum API] {error_msg}")
+        print(f"⚠ [Quantum API] {error_msg}")
+        init_status['quantum_api']['ready'] = False
+        return False
+
+def initialize_json_memory():
+    """Initialize JSON memory database"""
+    try:
+        logging.info("🔄 [JSON Memory] Initializing...")
+        print("🔄 [JSON Memory] Initializing...")
+        import json
+        
+        json_path = "./memory.json"
+        if os.path.exists(json_path):
+            with open(json_path, 'r', encoding='utf-8') as f:
+                memory = json.load(f)
+            logging.info(f"✓ [JSON Memory] Loaded {len(memory)} entries")
+            print(f"✓ [JSON Memory] Loaded {len(memory)} entries")
+        else:
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump({}, f)
+            logging.info("✓ [JSON Memory] Created new database")
+            print("✓ [JSON Memory] Created new database")
+        
+        init_status['json_memory']['ready'] = True
+        return True
+    except Exception as e:
+        error_msg = f"JSON memory initialization failed: {e}"
+        logging.error(f"✗ [JSON Memory] {error_msg}")
+        print(f"✗ [JSON Memory] {error_msg}")
+        init_status['json_memory']['error'] = str(e)
+        return False
+
+def run_initialization():
+    """Run all initialization steps in parallel"""
+    start_time = time.time()
+    
+    logging.info("=" * 70)
+    logging.info("GALATEA AI PARALLEL INITIALIZATION")
+    logging.info("=" * 70)
+    logging.info("Starting parallel initialization of all components...")
+    logging.info("")
+    
+    # Define initialization tasks
+    tasks = [
+        ("JSON Memory", initialize_json_memory),
+        ("Sentiment Analyzer", initialize_sentiment_analyzer),
+        ("Gemini API", validate_gemini_api),
+        ("Inflection AI", validate_inflection_api),
+        ("Quantum API", validate_quantum_api),
+    ]
+    
+    # Run tasks in parallel
+    completed_count = 0
+    total_tasks = len(tasks)
+    
+    with ThreadPoolExecutor(max_workers=5) as executor:
+        futures = {executor.submit(task[1]): task[0] for task in tasks}
+        
+        for future in as_completed(futures):
+            task_name = futures[future]
+            completed_count += 1
+            try:
+                result = future.result()
+                if result:
+                    logging.info(f"✅ [{task_name}] Completed successfully ({completed_count}/{total_tasks})")
+                    print(f"✅ [{task_name}] Completed successfully ({completed_count}/{total_tasks})")
+                else:
+                    logging.warning(f"⚠️  [{task_name}] Completed with warnings ({completed_count}/{total_tasks})")
+                    print(f"⚠️  [{task_name}] Completed with warnings ({completed_count}/{total_tasks})")
+            except Exception as e:
+                logging.error(f"❌ [{task_name}] Failed: {e} ({completed_count}/{total_tasks})")
+                print(f"❌ [{task_name}] Failed: {e} ({completed_count}/{total_tasks})")
+    
+    elapsed_time = time.time() - start_time
+    
+    # Print summary
+    logging.info("")
+    logging.info("=" * 70)
+    logging.info("INITIALIZATION SUMMARY")
+    logging.info("=" * 70)
+    print("")
+    print("=" * 70)
+    print("INITIALIZATION SUMMARY")
+    print("=" * 70)
+    
+    all_ready = True
+    critical_ready = True
+    
+    for component, status in init_status.items():
+        status_icon = "✓" if status['ready'] else "✗"
+        error_info = f" - {status['error']}" if status['error'] else ""
+        status_msg = f"{status_icon} {component.upper()}: {'READY' if status['ready'] else 'FAILED'}{error_info}"
+        logging.info(status_msg)
+        print(status_msg)
+        
+        # Critical components (must be ready)
+        if component in ['json_memory', 'sentiment_analyzer', 'gemini_api']:
+            if not status['ready']:
+                critical_ready = False
+        
+        if not status['ready']:
+            all_ready = False
+    
+    logging.info("")
+    logging.info(f"⏱️  Total initialization time: {elapsed_time:.2f} seconds")
+    logging.info("")
+    print("")
+    print(f"⏱️  Total initialization time: {elapsed_time:.2f} seconds")
+    print("")
+    
+    # Check for NumPy compatibility issues
+    numpy_issue = False
+    for component, status in init_status.items():
+        if status.get('error') and ('np.float_' in str(status['error']) or 'NumPy 2' in str(status['error']) or '_ARRAY_API' in str(status['error'])):
+            numpy_issue = True
+            break
+    
+    if numpy_issue:
+        logging.error("")
+        logging.error("=" * 70)
+        logging.error("NUM PY COMPATIBILITY ISSUE DETECTED")
+        logging.error("=" * 70)
+        logging.error("Some components failed due to NumPy 2.0 incompatibility.")
+        logging.error("")
+        logging.error("TO FIX:")
+        logging.error("  1. Run: python fix_numpy.py")
+        logging.error("  2. Or: pip install 'numpy<2.0.0'")
+        logging.error("  3. Then restart the application")
+        logging.error("=" * 70)
+        logging.error("")
+    
+    # Determine final status
+    if critical_ready:
+        if all_ready:
+            logging.info("✅ ALL COMPONENTS INITIALIZED SUCCESSFULLY")
+            logging.info("🎉 Galatea AI is ready to use!")
+            print("✅ ALL COMPONENTS INITIALIZED SUCCESSFULLY")
+            print("🎉 Galatea AI is ready to use!")
+            return True
+        else:
+            logging.info("⚠️  CRITICAL COMPONENTS READY (some optional components failed)")
+            if numpy_issue:
+                logging.warning("⚠️  Some failures due to NumPy compatibility - fix NumPy for full functionality")
+            logging.info("✅ Galatea AI is ready to use (with limited features)")
+            print("⚠️  CRITICAL COMPONENTS READY (some optional components failed)")
+            print("✅ Galatea AI is ready to use (with limited features)")
+            return True
+    else:
+        logging.error("❌ CRITICAL COMPONENTS FAILED")
+        if numpy_issue:
+            logging.error("⚠️  Failures likely due to NumPy 2.0 - run 'python fix_numpy.py' to fix")
+        logging.error("⚠️  Galatea AI may not function properly")
+        print("❌ CRITICAL COMPONENTS FAILED")
+        print("⚠️  Galatea AI may not function properly")
+        return False
+
+if __name__ == "__main__":
+    try:
+        success = run_initialization()
+        sys.exit(0 if success else 1)
+    except KeyboardInterrupt:
+        logging.info("\n⚠️  Initialization interrupted by user")
+        sys.exit(1)
+    except Exception as e:
+        logging.error(f"\n❌ Fatal error during initialization: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+

llm_wrapper.py

@@ -0,0 +1,240 @@
+"""Custom LLM Wrapper - Direct API calls using requests (no LiteLLM)"""
+import os
+import sys
+import logging
+import requests
+
+# Add current directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from config import MODEL_CONFIG
+
+class LLMWrapper:
+    """Custom LLM wrapper for Gemini and Inflection AI using direct API calls"""
+    
+    def __init__(self, gemini_model=None, inflection_model=None, config=None):
+        """
+        Initialize LLM Wrapper with models and configuration
+        
+        Args:
+            gemini_model: Gemini model name (e.g., 'gemini-2.0-flash-exp')
+            inflection_model: Inflection AI model name (e.g., 'Pi-3.1')
+            config: Configuration dict (optional, will load from MODEL_CONFIG if not provided)
+        """
+        self.config = config or MODEL_CONFIG or {}
+        self.gemini_api_key = os.getenv("GEMINI_API_KEY")
+        self.inflection_ai_api_key = os.getenv("INFLECTION_AI_API_KEY")
+        
+        # Set models from parameters or config
+        if gemini_model:
+            self.gemini_model = gemini_model
+        else:
+            gemini_config = self.config.get('gemini', {}) if self.config else {}
+            self.gemini_model = gemini_config.get('model', 'gemini-2.0-flash-exp')
+        
+        if inflection_model:
+            self.inflection_model = inflection_model
+        else:
+            inflection_config = self.config.get('inflection_ai', {}) if self.config else {}
+            self.inflection_model = inflection_config.get('model', 'Pi-3.1')
+        
+        # Remove 'gemini/' prefix if present
+        if self.gemini_model.startswith('gemini/'):
+            self.gemini_model = self.gemini_model.replace('gemini/', '')
+        
+        logging.info(f"[LLMWrapper] Initialized with Gemini model: {self.gemini_model}, Inflection model: {self.inflection_model}")
+    
+    def call_gemini(self, messages, temperature=0.7, max_tokens=1024):
+        """
+        Call Gemini API directly using requests
+        
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            temperature: Temperature for generation
+            max_tokens: Maximum tokens to generate
+            
+        Returns:
+            Response text or None if failed
+        """
+        if not self.gemini_api_key:
+            logging.error("[LLMWrapper] GEMINI_API_KEY not found")
+            return None
+        
+        # Use the model set during initialization
+        model = self.gemini_model
+        
+        # Gemini API endpoint
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+        
+        headers = {
+            "Content-Type": "application/json",
+            "X-goog-api-key": self.gemini_api_key
+        }
+        
+        # Convert messages to Gemini format
+        contents = []
+        system_instruction = None
+        
+        for msg in messages:
+            role = msg.get('role', 'user')
+            content = msg.get('content', '')
+            
+            if role == 'system':
+                system_instruction = content
+            elif role == 'user':
+                contents.append({
+                    "role": "user",
+                    "parts": [{"text": content}]
+                })
+            elif role == 'assistant':
+                contents.append({
+                    "role": "model",
+                    "parts": [{"text": content}]
+                })
+        
+        # Build request payload
+        payload = {
+            "contents": contents,
+            "generationConfig": {
+                "temperature": temperature,
+                "maxOutputTokens": max_tokens
+            }
+        }
+        
+        # Add system instruction if present
+        if system_instruction:
+            payload["systemInstruction"] = {
+                "parts": [{"text": system_instruction}]
+            }
+        
+        try:
+            logging.info(f"[LLMWrapper] Calling Gemini API: {model}")
+            response = requests.post(url, headers=headers, json=payload, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                # Extract text from Gemini response
+                if 'candidates' in result and len(result['candidates']) > 0:
+                    candidate = result['candidates'][0]
+                    if 'content' in candidate and 'parts' in candidate['content']:
+                        parts = candidate['content']['parts']
+                        if len(parts) > 0 and 'text' in parts[0]:
+                            text = parts[0]['text']
+                            logging.info("[LLMWrapper] ✓ Gemini response received")
+                            return text.strip()
+                
+                logging.error(f"[LLMWrapper] Unexpected Gemini response format: {result}")
+                return None
+            else:
+                logging.error(f"[LLMWrapper] Gemini API returned status {response.status_code}: {response.text}")
+                return None
+                
+        except Exception as e:
+            logging.error(f"[LLMWrapper] Error calling Gemini API: {e}")
+            return None
+    
+    def call_inflection_ai(self, context_parts):
+        """
+        Call Inflection AI API directly using requests
+        
+        Args:
+            context_parts: List of context dicts with 'text' and 'type'
+            
+        Returns:
+            Response text or None if failed
+        """
+        if not self.inflection_ai_api_key:
+            logging.error("[LLMWrapper] INFLECTION_AI_API_KEY not found")
+            return None
+        
+        # Use the model set during initialization
+        model_config = self.inflection_model
+        
+        # Get endpoint from config
+        inflection_config = self.config.get('inflection_ai', {}) if self.config else {}
+        url = inflection_config.get('api_endpoint', 'https://api.inflection.ai/external/api/inference')
+        
+        headers = {
+            "Authorization": f"Bearer {self.inflection_ai_api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "context": context_parts,
+            "config": model_config
+        }
+        
+        try:
+            logging.info(f"[LLMWrapper] Calling Inflection AI API: {model_config}")
+            logging.debug(f"[LLMWrapper] Request URL: {url}")
+            logging.debug(f"[LLMWrapper] Request data: {data}")
+            response = requests.post(url, headers=headers, json=data, timeout=30)
+            
+            logging.info(f"[LLMWrapper] Response status: {response.status_code}")
+            
+            if response.status_code == 200:
+                try:
+                    result = response.json()
+                except Exception as json_error:
+                    logging.error(f"[LLMWrapper] Failed to parse JSON response: {json_error}")
+                    logging.error(f"[LLMWrapper] Raw response text: {response.text[:500]}")
+                    return None
+                
+                logging.debug(f"[LLMWrapper] Response JSON: {result}")
+                logging.info(f"[LLMWrapper] Response type: {type(result)}")
+                
+                # Extract response text - Inflection AI returns text in 'text' field
+                # Based on actual API response: {"created": ..., "text": "...", "tool_calls": [], "reasoning_content": null}
+                text = None
+                if isinstance(result, dict):
+                    # Prioritize 'text' field as that's what the API actually returns
+                    if 'text' in result:
+                        text = result['text']
+                        logging.debug(f"[LLMWrapper] Found text in 'text' field: {text[:100]}...")
+                    elif 'output' in result:
+                        text = result['output']
+                        logging.debug(f"[LLMWrapper] Found text in 'output' field")
+                    elif 'response' in result:
+                        text = result['response']
+                        logging.debug(f"[LLMWrapper] Found text in 'response' field")
+                    elif 'message' in result:
+                        text = result['message']
+                        logging.debug(f"[LLMWrapper] Found text in 'message' field")
+                    else:
+                        # If result is a dict but no known field, try to get first string value
+                        logging.warning(f"[LLMWrapper] No standard text field found, searching for string values...")
+                        for key, value in result.items():
+                            if isinstance(value, str) and value.strip():
+                                text = value
+                                logging.debug(f"[LLMWrapper] Found text in '{key}' field")
+                                break
+                        if not text:
+                            logging.error(f"[LLMWrapper] No text found in response dict. Keys: {list(result.keys())}")
+                            text = str(result)
+                elif isinstance(result, str):
+                    text = result
+                    logging.debug(f"[LLMWrapper] Response is a string")
+                else:
+                    logging.warning(f"[LLMWrapper] Unexpected response type: {type(result)}")
+                    text = str(result)
+                
+                if text and isinstance(text, str) and text.strip():
+                    logging.info(f"[LLMWrapper] ✓ Inflection AI response received: {text[:100]}...")
+                    return text.strip()
+                else:
+                    logging.error(f"[LLMWrapper] No valid text found in response. Text value: {text}, Type: {type(text)}")
+                    logging.error(f"[LLMWrapper] Full response: {result}")
+                    return None
+            else:
+                logging.error(f"[LLMWrapper] Inflection AI API returned status {response.status_code}")
+                try:
+                    error_detail = response.json()
+                    logging.error(f"[LLMWrapper] Error details: {error_detail}")
+                except:
+                    logging.error(f"[LLMWrapper] Error response text: {response.text[:500]}")
+                return None
+                
+        except Exception as e:
+            logging.error(f"[LLMWrapper] Error calling Inflection AI API: {e}")
+            return None
+

models.yaml

@@ -0,0 +1,65 @@
+# Galatea AI Model Configuration
+# This file contains all model settings and hyperparameters
+
+# Gemini Agent Configuration (Thinking/Analysis)
+gemini:
+  # Single model to use for thinking/analysis
+  model: "gemini-2.0-flash-exp"
+  
+  # Hyperparameters
+  temperature: 0.5  # Lower temperature for more focused thinking
+  max_tokens: 200
+  
+  # API endpoint (automatically constructed)
+  api_endpoint: "https://generativelanguage.googleapis.com/v1beta/models"
+
+# Pi/Phi Agent Configuration (Response Generation)
+inflection_ai:
+  # Single model to use for response generation
+  model: "Pi-3.1"
+  
+  # API endpoint
+  api_endpoint: "https://api.inflection.ai/external/api/inference"
+  
+  # Hyperparameters (if supported by API)
+  # Note: Inflection AI may not support all these parameters
+  temperature: 0.8
+  max_tokens: 300
+
+# Sentiment Analysis Configuration
+sentiment:
+  # Primary model (Hugging Face)
+  primary_model: "distilbert/distilbert-base-uncased-finetuned-sst-2-english"
+  # Fallback: NLTK VADER (automatic if primary fails)
+
+# Memory System Configuration (JSON only)
+memory:
+  # JSON memory settings
+  json_path: "./memory.json"
+  
+  # Memory retrieval settings
+  retrieval:
+    max_retrieved_memories: 5
+
+# Conversation Configuration
+conversation:
+  max_history_length: 20  # Number of messages to keep (user + assistant pairs)
+  max_response_length: 50  # Target response length in words
+
+# System Prompt Configuration
+system_prompts:
+  galatea_identity: "You are Galatea, an AI assistant with emotional awareness and memory."
+  response_style: "Respond in character, keeping responses concise (under 50 words)."
+  
+# Quantum Randomness Configuration
+quantum:
+  api_endpoint: "https://api.quantumnumbers.anu.edu.au"
+  default_length: 128
+  default_type: "uint8"
+  
+  # Usage settings
+  use_for_temperature: true
+  use_for_emotion_decay: true
+  use_for_learning_rate: true
+  use_for_curiosity: true
+

requirements.txt

@@ -1,7 +1,9 @@
 flask==3.0.0
-transformers==4.36.0
+transformers>=4.50.0
 nltk==3.8.1
-google-generativeai==0.8.3
 python-dotenv==1.0.0
 azure-ai-textanalytics==5.3.0
-torch==2.1.0
+torch>=2.2.0
+numpy<2.0.0
+requests==2.31.0
+pyyaml==6.0.1

systems/__init__.py

@@ -0,0 +1,5 @@
+"""Systems package"""
+from .memory_system import MemorySystem
+
+__all__ = ['MemorySystem']
+

systems/memory_system.py

@@ -0,0 +1,111 @@
+"""Memory system using JSON for simple key-value storage"""
+import os
+import json
+import logging
+import sys
+from datetime import datetime
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import MODEL_CONFIG
+
+class MemorySystem:
+    """Memory system using JSON for simple key-value storage"""
+    
+    def __init__(self, json_db_path=None, config=None):
+        self.config = config or MODEL_CONFIG or {}
+        # Get paths from config or use defaults
+        memory_config = self.config.get('memory', {}) if self.config else {}
+        self.json_db_path = json_db_path or memory_config.get('json_path', './memory.json')
+        self.json_memory = {}
+        
+        # Initialize JSON database
+        self.load_json_memory()
+    
+    def is_ready(self):
+        """Check if memory system is fully initialized"""
+        return self.json_memory is not None
+    
+    def load_json_memory(self):
+        """Load JSON memory database"""
+        try:
+            if os.path.exists(self.json_db_path):
+                with open(self.json_db_path, 'r', encoding='utf-8') as f:
+                    self.json_memory = json.load(f)
+                logging.info(f"Loaded JSON memory with {len(self.json_memory)} entries")
+            else:
+                self.json_memory = {}
+                logging.info("Created new JSON memory database")
+        except Exception as e:
+            logging.error(f"Error loading JSON memory: {e}")
+            self.json_memory = {}
+    
+    def save_json_memory(self):
+        """Save JSON memory database"""
+        try:
+            with open(self.json_db_path, 'w', encoding='utf-8') as f:
+                json.dump(self.json_memory, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            logging.error(f"Error saving JSON memory: {e}")
+    
+    def store_memory(self, text, metadata=None, memory_type="conversation"):
+        """Store a memory in JSON"""
+        timestamp = datetime.now().isoformat()
+        
+        # Store in JSON
+        memory_id = f"{memory_type}_{timestamp}"
+        self.json_memory[memory_id] = {
+            "text": text,
+            "metadata": metadata or {},
+            "type": memory_type,
+            "timestamp": timestamp
+        }
+        self.save_json_memory()
+        logging.info(f"Stored memory in JSON: {memory_id[:20]}...")
+    
+    def retrieve_relevant_memories(self, query, n_results=5):
+        """Retrieve relevant memories using keyword search in JSON"""
+        relevant_memories = []
+        
+        # Simple keyword search in JSON
+        if self.json_memory:
+            query_lower = query.lower()
+            query_words = set(query_lower.split())
+            
+            for memory_id, memory_data in self.json_memory.items():
+                text_lower = memory_data.get("text", "").lower()
+                text_words = set(text_lower.split())
+                
+                # Simple overlap check
+                overlap = len(query_words & text_words)
+                if overlap > 0:
+                    relevant_memories.append({
+                        "text": memory_data["text"],
+                        "metadata": memory_data.get("metadata", {}),
+                        "distance": 1.0 - (overlap / max(len(query_words), len(text_words)))
+                    })
+            
+            # Sort by relevance (lower distance = more relevant)
+            relevant_memories.sort(key=lambda x: x.get("distance", 1.0))
+            relevant_memories = relevant_memories[:n_results]
+            logging.info(f"Retrieved {len(relevant_memories)} relevant memories from JSON DB")
+        
+        return relevant_memories
+    
+    def get_json_memory(self, key):
+        """Get a specific memory by key from JSON database"""
+        return self.json_memory.get(key)
+    
+    def set_json_memory(self, key, value, metadata=None):
+        """Set a key-value memory in JSON database"""
+        self.json_memory[key] = {
+            "value": value,
+            "metadata": metadata or {},
+            "timestamp": datetime.now().isoformat()
+        }
+        self.save_json_memory()
+    
+    def get_all_json_memories(self):
+        """Get all JSON memories"""
+        return self.json_memory.copy()
+