Update app.py

app.py

@@ -3,7 +3,6 @@
 
 import os
 import time
-import threading
 import requests
 from flask import Flask, request, render_template_string, jsonify
 from google import genai
@@ -16,32 +15,11 @@ LAMBDA_URL = os.getenv("LAMBDA_URL", "https://your-lambda-function-url")
 GEMINI_KEY = os.getenv("GEMINI_API_KEY", "")
 FLUSH_INTERVAL = 30  # seconds between DB backups per user
 MAX_HISTORY_TURNS = 10  # Maximum conversation turns to keep in context
+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 } }
-
-# --- Background thread for periodic flush ---
-def flush_loop():
-    while True:
-        time.sleep(5)
-        now = time.time()
-        for uid, data in list(user_memory.items()):
-            if now - data.get("last_sync", 0) >= FLUSH_INTERVAL and data["history"]:
-                try:
-                    # Only sync the most recent MAX_HISTORY_TURNS entries
-                    history_to_sync = data["history"][-MAX_HISTORY_TURNS:]
-                    payload = {"user_id": uid, "history": history_to_sync}
-                    print(f"🔄 Attempting to sync {uid} to {LAMBDA_URL}")
-                    resp = requests.post(LAMBDA_URL, json=payload, timeout=5)
-                    resp.raise_for_status()
-                    user_memory[uid]["last_sync"] = now
-                    app.logger.info(f"Synced memory for {uid} ({len(history_to_sync)} turns)")
-                    print(f"✅ Successfully synced memory for {uid} ({len(history_to_sync)} turns)")
-                except Exception as e:
-                    app.logger.warning(f"Failed sync for {uid}: {e}")
-                    print(f"❌ Failed sync for {uid}: {e}")
-
-threading.Thread(target=flush_loop, daemon=True).start()
+user_memory = {}  # { user_id: { "history": [], "last_sync": timestamp, "last_activity": timestamp } }
 
 # --- HTML Frontend ---
 HTML = """
@@ -139,35 +117,67 @@ def generate_from_gemini(prompt, image_bytes=None, history=None):
         }
     }
 
+# --- Memory Cleanup ---
+def cleanup_inactive_users():
+    """Remove users who haven't had activity in MEMORY_CLEANUP_TIMEOUT seconds"""
+    now = time.time()
+    removed_count = 0
+    for uid in list(user_memory.keys()):
+        last_activity = user_memory[uid].get("last_activity", 0)
+        if now - last_activity >= MEMORY_CLEANUP_TIMEOUT:
+            del user_memory[uid]
+            removed_count += 1
+            app.logger.info(f"Cleaned up inactive user {uid}")
+            print(f"🧹 Cleaned up inactive user {uid}")
+    
+    if removed_count > 0:
+        print(f"🧹 Cleaned up {removed_count} inactive user(s)")
+    return removed_count
+
 # --- History Management ---
 def get_user_history(uid):
     if uid not in user_memory:
         try:
-            resp = requests.get(f"{LAMBDA_URL}?userid={uid}", timeout=5)
+            resp = requests.get(f"{LAMBDA_URL}?user_id={uid}", timeout=5)
             resp.raise_for_status()
             loaded_history = resp.json().get("history", [])
-            # Only keep the most recent MAX_HISTORY_TURNS when loading
+            # Only keep the most recent MAX_MEMORY_MESSAGES when loading
             user_memory[uid] = {
-                "history": loaded_history[-MAX_HISTORY_TURNS:], 
-                "last_sync": time.time()
+                "history": loaded_history[-MAX_MEMORY_MESSAGES:], 
+                "last_sync": time.time(),
+                "last_activity": time.time()
             }
-            app.logger.info(f"Loaded history for {uid} ({len(user_memory[uid]['history'])} turns)")
+            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}")
-            user_memory[uid] = {"history": [], "last_sync": time.time()}
+            user_memory[uid] = {
+                "history": [], 
+                "last_sync": time.time(),
+                "last_activity": time.time()
+            }
+    
+    # Update last activity timestamp
+    user_memory[uid]["last_activity"] = time.time()
     return user_memory[uid]["history"]
 
 def update_user_history(uid, prompt, response):
     entry = {"prompt": prompt, "response": response, "timestamp": time.time()}
     if uid not in user_memory:
