Replace Gemini with DeepSeek Reasoner and implement quantum queue in /api/avatar endpoint

agents/__init__.py

@@ -1,6 +1,6 @@
 """Agents package"""
 from .memory_agent import MemoryAgent
-from .gemini_agent import GeminiThinkingAgent
+from .gemini_agent import DeepSeekThinkingAgent
 from .pi_agent import PiResponseAgent
 from .emotional_agent import EmotionalStateAgent
 from .azure_agent import AzureTextAnalyticsAgent
@@ -8,7 +8,7 @@ from .sentiment_agent import SentimentAgent
 
 __all__ = [
     'MemoryAgent',
-    'GeminiThinkingAgent',
+    'DeepSeekThinkingAgent',
     'PiResponseAgent',
     'EmotionalStateAgent',
     'AzureTextAnalyticsAgent',

agents/gemini_agent.py

@@ -1,4 +1,4 @@
-"""Gemini Thinking Agent - responsible for thinking and analysis using Gemini"""
+"""DeepSeek Thinking Agent - responsible for thinking and analysis using DeepSeek Reasoner"""
 import os
 import sys
 import logging
@@ -8,34 +8,34 @@ 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"""
+class DeepSeekThinkingAgent:
+    """Agent responsible for thinking and analysis using DeepSeek Reasoner"""
     
     def __init__(self, config=None):
         self.config = config or MODEL_CONFIG or {}
-        self.gemini_available = False
+        self.deepseek_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')
+        deepseek_config = self.config.get('deepseek', {}) if self.config else {}
+        deepseek_model = deepseek_config.get('model', 'deepseek-reasoner')
         
         # Initialize LLM wrapper with the model
-        self.llm_wrapper = LLMWrapper(gemini_model=gemini_model, config=self.config)
+        self.llm_wrapper = LLMWrapper(deepseek_model=deepseek_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")
+        """Initialize DeepSeek API availability"""
+        deepseek_key = os.getenv("DEEPSEEK_API_KEY")
+        if deepseek_key:
+            self.deepseek_available = True
+            logging.info("[DeepSeekThinkingAgent] ✓ Initialized and ready")
         else:
-            logging.warning("[GeminiThinkingAgent] ✗ GEMINI_API_KEY not found")
+            logging.warning("[DeepSeekThinkingAgent] ✗ DEEPSEEK_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")
+        if not self.deepseek_available:
+            logging.warning("[DeepSeekThinkingAgent] Not available")
             return None
         
         try:
@@ -78,36 +78,36 @@ Keep your analysis concise (2-3 sentences). Focus on what matters for crafting a
                 {"role": "user", "content": thinking_prompt}
             ]
             
-            logging.info("[GeminiThinkingAgent] Processing thinking request...")
+            logging.info("[DeepSeekThinkingAgent] 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)
+            deepseek_config = self.config.get('deepseek', {}) if self.config else {}
+            temperature = deepseek_config.get('temperature', 0.5)
+            max_tokens = deepseek_config.get('max_tokens', 200)
             
-            # Call Gemini model (model is set in wrapper initialization)
+            # Call DeepSeek model (model is set in wrapper initialization)
             try:
-                thinking_result = self.llm_wrapper.call_gemini(
+                thinking_result = self.llm_wrapper.call_deepseek(
                     messages=messages,
                     temperature=temperature,
                     max_tokens=max_tokens
                 )
                 
                 if thinking_result and len(thinking_result) > 0:
-                    logging.info("[GeminiThinkingAgent] ✓ Thinking completed")
+                    logging.info("[DeepSeekThinkingAgent] ✓ Thinking completed")
                     return thinking_result
                 else:
-                    logging.error("[GeminiThinkingAgent] Model returned empty result")
+                    logging.error("[DeepSeekThinkingAgent] Model returned empty result")
                     return None
             except Exception as e:
-                logging.error(f"[GeminiThinkingAgent] Model {self.llm_wrapper.gemini_model} failed: {e}")
+                logging.error(f"[DeepSeekThinkingAgent] Model {self.llm_wrapper.deepseek_model} failed: {e}")
                 return None
             
         except Exception as e:
-            logging.error(f"[GeminiThinkingAgent] Error: {e}")
+            logging.error(f"[DeepSeekThinkingAgent] Error: {e}")
             return None
     
     def is_ready(self):
         """Check if agent is ready"""
-        return self.gemini_available
+        return self.deepseek_available
 

app.py

@@ -5,8 +5,9 @@ import time
 import json
 from dotenv import load_dotenv
 import logging
-from threading import Thread
+from threading import Thread, Lock
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from collections import deque
 import nltk
 import requests
 
@@ -20,34 +21,32 @@ load_dotenv()
 logging.info("=" * 60)
 logging.info("ENVIRONMENT VARIABLES CHECK")
 logging.info("=" * 60)
-gemini_key = os.environ.get('GEMINI_API_KEY')
-missing_gemini_key = False
-if gemini_key:
-    logging.info(f"✓ GEMINI_API_KEY found (length: {len(gemini_key)} chars)")
-    logging.info(f"  First 10 chars: {gemini_key[:10]}...")
+deepseek_key = os.environ.get('DEEPSEEK_API_KEY')
+missing_deepseek_key = False
+if deepseek_key:
+    logging.info(f"✓ DEEPSEEK_API_KEY found (length: {len(deepseek_key)} chars)")
+    logging.info(f"  First 10 chars: {deepseek_key[:10]}...")
 else:
-    missing_gemini_key = True
+    missing_deepseek_key = True
     logging.error("=" * 60)
-    logging.error("✗ GEMINI_API_KEY not found in environment!")
+    logging.error("✗ DEEPSEEK_API_KEY not found in environment!")
     logging.error("=" * 60)
     logging.error("")
-    logging.error("The GEMINI_API_KEY environment variable is required for full functionality.")
+    logging.error("The DEEPSEEK_API_KEY environment variable is required for full functionality.")
     logging.error("")
     logging.error("For Hugging Face Spaces:")
     logging.error("  1. Go to Settings → Repository secrets")
     logging.error("  2. Click 'New secret'")
-    logging.error("  3. Name: GEMINI_API_KEY")
-    logging.error("  4. Value: [Your Google Gemini API key]")
-    logging.error("  5. Get a key from: https://ai.google.dev/")
+    logging.error("  3. Name: DEEPSEEK_API_KEY")
+    logging.error("  4. Value: [Your DeepSeek API key]")
+    logging.error("  5. Get a key from: https://platform.deepseek.com/")
     logging.error("")
     logging.error("For local development:")
     logging.error("  1. Copy .env.example to .env")
     logging.error("  2. Add your API key to the .env file")
     logging.error("")
-    logging.error("Available env vars starting with 'GEMINI': " +
-                 str([k for k in os.environ.keys() if 'GEMINI' in k.upper()]))
-    logging.error("Available env vars starting with 'GOOGLE': " +
-                 str([k for k in os.environ.keys() if 'GOOGLE' in k.upper()]))
+    logging.error("Available env vars starting with 'DEEPSEEK': " +
+                 str([k for k in os.environ.keys() if 'DEEPSEEK' in k.upper()]))
     logging.error("=" * 60)
 
 logging.info("=" * 60)
@@ -75,15 +74,19 @@ app = Flask(__name__, static_folder='static', template_folder='templates')
 galatea_ai = None
 dialogue_engine = None
 avatar_engine = None
-quantum_emotion_service = None
 is_initialized = False
 initializing = False
-gemini_initialized = False
+deepseek_initialized = False
 max_init_retries = 3
 current_init_retry = 0
 
+# Quantum numbers queue for /api/avatar endpoint
+quantum_numbers_queue = deque(maxlen=100)
+quantum_queue_lock = Lock()
+quantum_filling = False
+
 # Check for required environment variables
-required_env_vars = ['GEMINI_API_KEY']
+required_env_vars = ['DEEPSEEK_API_KEY']
 missing_vars = [var for var in required_env_vars if not os.environ.get(var)]
 if missing_vars:
     logging.error(f"Missing required environment variables: {', '.join(missing_vars)}")
@@ -91,43 +94,43 @@ if missing_vars:
     print(f"⚠️ Missing required environment variables: {', '.join(missing_vars)}")
     print("Please set these in your .env file or environment")
 
-def initialize_gemini():
-    """Initialize Gemini API specifically"""
-    global gemini_initialized
+def initialize_deepseek():
+    """Initialize DeepSeek API specifically"""
+    global deepseek_initialized
     
     if not galatea_ai:
-        logging.warning("Cannot initialize Gemini: GalateaAI instance not created yet")
+        logging.warning("Cannot initialize DeepSeek: GalateaAI instance not created yet")
         return False
         
-    if missing_gemini_key:
-        logging.error("Cannot initialize Gemini: GEMINI_API_KEY is missing")
+    if missing_deepseek_key:
+        logging.error("Cannot initialize DeepSeek: DEEPSEEK_API_KEY is missing")
         return False
 
     try:
-        # Check for GEMINI_API_KEY
-        if not os.environ.get('GEMINI_API_KEY'):
-            logging.error("GEMINI_API_KEY not found in environment variables")
+        # Check for DEEPSEEK_API_KEY
+        if not os.environ.get('DEEPSEEK_API_KEY'):
+            logging.error("DEEPSEEK_API_KEY not found in environment variables")
             return False
             
-        # Check if Gemini agent is ready (initialization happens automatically in GalateaAI.__init__)
-        gemini_success = hasattr(galatea_ai, 'gemini_agent') and galatea_ai.gemini_agent.is_ready()
+        # Check if DeepSeek agent is ready (initialization happens automatically in GalateaAI.__init__)
+        deepseek_success = hasattr(galatea_ai, 'deepseek_agent') and galatea_ai.deepseek_agent.is_ready()
         
-        if gemini_success:
-            gemini_initialized = True
-            logging.info("Gemini API initialized successfully")
+        if deepseek_success:
+            deepseek_initialized = True
+            logging.info("DeepSeek API initialized successfully")
             return True
         else:
-            logging.error("Failed to initialize Gemini API")
+            logging.error("Failed to initialize DeepSeek API")
             return False
     except Exception as e:
-        logging.error(f"Error initializing Gemini API: {e}")
+        logging.error(f"Error initializing DeepSeek API: {e}")
         return False
 
 # Global status tracking for parallel initialization
 init_status = {
     'json_memory': {'ready': False, 'error': None},
     'sentiment_analyzer': {'ready': False, 'error': None},
-    'gemini_api': {'ready': False, 'error': None},
+    'deepseek_api': {'ready': False, 'error': None},
     'inflection_api': {'ready': False, 'error': None},
     'quantum_api': {'ready': False, 'error': None},
 }
@@ -195,38 +198,38 @@ def initialize_sentiment_analyzer():
         init_status['sentiment_analyzer']['ready'] = True
         return True
 
-def validate_gemini_api():
-    """Validate Gemini API key"""
+def validate_deepseek_api():
+    """Validate DeepSeek API key"""
     try:
-        logging.info("🔄 [Gemini API] Validating API key...")
-        print("🔄 [Gemini API] Validating API key...")
-        api_key = os.getenv("GEMINI_API_KEY")
+        logging.info("🔄 [DeepSeek API] Validating API key...")
+        print("🔄 [DeepSeek API] Validating API key...")
+        api_key = os.getenv("DEEPSEEK_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
+            logging.warning("⚠ [DeepSeek API] API key not found")
+            print("⚠ [DeepSeek API] API key not found")
+            init_status['deepseek_api']['ready'] = False
             return False
         try:
             from llm_wrapper import LLMWrapper
             from config import MODEL_CONFIG
             
             # Get model from config
-            gemini_config = MODEL_CONFIG.get('gemini', {}) if MODEL_CONFIG else {}
-            gemini_model = gemini_config.get('model', 'gemini-2.0-flash-exp')
+            deepseek_config = MODEL_CONFIG.get('deepseek', {}) if MODEL_CONFIG else {}
+            deepseek_model = deepseek_config.get('model', 'deepseek-reasoner')
             
-            wrapper = LLMWrapper(gemini_model=gemini_model)
-            response = wrapper.call_gemini(
+            wrapper = LLMWrapper(deepseek_model=deepseek_model)
+            response = wrapper.call_deepseek(
                 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
+                logging.info("✓ [DeepSeek API] API key validated")
+                print("✓ [DeepSeek API] API key validated")
+                init_status['deepseek_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")
+                logging.warning("⚠ [DeepSeek API] Validation failed - no response")
+                print("⚠ [DeepSeek API] Validation failed - key exists, may be network issue")
                 return False
         except Exception as e:
             error_msg = str(e)
@@ -236,27 +239,27 @@ def validate_gemini_api():
             
             # Check if it's a 404 (model not found) - this is a real error
             if status_code == 404 or '404' in error_msg or 'NOT_FOUND' in error_msg:
-                logging.error(f"✗ [Gemini API] Model not found: {error_msg}")
-                print(f"✗ [Gemini API] Model not found - check models.yaml configuration")
-                init_status['gemini_api']['error'] = error_msg
+                logging.error(f"✗ [DeepSeek API] Model not found: {error_msg}")
+                print(f"✗ [DeepSeek API] Model not found - check models.yaml configuration")
+                init_status['deepseek_api']['error'] = error_msg
                 return False
             # Check if it's a 429 (rate limit/quota exceeded) - API key is valid, just quota issue
             elif status_code == 429 or '429' in error_msg or 'RESOURCE_EXHAUSTED' in error_msg or 'quota' in response_text.lower():
-                logging.info("ℹ️  [Gemini API] Rate limit/quota exceeded (API key is valid)")
-                print("ℹ️  [Gemini API] Rate limit/quota exceeded (API key is valid, will work when quota resets)")
-                init_status['gemini_api']['ready'] = True  # Key is valid, just quota issue
-                init_status['gemini_api']['error'] = "Rate limit/quota exceeded"
+                logging.info("ℹ️  [DeepSeek API] Rate limit/quota exceeded (API key is valid)")
+                print("ℹ️  [DeepSeek API] Rate limit/quota exceeded (API key is valid, will work when quota resets)")
+                init_status['deepseek_api']['ready'] = True  # Key is valid, just quota issue
+                init_status['deepseek_api']['error'] = "Rate limit/quota exceeded"
                 return True  # Don't fail initialization - key is valid
             else:
-                logging.warning(f"⚠ [Gemini API] Validation failed: {e}")
-                print("⚠ [Gemini API] Validation failed - key exists, may be network issue")
-                init_status['gemini_api']['ready'] = True
+                logging.warning(f"⚠ [DeepSeek API] Validation failed: {e}")
+                print("⚠ [DeepSeek API] Validation failed - key exists, may be network issue")
+                init_status['deepseek_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)
+        error_msg = f"DeepSeek API validation failed: {e}"
+        logging.error(f"✗ [DeepSeek API] {error_msg}")
+        print(f"✗ [DeepSeek API] {error_msg}")
+        init_status['deepseek_api']['error'] = str(e)
         return False
 
 def validate_inflection_api():
@@ -353,7 +356,7 @@ def run_parallel_initialization():
     tasks = [
         ("JSON Memory", initialize_json_memory),
         ("Sentiment Analyzer", initialize_sentiment_analyzer),
-        ("Gemini API", validate_gemini_api),
+        ("DeepSeek API", validate_deepseek_api),
         ("Inflection AI", validate_inflection_api),
         ("Quantum API", validate_quantum_api),
     ]
@@ -400,7 +403,7 @@ def run_parallel_initialization():
         logging.info(status_msg)
         print(status_msg)
         
-        if component in ['json_memory', 'sentiment_analyzer', 'gemini_api']:
+        if component in ['json_memory', 'sentiment_analyzer', 'deepseek_api']:
             if not status['ready']:
                 critical_ready = False
         
@@ -437,13 +440,13 @@ def run_parallel_initialization():
 def initialize_components():
     """Initialize Galatea components"""
     global galatea_ai, dialogue_engine, avatar_engine, is_initialized, initializing
-    global current_init_retry, gemini_initialized
+    global current_init_retry, deepseek_initialized
     
     if initializing or is_initialized:
         return
 
-    if missing_gemini_key:
-        logging.error("Initialization aborted: GEMINI_API_KEY missing")
+    if missing_deepseek_key:
+        logging.error("Initialization aborted: DEEPSEEK_API_KEY missing")
         return
         
     initializing = True
@@ -465,19 +468,6 @@ def initialize_components():
         avatar_engine = AvatarEngine()
         avatar_engine.update_avatar(galatea_ai.emotional_state)
         
-        # Start quantum emotion service (background thread)
-        global quantum_emotion_service
-        try:
-            from quantum_emotion_service import QuantumEmotionService
-            quantum_emotion_service = QuantumEmotionService(galatea_ai.emotional_agent)
-            if quantum_emotion_service.start():
-                logging.info("✓ Quantum Emotion Service started")
-            else:
-                logging.info("ℹ️  Quantum Emotion Service not started (no API key or unavailable)")
-        except Exception as e:
-            logging.warning(f"⚠ Could not start Quantum Emotion Service: {e}")
-            quantum_emotion_service = None
-        
         # Check if all components are fully initialized
         init_status = galatea_ai.get_initialization_status()
         
@@ -487,7 +477,7 @@ def initialize_components():
         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"  - DeepSeek available: {init_status['deepseek_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']}")
@@ -496,9 +486,9 @@ def initialize_components():
         # 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
+        is_initialized = True
             logging.info("✓ Galatea AI system fully initialized and ready")
-            logging.info(f"Emotions initialized: {galatea_ai.emotional_state}")
+        logging.info(f"Emotions initialized: {galatea_ai.emotional_state}")
         else:
             logging.error("=" * 60)
             logging.error("❌ INITIALIZATION FAILED - EXITING APPLICATION")
@@ -535,7 +525,7 @@ def home():
     # Add error handling for template rendering
     try:
         # Start component initialization if not already started
-        if not is_initialized and not initializing and not missing_gemini_key:
+        if not is_initialized and not initializing and not missing_deepseek_key:
             Thread(target=initialize_components, daemon=True).start()
             
         return render_template('index.html')
@@ -554,10 +544,10 @@ def chat():
         }), 503  # Service Unavailable
     
     # Check if API key is missing
-    if missing_gemini_key:
+    if missing_deepseek_key:
         return jsonify({
-            'error': 'GEMINI_API_KEY is missing. Chat is unavailable.',
-            'status': 'missing_gemini_key',
+            'error': 'DEEPSEEK_API_KEY is missing. Chat is unavailable.',
+            'status': 'missing_deepseek_key',
             'is_initialized': False
         }), 503
     
@@ -720,10 +710,102 @@ def analyze_sentiment(text):
 # Track avatar updates with timestamp
 last_avatar_update = time.time()
 
+def fill_quantum_queue():
+    """Asynchronously fill the quantum numbers queue with 100 numbers"""
+    global quantum_filling, quantum_numbers_queue
+    
+    with quantum_queue_lock:
+        if quantum_filling:
+            return  # Already filling
+        quantum_filling = True
+    
+    def _fill_queue():
+        global quantum_filling
+        try:
+            quantum_api_key = os.getenv("ANU_QUANTUM_API_KEY")
+            if not quantum_api_key:
+                logging.debug("[Quantum Queue] No API key, using pseudo-random")
+                import random
+                with quantum_queue_lock:
+                    while len(quantum_numbers_queue) < 100:
+                        quantum_numbers_queue.append(random.random())
+                return
+            
+            from config import MODEL_CONFIG
+            quantum_config = MODEL_CONFIG.get('quantum', {}) if MODEL_CONFIG else {}
+            api_endpoint = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
+            
+            headers = {"x-api-key": quantum_api_key}
+            params = {"length": 1, "type": "uint8"}
+            
+            numbers_fetched = 0
+            with quantum_queue_lock:
+                current_size = len(quantum_numbers_queue)
+            
+            while numbers_fetched < 100:
+                try:
+                    response = requests.get(api_endpoint, headers=headers, params=params, timeout=5)
+                    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
+                            with quantum_queue_lock:
+                                quantum_numbers_queue.append(normalized)
+                            numbers_fetched += 1
+                        else:
+                            # Fallback to pseudo-random
+                            import random
+                            with quantum_queue_lock:
+                                quantum_numbers_queue.append(random.random())
+                            numbers_fetched += 1
+                    elif response.status_code == 429:
+                        # Rate limited - use pseudo-random
+                        import random
+                        with quantum_queue_lock:
+                            quantum_numbers_queue.append(random.random())
+                        numbers_fetched += 1
+                    else:
+                        # Error - use pseudo-random
+                        import random
+                        with quantum_queue_lock:
+                            quantum_numbers_queue.append(random.random())
+                        numbers_fetched += 1
+                except Exception as e:
+                    logging.debug(f"[Quantum Queue] Error fetching number: {e}, using pseudo-random")
+                    import random
+                    with quantum_queue_lock:
+                        quantum_numbers_queue.append(random.random())
+                    numbers_fetched += 1
+                
+                # Small delay to avoid rate limits
+                time.sleep(0.1)
+            
+            logging.info(f"[Quantum Queue] Filled queue with {numbers_fetched} numbers")
+        except Exception as e:
+            logging.error(f"[Quantum Queue] Error filling queue: {e}")
+        finally:
+            with quantum_queue_lock:
+                quantum_filling = False
+    
+    # Start filling in background thread
+    Thread(target=_fill_queue, daemon=True).start()
+
+def pop_quantum_number():
+    """Pop a quantum number from the queue, or return pseudo-random if empty"""
+    global quantum_numbers_queue
+    
+    with quantum_queue_lock:
+        if len(quantum_numbers_queue) > 0:
+            return quantum_numbers_queue.popleft()
+        else:
+            # Queue is empty, use pseudo-random
+            import random
+            return random.random()
+
 @app.route('/api/avatar')
 def get_avatar():
     """Endpoint to get the current avatar shape and state with enhanced responsiveness"""
-    global last_avatar_update
+    global last_avatar_update, quantum_numbers_queue, quantum_filling
     
     if not is_initialized:
         return jsonify({
@@ -734,6 +816,16 @@ def get_avatar():
         })
     
     try:
+        # Check if quantum queue is empty, fill it asynchronously if needed
+        with quantum_queue_lock:
+            queue_empty = len(quantum_numbers_queue) == 0
+        
+        if queue_empty and not quantum_filling:
+            fill_quantum_queue()
+        
+        # Pop one quantum number to update emotions
+        quantum_num = pop_quantum_number()
+        
         avatar_shape = avatar_engine.avatar_model if avatar_engine else 'Circle'
         
         # Update timestamp when the avatar changes (you would track this in AvatarEngine normally)
@@ -749,6 +841,19 @@ def get_avatar():
             
         # Force avatar update based on emotions if available
         if avatar_engine and galatea_ai:
+            # Apply quantum influence to emotions
+            emotions = ["joy", "sadness", "anger", "fear", "curiosity"]
+            # Use quantum number to influence a random emotion
+            import random
+            emotion_index = int(quantum_num * len(emotions)) % len(emotions)
+            selected_emotion = emotions[emotion_index]
+            
+            # Apply subtle quantum influence (-0.05 to +0.05)
+            influence = (quantum_num - 0.5) * 0.1
+            current_value = galatea_ai.emotional_state[selected_emotion]
+            new_value = max(0.05, min(1.0, current_value + influence))
+            galatea_ai.emotional_state[selected_emotion] = new_value
+            
             # If we have sentiment data, incorporate it into emotional state
             if sentiment_data:
                 # Update emotional state based on sentiment (enhanced mapping)
@@ -760,6 +865,10 @@ def get_avatar():
                     # Amplify anger emotion when detected
                     galatea_ai.emotional_state["anger"] = max(galatea_ai.emotional_state["anger"], 0.8)
             
+            # Save emotional state to JSON
+            if hasattr(galatea_ai, 'emotional_agent'):
+                galatea_ai.emotional_agent._save_to_json()
+            
             avatar_engine.update_avatar(galatea_ai.emotional_state)
             avatar_shape = avatar_engine.avatar_model
             last_avatar_update = current_timestamp
@@ -785,21 +894,21 @@ def health():
     """Simple health check endpoint to verify the server is running"""
     return jsonify({
         'status': 'ok',
-        'gemini_available': hasattr(galatea_ai, 'gemini_available') and galatea_ai.gemini_available if galatea_ai else False,
+        'deepseek_available': hasattr(galatea_ai, 'deepseek_available') and galatea_ai.deepseek_available if galatea_ai else False,
         'is_initialized': is_initialized,
-        'missing_gemini_key': missing_gemini_key
+        'missing_deepseek_key': missing_deepseek_key
     })
 
 @app.route('/api/availability')
 def availability():
     """Report overall availability state to the frontend"""
-    if missing_gemini_key:
+    if missing_deepseek_key:
         return jsonify({
             'available': False,
-            'status': 'missing_gemini_key',
+            'status': 'missing_deepseek_key',
             'is_initialized': False,
             'initializing': False,
-            'missing_gemini_key': True,
+            'missing_deepseek_key': True,
             'error_page': url_for('error_page')
         })
 
@@ -809,7 +918,7 @@ def availability():
             'status': 'initializing',
             'is_initialized': is_initialized,
             'initializing': initializing,
-            'missing_gemini_key': False
+            'missing_deepseek_key': False
         })
 
     return jsonify({
@@ -817,18 +926,18 @@ def availability():
         'status': 'ready',
         'is_initialized': True,
         'initializing': False,
-        'missing_gemini_key': False
+        'missing_deepseek_key': False
     })
 
 @app.route('/api/is_initialized')
 def is_initialized_endpoint():
     """Lightweight endpoint for polling initialization progress"""
     # Determine current initialization state
-    if missing_gemini_key:
+    if missing_deepseek_key:
         return jsonify({
             'is_initialized': False,
             'initializing': False,
-            'missing_gemini_key': True,
+            'missing_deepseek_key': True,
             'error_page': url_for('error_page'),
             'status': 'missing_api_key'
         })
@@ -838,7 +947,7 @@ def is_initialized_endpoint():
         return jsonify({
             'is_initialized': False,
             'initializing': True,
-            'missing_gemini_key': False,
+            'missing_deepseek_key': False,
             'status': 'initializing_components',
             'message': 'Initializing AI components...'
         })
@@ -848,7 +957,7 @@ def is_initialized_endpoint():
         return jsonify({
             'is_initialized': True,
             'initializing': False,
-            'missing_gemini_key': False,
+            'missing_deepseek_key': False,
             'status': 'ready',
             'message': 'System ready'
         })
@@ -857,7 +966,7 @@ def is_initialized_endpoint():
     return jsonify({
         'is_initialized': False,
         'initializing': True,
-        'missing_gemini_key': False,
+        'missing_deepseek_key': False,
         'status': 'waiting',
         'message': 'Waiting for initialization...'
     })
@@ -870,13 +979,13 @@ def status():
         'initializing': initializing,
         'emotions': galatea_ai.emotional_state if galatea_ai else {'joy': 0.2, 'sadness': 0.2, 'anger': 0.2, 'fear': 0.2, 'curiosity': 0.2},
         'avatar_shape': avatar_engine.avatar_model if avatar_engine and is_initialized else 'Circle',
-        'missing_gemini_key': missing_gemini_key
+        'missing_deepseek_key': missing_deepseek_key
     })
 
 @app.route('/error')
 def error_page():
     """Render an informative error page when the app is unavailable"""
-    return render_template('error.html', missing_gemini_key=missing_gemini_key)
+    return render_template('error.html', missing_deepseek_key=missing_deepseek_key)
 
 if __name__ == '__main__':
     print("Starting Galatea Web Interface...")
@@ -921,7 +1030,7 @@ if __name__ == '__main__':
         print("Application will exit")
         print("=" * 70)
         sys.exit(1)
-    
+
     # Add debug logs for avatar shape changes
     logging.info("Avatar system initialized with default shape.")
 
@@ -932,6 +1041,6 @@ if __name__ == '__main__':
     logging.info("Frontend will poll /api/is_initialized for status")
     print(f"\nFlask server starting on port {port}...")
     print("Frontend will poll /api/is_initialized for status\n")
-    
+
     # Bind to 0.0.0.0 for external access (required for Hugging Face Spaces)
     app.run(host='0.0.0.0', port=port, debug=True)

galatea_ai.py

@@ -9,7 +9,7 @@ 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,
+    MemoryAgent, DeepSeekThinkingAgent, PiResponseAgent,
     EmotionalStateAgent, SentimentAgent
 )
 
@@ -51,7 +51,7 @@ class GalateaAI:
         # Initialize agents
         logging.info("Initializing agents...")
         self.memory_agent = MemoryAgent(self.memory_system, config=self.config)
-        self.gemini_agent = GeminiThinkingAgent(config=self.config)
+        self.deepseek_agent = DeepSeekThinkingAgent(config=self.config)
         self.pi_agent = PiResponseAgent(config=self.config)
         self.emotional_agent = EmotionalStateAgent(config=self.config)
         self.sentiment_agent = SentimentAgent(config=self.config)
@@ -59,8 +59,8 @@ class GalateaAI:
         # 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()
+        self.models_ready = self.deepseek_agent.is_ready() or self.pi_agent.is_ready()
+        self.api_keys_valid = self.deepseek_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:
@@ -68,16 +68,16 @@ class GalateaAI:
         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")
+            raise RuntimeError("No AI models available (DeepSeek 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")
+        if not self.deepseek_agent.is_ready():
+            raise RuntimeError("DeepSeek model is not available - application cannot continue")
         
         # Legacy compatibility
-        self.gemini_available = self.gemini_agent.is_ready()
+        self.deepseek_available = self.deepseek_agent.is_ready()
         self.inflection_ai_available = self.pi_agent.is_ready()
         self.quantum_random_available = self.emotional_agent.quantum_random_available
         
@@ -108,7 +108,7 @@ class GalateaAI:
             "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,
+            "deepseek_available": self.deepseek_agent.is_ready() if hasattr(self, 'deepseek_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()
@@ -189,16 +189,16 @@ class GalateaAI:
         # 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(
+        # Step 5: Chain workflow: PHI(DEEPSEEK(User inputs, read with past memory), emotionalstate)
+        # Step 5a: DEEPSEEK(User inputs, read with past memory)
+        thinking_context = self.deepseek_agent.think(
             user_input,
             current_emotional_state,
             self.conversation_history,
             retrieved_memories=retrieved_memories
         )
         
-        # Step 5b: PHI(GEMINI result, emotionalstate)
+        # Step 5b: PHI(DEEPSEEK result, emotionalstate)
         response = self.pi_agent.respond(
             user_input,
             current_emotional_state,

llm_wrapper.py

@@ -1,4 +1,4 @@
-"""Custom LLM Wrapper - Direct API calls using requests (no LiteLLM)"""
+"""Custom LLM Wrapper - Direct API calls using requests and OpenAI SDK"""
 import os
 import sys
 import logging
@@ -8,28 +8,35 @@ import requests  # type: ignore[import-untyped]
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from config import MODEL_CONFIG
 
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    logging.warning("[LLMWrapper] OpenAI SDK not available. DeepSeek API calls will fail.")
+
 class LLMWrapper:
-    """Custom LLM wrapper for Gemini and Inflection AI using direct API calls"""
+    """Custom LLM wrapper for DeepSeek and Inflection AI using direct API calls"""
     
-    def __init__(self, gemini_model=None, inflection_model=None, config=None):
+    def __init__(self, deepseek_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')
+            deepseek_model: DeepSeek model name (e.g., 'deepseek-reasoner')
             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.deepseek_api_key = os.getenv("DEEPSEEK_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
+        if deepseek_model:
+            self.deepseek_model = deepseek_model
         else:
-            gemini_config = self.config.get('gemini', {}) if self.config else {}
-            self.gemini_model = gemini_config.get('model', 'gemini-2.0-flash-exp')
+            deepseek_config = self.config.get('deepseek', {}) if self.config else {}
+            self.deepseek_model = deepseek_config.get('model', 'deepseek-reasoner')
         
         if inflection_model:
             self.inflection_model = inflection_model
@@ -37,15 +44,20 @@ class LLMWrapper:
             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/', '')
+        # Initialize OpenAI client for DeepSeek
+        if OPENAI_AVAILABLE and self.deepseek_api_key:
+            self.deepseek_client = OpenAI(
+                api_key=self.deepseek_api_key,
+                base_url="https://api.deepseek.com"
+            )
+        else:
+            self.deepseek_client = None
         
-        logging.info(f"[LLMWrapper] Initialized with Gemini model: {self.gemini_model}, Inflection model: {self.inflection_model}")
+        logging.info(f"[LLMWrapper] Initialized with DeepSeek model: {self.deepseek_model}, Inflection model: {self.inflection_model}")
     
-    def call_gemini(self, messages, temperature=0.7, max_tokens=1024):
+    def call_deepseek(self, messages, temperature=0.7, max_tokens=1024):
         """
-        Call Gemini API directly using requests
+        Call DeepSeek API using OpenAI SDK
         
         Args:
             messages: List of message dicts with 'role' and 'content'
@@ -55,97 +67,53 @@ class LLMWrapper:
         Returns:
             Response text or None if failed
         """
-        if not self.gemini_api_key:
-            logging.error("[LLMWrapper] GEMINI_API_KEY not found")
+        if not self.deepseek_api_key:
+            logging.error("[LLMWrapper] DEEPSEEK_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}]
-                })
+        if not OPENAI_AVAILABLE:
+            logging.error("[LLMWrapper] OpenAI SDK not available. Install with: pip install openai")
+            return None
         
-        # Build request payload
-        payload = {
-            "contents": contents,
-            "generationConfig": {
-                "temperature": temperature,
-                "maxOutputTokens": max_tokens
-            }
-        }
+        if not self.deepseek_client:
+            logging.error("[LLMWrapper] DeepSeek client not initialized")
+            return None
         
-        # Add system instruction if present
-        if system_instruction:
-            payload["systemInstruction"] = {
-                "parts": [{"text": system_instruction}]
-            }
+        # Use the model set during initialization
+        model = self.deepseek_model
         
         try:
-            logging.info(f"[LLMWrapper] Calling Gemini API: {model}")
-            response = requests.post(url, headers=headers, json=payload, timeout=30)
+            logging.info(f"[LLMWrapper] Calling DeepSeek API: {model}")
+            response = self.deepseek_client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=False
+            )
             
-            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:
-                # Raise exception with status code and response text so validation can catch it
-                error_text = response.text
-                logging.error(f"[LLMWrapper] Gemini API returned status {response.status_code}: {error_text}")
-                # Create exception with status code info for validation to catch
-                api_error = Exception(f"Gemini API status {response.status_code}: {error_text}")
-                api_error.status_code = response.status_code
-                api_error.response_text = error_text
-                raise api_error
-                
-        except requests.RequestException as e:
-            # Network/request errors - log and return None
-            logging.error(f"[LLMWrapper] Network error calling Gemini API: {e}")
+            if response and response.choices and len(response.choices) > 0:
+                text = response.choices[0].message.content
+                if text:
+                    logging.info("[LLMWrapper] ✓ DeepSeek response received")
+                    return text.strip()
+            
+            logging.error(f"[LLMWrapper] Unexpected DeepSeek response format: {response}")
             return None
+                
         except Exception as e:
-            # Re-raise status code errors so validation can catch them
-            if hasattr(e, 'status_code'):
-                raise
-            # Other errors - log and return None
-            logging.error(f"[LLMWrapper] Error calling Gemini API: {e}")
-            return None
+            # Check if it's an API error with status code
+            error_msg = str(e)
+            status_code = getattr(e, 'status_code', None)
+            response_text = getattr(e, 'response_text', error_msg)
+            
+            # Create exception with status code info for validation to catch
+            api_error = Exception(f"DeepSeek API error: {error_msg}")
+            if status_code:
+                api_error.status_code = status_code
+            api_error.response_text = response_text
+            logging.error(f"[LLMWrapper] Error calling DeepSeek API: {e}")
+            raise api_error
     
     def call_inflection_ai(self, context_parts):
         """

models.yaml

@@ -1,17 +1,17 @@
 # Galatea AI Model Configuration
 # This file contains all model settings and hyperparameters
 
-# Gemini Agent Configuration (Thinking/Analysis)
-gemini:
+# DeepSeek Agent Configuration (Thinking/Analysis)
+deepseek:
   # Single model to use for thinking/analysis
-  model: "gemini-2.0-flash-exp"
+  model: "deepseek-reasoner"
   
   # 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"
+  # API endpoint (using OpenAI SDK)
+  api_endpoint: "https://api.deepseek.com"
 
 # Pi/Phi Agent Configuration (Response Generation)
 inflection_ai:

requirements.txt

@@ -7,3 +7,4 @@ torch>=2.2.0
 numpy<2.0.0
 requests==2.31.0
 pyyaml==6.0.1
+openai>=1.0.0