Update app.py

app.py

@@ -19,7 +19,7 @@ MAX_MEMORY_MESSAGES = 90  # Maximum messages to keep in memory per user
 MEMORY_CLEANUP_TIMEOUT = 1800  # 30 minutes in seconds - remove inactive users
 
 client = genai.Client(api_key=GEMINI_KEY)
-user_memory = {}  # { user_id: { "history": [], "last_sync": timestamp, "last_activity": timestamp } }
+user_memory = {}  # { user_id: { "history": [], "last_sync": timestamp, "last_activity": timestamp, "needs_sync": bool } }
 
 # --- HTML Frontend ---
 HTML = """
@@ -81,6 +81,7 @@ def generate_from_gemini(prompt, image_bytes=None, history=None):
     # Add historical messages (limit to recent turns to avoid token limits)
     if history:
         recent_history = history[-MAX_HISTORY_TURNS:]
+        print(f"📚 Using {len(recent_history)} history entries for context")
         for entry in recent_history:
             # Add user message
             user_parts = [types.Part.from_text(text=entry["prompt"])]
@@ -89,6 +90,8 @@ def generate_from_gemini(prompt, image_bytes=None, history=None):
             # Add model response
             model_parts = [types.Part.from_text(text=entry["response"])]
             contents.append(types.Content(role="model", parts=model_parts))
+    else:
+        print("📚 No history available for context")
     
     # Add current user message
     current_parts = []
@@ -136,41 +139,62 @@ def cleanup_inactive_users():
 
 # --- History Management ---
 def get_user_history(uid):
+    """Fetch user history from memory or backend"""
     if uid not in user_memory:
+        print(f"🔍 User {uid} not in memory, fetching from backend...")
         try:
-            resp = requests.get(f"{LAMBDA_URL}?userid={uid}", timeout=5)
+            fetch_url = f"{LAMBDA_URL}?userid={uid}"
+            print(f"📡 Fetching from: {fetch_url}")
+            resp = requests.get(fetch_url, timeout=5)
+            print(f"📡 Response status: {resp.status_code}")
             resp.raise_for_status()
-            loaded_history = resp.json().get("history", [])
+            
+            response_data = resp.json()
+            print(f"📡 Response data: {response_data}")
+            
+            loaded_history = response_data.get("history", [])
+            print(f"✅ Loaded {len(loaded_history)} messages from backend for {uid}")
+            
             # Only keep the most recent MAX_MEMORY_MESSAGES when loading
             user_memory[uid] = {
                 "history": loaded_history[-MAX_MEMORY_MESSAGES:], 
                 "last_sync": time.time(),
-                "last_activity": time.time()
+                "last_activity": time.time(),
+                "needs_sync": False
             }
             app.logger.info(f"Loaded history for {uid} ({len(user_memory[uid]['history'])} messages)")
         except Exception as e:
             app.logger.warning(f"Failed to load history for {uid}: {e}")
+            print(f"❌ Failed to load history for {uid}: {e}")
             user_memory[uid] = {
                 "history": [], 
                 "last_sync": time.time(),
-                "last_activity": time.time()
+                "last_activity": time.time(),
+                "needs_sync": False
             }
+    else:
+        print(f"✅ User {uid} already in memory with {len(user_memory[uid]['history'])} messages")
     
     # Update last activity timestamp
     user_memory[uid]["last_activity"] = time.time()
     return user_memory[uid]["history"]
 
 def update_user_history(uid, prompt, response):
+    """Add new message to user history"""
     entry = {"prompt": prompt, "response": response, "timestamp": time.time()}
     if uid not in user_memory:
         user_memory[uid] = {
             "history": [], 
             "last_sync": time.time(),
-            "last_activity": time.time()
+            "last_activity": time.time(),
+            "needs_sync": False
         }
     
     user_memory[uid]["history"].append(entry)
     user_memory[uid]["last_activity"] = time.time()
+    user_memory[uid]["needs_sync"] = True  # Mark as needing sync
+    
+    print(f"💾 Updated history for {uid}, now has {len(user_memory[uid]['history'])} messages")
     
     # Trim history to MAX_MEMORY_MESSAGES to prevent unbounded growth
     # This keeps the oldest messages in memory up to the limit
@@ -191,13 +215,28 @@ def remote_saving():
     now = time.time()
     synced_users = []
     failed_users = []
+    skipped_users = []
     
     # First, cleanup inactive users
     cleanup_inactive_users()
     
-    # Then sync active users
+    # Then sync only users that need syncing (have new messages)
     for uid, data in list(user_memory.items()):
-        if now - data.get("last_sync", 0) >= FLUSH_INTERVAL and data["history"]:
+        # Check if user needs sync and enough time has passed
+        needs_sync = data.get("needs_sync", False)
+        time_since_last_sync = now - data.get("last_sync", 0)
+        
+        if not needs_sync:
+            skipped_users.append(uid)
+            print(f"⏭️ Skipping {uid} - no new messages")
+            continue
+            
+        if time_since_last_sync < FLUSH_INTERVAL:
+            skipped_users.append(uid)
+            print(f"⏭️ Skipping {uid} - synced {int(time_since_last_sync)}s ago (< {FLUSH_INTERVAL}s)")
+            continue
+        
+        if data["history"]:
             try:
                 # Sync all messages (up to MAX_MEMORY_MESSAGES)
                 history_to_sync = data["history"][-MAX_MEMORY_MESSAGES:]
@@ -206,6 +245,7 @@ def remote_saving():
                 resp = requests.post(LAMBDA_URL, json=payload, timeout=5)
                 resp.raise_for_status()
                 user_memory[uid]["last_sync"] = now
+                user_memory[uid]["needs_sync"] = False  # Mark as synced
                 app.logger.info(f"Synced memory for {uid} ({len(history_to_sync)} messages)")
                 print(f"✅ Successfully synced memory for {uid} ({len(history_to_sync)} messages)")
                 synced_users.append(uid)
@@ -218,8 +258,10 @@ def remote_saving():
         "success": True,
         "synced_count": len(synced_users),
         "failed_count": len(failed_users),
+        "skipped_count": len(skipped_users),
         "synced_users": synced_users,
         "failed_users": failed_users,
+        "skipped_users": skipped_users,
         "active_users_in_memory": len(user_memory)
     }), 200
 
@@ -237,18 +279,24 @@ def gen():
         return jsonify({"error": "No prompt or image provided"}), 400
 
     try:
+        print(f"\n{'='*50}")
+        print(f"🆕 New generation request from user: {uid}")
+        
         # Load user's conversation history
         history = get_user_history(uid)
+        print(f"📖 Retrieved {len(history)} messages from history")
         
         # Generate response with history context
         result = generate_from_gemini(prompt, img_bytes, history=history)
         
         # Update history with new exchange
         update_user_history(uid, prompt, result["text"])
+        print(f"{'='*50}\n")
         
         return jsonify({"result": result["text"], "timing": result["timing"]})
     except Exception as e:
         app.logger.exception("Generation failed")
+        print(f"❌ Generation failed: {e}")
         return jsonify({"error": str(e)}), 500