-        user_memory[uid] = {"history": [], "last_sync": time.time()}
+        user_memory[uid] = {
+            "history": [], 
+            "last_sync": time.time(),
+            "last_activity": time.time()
+        }
     
     user_memory[uid]["history"].append(entry)
+    user_memory[uid]["last_activity"] = time.time()
     
-    # Trim history to MAX_HISTORY_TURNS to prevent unbounded growth
-    if len(user_memory[uid]["history"]) > MAX_HISTORY_TURNS:
-        user_memory[uid]["history"] = user_memory[uid]["history"][-MAX_HISTORY_TURNS:]
-        app.logger.debug(f"Trimmed history for {uid} to {MAX_HISTORY_TURNS} turns")
+    # Trim history to MAX_MEMORY_MESSAGES to prevent unbounded growth
+    # This keeps the oldest messages in memory up to the limit
+    if len(user_memory[uid]["history"]) > MAX_MEMORY_MESSAGES:
+        user_memory[uid]["history"] = user_memory[uid]["history"][-MAX_MEMORY_MESSAGES:]
+        app.logger.debug(f"Trimmed history for {uid} to {MAX_MEMORY_MESSAGES} messages")
+        print(f"✂️ Trimmed history for {uid} to {MAX_MEMORY_MESSAGES} messages")
 
 # --- Routes ---
 @app.route("/")
@@ -175,26 +185,43 @@ def index():
     return render_template_string(HTML)
 
 
-@app.route("/remote")
+@app.route("/cron/sync", methods=["GET", "POST"])
 def remote_saving():
+    """Cron job endpoint for syncing user memory to backend"""
     now = time.time()
+    synced_users = []
+    failed_users = []
+    
+    # First, cleanup inactive users
+    cleanup_inactive_users()
+    
+    # Then sync active users
     for uid, data in list(user_memory.items()):
-            if now - data.get("last_sync", 0) >= FLUSH_INTERVAL and data["history"]:
-                try:
-                    # Only sync the most recent MAX_HISTORY_TURNS entries
-                    history_to_sync = data["history"][-MAX_HISTORY_TURNS:]
-                    payload = {"user_id": uid, "history": history_to_sync}
-                    print(f"🔄 Attempting to sync {uid} to {LAMBDA_URL}")
-                    resp = requests.post(LAMBDA_URL, json=payload, timeout=5)
-                    resp.raise_for_status()
-                    user_memory[uid]["last_sync"] = now
-                    app.logger.info(f"Synced memory for {uid} ({len(history_to_sync)} turns)")
-                    print(f"✅ Successfully synced memory for {uid} ({len(history_to_sync)} turns)")
-                    return jsonify({"done": True}), 200
-                except Exception as e:
-                    app.logger.warning(f"Failed sync for {uid}: {e}")
-                    print(f"❌ Failed sync for {uid}: {e}")
-                    return jsonify({"error": str(e)}), 500
+        if now - data.get("last_sync", 0) >= FLUSH_INTERVAL and data["history"]:
+            try:
+                # Sync all messages (up to MAX_MEMORY_MESSAGES)
+                history_to_sync = data["history"][-MAX_MEMORY_MESSAGES:]
+                payload = {"user_id": uid, "history": history_to_sync}
+                print(f"🔄 Attempting to sync {uid} to {LAMBDA_URL}")
+                resp = requests.post(LAMBDA_URL, json=payload, timeout=5)
+                resp.raise_for_status()
+                user_memory[uid]["last_sync"] = now
+                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)
+            except Exception as e:
+                app.logger.warning(f"Failed sync for {uid}: {e}")
+                print(f"❌ Failed sync for {uid}: {e}")
+                failed_users.append({"user_id": uid, "error": str(e)})
+    
+    return jsonify({
+        "success": True,
+        "synced_count": len(synced_users),
+        "failed_count": len(failed_users),
+        "synced_users": synced_users,
+        "failed_users": failed_users,
+        "active_users_in_memory": len(user_memory)
+    }), 200
 
 
 @app.route("/generate", methods=["POST"])