Upload app.py with huggingface_hub

app.py

@@ -1,21 +1,28 @@
 """
 Mnemo v2 - Interactive Demo (ZeroGPU Compatible)
 Enhanced memory system with real embeddings, HNSW index, and temporal decay.
+
+Fixed: State persistence across ZeroGPU function calls
 """
 
 import gradio as gr
 import spaces
 import time
 from datetime import datetime
-from mnemo_core import get_mnemo, compute_embedding, compute_embeddings_batch
+from typing import List
+import numpy as np
+
+# Import core components
+from mnemo_core import MnemoV2, compute_embedding, compute_embeddings_batch
+
+# Global persistent state (outside GPU functions)
+MNEMO = MnemoV2()
 
 def format_time(timestamp: float) -> str:
     return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
 
 def get_stats_text(user_id: str = "default") -> str:
-    mnemo = get_mnemo()
-    stats = mnemo.get_stats(user_id=user_id or "default")
-    
+    stats = MNEMO.get_stats(user_id=user_id or "default")
     return f"""**System Stats**
 - Total memories: {stats['total_memories']}
 - User memories: {stats['user_memory_count']}
@@ -26,18 +33,29 @@ def get_stats_text(user_id: str = "default") -> str:
 
 
 @spaces.GPU(duration=30)
+def compute_single_embedding(text: str) -> np.ndarray:
+    """GPU function: compute embedding for single text."""
+    return compute_embedding(text)
+
+
+@spaces.GPU(duration=60)
+def compute_batch_embeddings(texts: List[str]) -> np.ndarray:
+    """GPU function: compute embeddings for batch of texts."""
+    return compute_embeddings_batch(texts)
+
+
 def add_memory(content: str, importance: float, tags: str, user_id: str):
-    """Add a memory - requires GPU for embedding computation."""
+    """Add a memory - computes embedding on GPU, stores in persistent state."""
     if not content.strip():
         return "❌ Please enter content", get_stats_text(user_id)
     
-    mnemo = get_mnemo()
     tags_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else []
     
-    # Compute embedding (GPU operation)
-    embedding = compute_embedding(content)
+    # Compute embedding on GPU
+    embedding = compute_single_embedding(content)
     
-    result = mnemo.add_with_embedding(
+    # Store in persistent MNEMO instance (CPU operation)
+    result = MNEMO.add_with_embedding(
         content=content,
         embedding=embedding,
         user_id=user_id or "default",
@@ -51,19 +69,18 @@ def add_memory(content: str, importance: float, tags: str, user_id: str):
     return f"{icon} {result['message']} (ID: {result['id']})", get_stats_text(user_id)
 
 
-@spaces.GPU(duration=30)
 def search_memories(query: str, k: int, min_score: float, user_id: str):
-    """Search memories - requires GPU for embedding computation."""
+    """Search memories - computes query embedding on GPU, searches persistent state."""
     if not query.strip():
         return "❌ Please enter a search query"
     
-    mnemo = get_mnemo()
     start = time.time()
     
-    # Compute query embedding (GPU operation)
-    query_embedding = compute_embedding(query)
+    # Compute query embedding on GPU
+    query_embedding = compute_single_embedding(query)
     
-    results = mnemo.search_with_embedding(
+    # Search in persistent MNEMO instance (CPU operation)
+    results = MNEMO.search_with_embedding(
         query_embedding=query_embedding,
         user_id=user_id or "default",
         k=k,
@@ -94,9 +111,8 @@ def search_memories(query: str, k: int, min_score: float, user_id: str):
 
 
 def list_memories_ui(user_id: str, limit: int):
-    """List memories - no GPU needed."""
-    mnemo = get_mnemo()
-    memories = mnemo.list_memories(user_id=user_id or "default", limit=limit)
+    """List memories - no GPU needed, uses persistent state."""
+    memories = MNEMO.list_memories(user_id=user_id or "default", limit=limit)
     
     if not memories:
         return "No memories stored yet."
@@ -119,8 +135,7 @@ def delete_memory_ui(memory_id: str, user_id: str):
     if not memory_id.strip():
         return "❌ Please enter a memory ID", get_stats_text(user_id)
     
-    mnemo = get_mnemo()
-    success = mnemo.delete(memory_id.strip(), user_id=user_id or "default")
+    success = MNEMO.delete(memory_id.strip(), user_id=user_id or "default")
     
     if success:
         return f"✅ Deleted memory: {memory_id}", get_stats_text(user_id)
@@ -129,16 +144,12 @@ def delete_memory_ui(memory_id: str, user_id: str):
 
 def clear_memories_ui(user_id: str):
     """Clear all memories - no GPU needed."""
-    mnemo = get_mnemo()
-    count = mnemo.clear(user_id=user_id or "default")
+    count = MNEMO.clear(user_id=user_id or "default")
     return f"🗑️ Cleared {count} memories", get_stats_text(user_id)
 
 
-@spaces.GPU(duration=60)
 def load_examples(user_id: str):
-    """Load example memories - requires GPU for batch embedding computation."""
-    mnemo = get_mnemo()
-    
+    """Load example memories - batch GPU embedding then store in persistent state."""
     examples = [
         ("User prefers dark mode and VS Code for development", 1.0, ["preferences", "development"]),
         ("Project deadline is March 15th 2026 for the Q1 release", 0.9, ["project", "deadline"]),
@@ -150,13 +161,14 @@ def load_examples(user_id: str):
         ("Lives in San Francisco, timezone is PST", 0.6, ["personal", "location"]),
     ]
     
-    # Batch compute embeddings for efficiency
+    # Batch compute embeddings on GPU
     texts = [ex[0] for ex in examples]
-    embeddings = compute_embeddings_batch(texts)
+    embeddings = compute_batch_embeddings(texts)
     
+    # Store in persistent MNEMO instance (CPU operations)
     added = 0
     for i, (content, importance, tags) in enumerate(examples):
-        result = mnemo.add_with_embedding(
+        result = MNEMO.add_with_embedding(
             content=content,
             embedding=embeddings[i],
             user_id=user_id or "default",