Update app.py

app.py

@@ -1,19 +1,24 @@
 import os
 from flask import Flask, render_template, request, jsonify
-from memvid_sdk import Memvid
+#from memvid_sdk import Memvid
+from memvid_sdk import create, open as open_memvid
+
 from huggingface_hub import hf_hub_download, upload_file, HfApi
 
 app = Flask(__name__)
 
+# CONFIGURATION
 FILENAME = "knowledge.mv2"
 HF_TOKEN = os.environ.get("HF_TOKEN")
-DATASET_NAME = "memvid-storage"
+DATASET_NAME = "memvid-storage" # Just the name, we will append username dynamically
 
+# Global variables
 db = None
 DB_PATH = os.path.abspath(FILENAME)
-DATASET_REPO_ID = None
+DATASET_REPO_ID = None # Will be set during initialization
 
 def get_repo_id():
+    """Helper to dynamically resolve 'username/dataset_name'"""
     global DATASET_REPO_ID
     if DATASET_REPO_ID:
         return DATASET_REPO_ID
@@ -24,24 +29,35 @@ def get_repo_id():
             username = api.whoami()['name']
             DATASET_REPO_ID = f"{username}/{DATASET_NAME}"
             return DATASET_REPO_ID
-        except Exception:
+        except Exception as e:
+            print(f"⚠️ Error getting username: {e}")
             return None
     return None
 
 def init_db():
+    """
+    1. Ensure Dataset Exists.
+    2. Try to download existing DB.
+    3. Initialize Memvid.
+    """
     global db, DATASET_REPO_ID
     
     repo_id = get_repo_id()
     
-    # 1. Cloud Sync
+    # 1. Sync / Setup Cloud Storage
     if HF_TOKEN and repo_id:
+        print(f"🔄 Checking cloud storage at {repo_id}...")
         api = HfApi(token=HF_TOKEN)
+        
         try:
+            # Create the repo if it doesn't exist (Fixes your 404 error)
             api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True)
+            
+            # Check for file existence
             files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")
             
             if FILENAME in files:
-                hf_hub_download(
+                downloaded_path = hf_hub_download(
                     repo_id=repo_id,
                     filename=FILENAME,
                     repo_type="dataset",
@@ -49,34 +65,42 @@ def init_db():
                     local_dir=".", 
                     local_dir_use_symlinks=False
                 )
+                print(f"✅ Downloaded database to {downloaded_path}")
+            else:
+                print("⚠️ Database file not found in repo. A new one will be created and synced.")
+                
         except Exception as e:
-            print(f"Cloud sync error: {e}")
+            print(f"⚠️ Cloud sync warning: {e}")
 
-    # 2. Initialize Memvid - FIX: No parameters in constructor
+    # 2. Initialize Memvid (Fixes 'no attribute create' error)
     try:
-        # Step 1: Initialize the handle without parameters
-        db = Memvid()
-        
-        # Step 2: Open or create the database file
         if os.path.exists(DB_PATH):
-            print(f"📂 File exists. Opening database at {DB_PATH}...")
-            db.open(DB_PATH)
+            db = open_memvid(DB_PATH) # Use the imported 'open' function
+        else:
+            db = create(DB_PATH)      # Use the imported 'create' function
+            
+    except ImportError:
+        # If the above imports fail, fall back to the class method style
+        # (Only do this if the library version is different than expected)
+        from memvid_sdk import Memvid
+        if os.path.exists(DB_PATH):
+             # Some bindings require an empty init first
+            db = Memvid()
+            db.open(DB_PATH) 
         else:
-            print(f"✨ New file. Creating database at {DB_PATH}...")
+            db = Memvid()
             db.create(DB_PATH)
 
-        print("✅ Database initialized.")
-
-    except Exception as e:
-        print(f"❌ Memvid init error: {e}")
-        db = None
-
 def sync_to_hub():
+    """Uploads the local .mv2 file back to Hugging Face"""
     repo_id = get_repo_id()
+    
     if not HF_TOKEN or not repo_id:
+        print("⚠️ No HF_TOKEN or Repo ID found. Skipping sync.")
         return
 
     try:
+        print("☁️ Syncing to Hub...")
         upload_file(
             path_or_fileobj=DB_PATH,
             path_in_repo=FILENAME,
@@ -85,10 +109,11 @@ def sync_to_hub():
             token=HF_TOKEN,
             commit_message="Memvid: Auto-save memory update"
         )
+        print("✅ Sync complete.")
     except Exception as e:
-        print(f"Sync failed: {e}")
+        print(f"❌ Sync failed: {e}")
 
-# Run init on start
+# Initialize on startup
 init_db()
 
 @app.route('/')
@@ -101,14 +126,14 @@ def add_memory():
     if not db:
         init_db()
         if not db:
-            return jsonify({"error": "Database could not be initialized. Check Server Logs."}), 500
+            return jsonify({"error": "Database could not be initialized."}), 500
 
     content = request.form.get('content')
+    
     if not content:
         return jsonify({"error": "No content provided"}), 400
 
     try:
-        # Payload must be a dict
         payload = {
             "text": content,
             "title": "User Memory",
@@ -117,19 +142,14 @@ def add_memory():
 
         db.put(payload)
         
-        # Force flush/close to ensure data is written before upload
         del db
         db = None
 
-        # Sync to Hugging Face
         sync_to_hub()
-        
-        # Re-open the database for the next request
         init_db()
         
         return jsonify({"success": True, "message": "Memory added and synced to cloud."})
     except Exception as e:
-        print(f"Add Error: {e}")
         return jsonify({"error": str(e)}), 500
 
 @app.route('/search', methods=['POST'])
@@ -142,16 +162,19 @@ def search_memory():
         return jsonify({"error": "No query provided"}), 400
 
     try:
-        # Query must be a string
-        results = db.find(query, top_k=5)
+        search_req = {
+            "query": query,
+            "top_k": 5,
+            "snippet_chars": 200
+        }
+
+        results = db.find(search_req)
         
         formatted_results = []
         for hit in results:
-            # Handle result object vs dict
             if isinstance(hit, dict):
                 text = hit.get('text') or hit.get('content') or "No text"
             else:
-                # Try common attribute names for the hit object
                 text = getattr(hit, 'text', getattr(hit, 'content', str(hit)))
 
             formatted_results.append({
@@ -160,7 +183,6 @@ def search_memory():
             
         return jsonify({"success": True, "results": formatted_results})
     except Exception as e:
-        print(f"Search Error: {e}")
         return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':