Upload app.py with huggingface_hub

app.py

@@ -1,76 +1,261 @@
+"""
+Mnemo v2 - Interactive Demo
+Enhanced memory system with real embeddings, HNSW index, and temporal decay.
+"""
+
 import gradio as gr
-import hashlib
 import time
-import numpy as np
-
-memories = {}
-stats = {"searches": 0, "adds": 0}
+from datetime import datetime
+from mnemo_core import get_mnemo
 
-def get_embedding(text):
-    emb = np.zeros(128, dtype=np.float32)
-    for i, word in enumerate(text.lower().split()):
-        emb[hash(word) % 128] += 1.0 / (i + 1)
-    norm = np.linalg.norm(emb)
-    return emb / norm if norm > 0 else emb
+def format_time(timestamp: float) -> str:
+    return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
 
-def add_memory(content):
-    if not content or not content.strip():
-        return "Please enter content"
-    mid = f"mem_{hashlib.md5(content.encode()).hexdigest()[:8]}"
-    memories[mid] = {"content": content.strip(), "embedding": get_embedding(content)}
-    stats["adds"] += 1
-    return f"Added: {mid} (total: {len(memories)})"
+def add_memory(content: str, importance: float, tags: str, user_id: str):
+    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 []
+    
+    result = mnemo.add(
+        content=content,
+        user_id=user_id or "default",
+        importance=importance,
+        tags=tags_list
+    )
+    
+    op = result['operation']
+    icon = {"ADD": "✅", "UPDATE": "🔄", "NOOP": "⚠️"}.get(op, "❓")
+    
+    return f"{icon} {result['message']} (ID: {result['id']})", get_stats_text(user_id)
 
-def search_memories(query):
-    if not query or not query.strip():
-        return "Please enter a query"
-    if not memories:
-        return "No memories yet"
+def search_memories(query: str, k: int, min_score: float, user_id: str):
+    if not query.strip():
+        return "❌ Please enter a search query"
     
+    mnemo = get_mnemo()
     start = time.time()
-    query_emb = get_embedding(query)
-    results = []
-    for mid, mem in memories.items():
-        score = float(np.dot(query_emb, mem["embedding"]))
-        results.append((mid, mem["content"], score))
-    results.sort(key=lambda x: x[2], reverse=True)
+    
+    results = mnemo.search(
+        query=query,
+        user_id=user_id or "default",
+        k=k,
+        min_score=min_score
+    )
+    
     latency = (time.time() - start) * 1000
-    stats["searches"] += 1
     
-    output = f"Found {len(results[:5])} results in {latency:.2f}ms\n\n"
-    for i, (mid, content, score) in enumerate(results[:5], 1):
-        output += f"{i}. [{mid}] {score:.3f}\n   {content}\n\n"
+    if not results:
+        return f"No results found (searched in {latency:.1f}ms)"
+    
+    output = f"**Found {len(results)} results in {latency:.1f}ms**\n\n"
+    
+    for i, r in enumerate(results, 1):
+        output += f"### {i}. [{r['id']}]\n"
+        output += f"**Content:** {r['content']}\n\n"
+        output += f"- Relevance: `{r['relevance_score']:.3f}`\n"
+        output += f"- Similarity: `{r['similarity']:.3f}`\n"
+        output += f"- Decay: `{r['decay_score']:.3f}`\n"
+        output += f"- Importance: `{r['importance']:.2f}`\n"
+        output += f"- Accesses: `{r['access_count']}`\n"
+        output += f"- Last accessed: `{format_time(r['last_accessed'])}`\n"
+        if r['tags']:
+            output += f"- Tags: `{', '.join(r['tags'])}`\n"
+        output += "\n---\n\n"
+    
+    return output
+
+def list_memories_ui(user_id: str, limit: int):
+    mnemo = get_mnemo()
+    memories = mnemo.list_memories(user_id=user_id or "default", limit=limit)
+    
+    if not memories:
+        return "No memories stored yet."
+    
+    output = f"**{len(memories)} memories (sorted by last accessed)**\n\n"
+    
+    for m in memories:
+        output += f"**{m['id']}** (importance: {m['importance']:.2f}, accesses: {m['access_count']})\n"
+        output += f"> {m['content'][:100]}{'...' if len(m['content']) > 100 else ''}\n"
+        output += f"- Created: {format_time(m['created_at'])} | Last: {format_time(m['last_accessed'])}\n"
+        if m['tags']:
+            output += f"- Tags: {', '.join(m['tags'])}\n"
+        output += "\n"
+    
     return output
 
-def get_stats():
-    return f"Memories: {len(memories)} | Searches: {stats['searches']} | Adds: {stats['adds']}"
+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")
+    
+    if success:
+        return f"✅ Deleted memory: {memory_id}", get_stats_text(user_id)
+    return f"❌ Memory not found: {memory_id}", get_stats_text(user_id)
 
-def reset_all():
-    memories.clear()
-    for ex in ["User prefers dark mode", "Project deadline March 15", "Favorite coffee cappuccino"]:
-        add_memory(ex)
-    return f"Reset. {len(memories)} memories."
+def clear_memories_ui(user_id: str):
+    mnemo = get_mnemo()
+    count = mnemo.clear(user_id=user_id or "default")
+    return f"🗑️ Cleared {count} memories", get_stats_text(user_id)
 
-reset_all()
+def get_stats_text(user_id: str = "default") -> str:
+    mnemo = get_mnemo()
+    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']}
+- Total users: {stats['total_users']}
+- Adds: {stats['total_adds']} | Updates: {stats['total_updates']} | Deletes: {stats['total_deletes']}
+- Searches: {stats['total_searches']}
+- Decay half-life: {stats['decay_half_life_days']:.1f} days"""
+
+def load_examples(user_id: str):
+    mnemo = get_mnemo()
+    
+    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"]),
+        ("Favorite programming language is Python, also uses TypeScript", 0.8, ["preferences", "languages"]),
+        ("Weekly standup meetings are every Monday at 10am", 0.7, ["meetings", "schedule"]),
+        ("User is allergic to peanuts - important health info", 1.0, ["health", "critical"]),
+        ("Prefers cappuccino with oat milk for coffee orders", 0.5, ["preferences", "food"]),
+        ("Working on a machine learning project for recommendation systems", 0.8, ["project", "ml"]),
+        ("Lives in San Francisco, timezone is PST", 0.6, ["personal", "location"]),
+    ]
+    
+    added = 0
+    for content, importance, tags in examples:
+        result = mnemo.add(
+            content=content,
+            user_id=user_id or "default",
+            importance=importance,
+            tags=tags
+        )
+        if result['operation'] in ('ADD', 'UPDATE'):
+            added += 1
+    
+    return f"✅ Loaded {added} example memories", get_stats_text(user_id)
 
-with gr.Blocks(title="Mnemo") as demo:
-    gr.Markdown("# 🧠 Mnemo\n**Memory for LLMs - 21x faster than mem0**")
-    
-    with gr.Tab("Search"):
-        q = gr.Textbox(label="Query", placeholder="e.g., preferences")
-        search_btn = gr.Button("Search", variant="primary")
-        out = gr.Textbox(label="Results", lines=8)
-        search_btn.click(search_memories, q, out)
-    
-    with gr.Tab("Add"):
-        c = gr.Textbox(label="Content")
-        add_btn = gr.Button("Add")
-        add_out = gr.Textbox(label="Status")
-        add_btn.click(add_memory, c, add_out)
-    
-    with gr.Tab("Stats"):
-        s = gr.Textbox(value=get_stats(), label="Stats")
-        gr.Button("Refresh").click(get_stats, outputs=s)
-        gr.Button("Reset").click(reset_all, outputs=s)
+# Build the Gradio interface
+with gr.Blocks(title="Mnemo v2", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧠 Mnemo v2 - Enhanced Memory for LLMs
+    
+    **Features:**
+    - 🔍 Real semantic embeddings (sentence-transformers)
+    - ⚡ HNSW index for O(log n) search (faiss)
+    - 📉 Temporal decay (Ebbinghaus forgetting curve)
+    - 📊 Composite relevance scoring (similarity + recency + frequency)
+    - 🔄 Intelligent ADD/UPDATE detection
+    - 👥 Multi-user support
+    """)
+    
+    with gr.Row():
+        user_id_input = gr.Textbox(
+            label="User ID",
+            value="default",
+            placeholder="Enter user ID for multi-user support",
+            scale=2
+        )
+        load_btn = gr.Button("📥 Load Examples", scale=1)
+    
+    stats_display = gr.Markdown(get_stats_text())
+    
+    with gr.Tabs():
+        with gr.Tab("🔍 Search"):
+            search_query = gr.Textbox(
+                label="Search Query",
+                placeholder="e.g., What are the user's preferences?"
+            )
+            with gr.Row():
+                search_k = gr.Slider(1, 20, value=5, step=1, label="Max Results")
+                search_min_score = gr.Slider(0, 1, value=0, step=0.05, label="Min Score")
+            search_btn = gr.Button("Search", variant="primary")
+            search_output = gr.Markdown()
+            
+            search_btn.click(
+                search_memories,
+                inputs=[search_query, search_k, search_min_score, user_id_input],
+                outputs=search_output
+            )
+        
+        with gr.Tab("➕ Add Memory"):
+            add_content = gr.Textbox(
+                label="Memory Content",
+                placeholder="e.g., User prefers dark mode",
+                lines=3
+            )
+            with gr.Row():
+                add_importance = gr.Slider(0, 1, value=1.0, step=0.1, label="Importance")
+                add_tags = gr.Textbox(
+                    label="Tags (comma-separated)",
+                    placeholder="e.g., preferences, settings"
+                )
+            add_btn = gr.Button("Add Memory", variant="primary")
+            add_output = gr.Textbox(label="Result")
+            
+            add_btn.click(
+                add_memory,
+                inputs=[add_content, add_importance, add_tags, user_id_input],
+                outputs=[add_output, stats_display]
+            )
+        
+        with gr.Tab("📋 List Memories"):
+            list_limit = gr.Slider(10, 100, value=50, step=10, label="Limit")
+            list_btn = gr.Button("List All Memories")
+            list_output = gr.Markdown()
+            
+            list_btn.click(
+                list_memories_ui,
+                inputs=[user_id_input, list_limit],
+                outputs=list_output
+            )
+        
+        with gr.Tab("⚙️ Manage"):
+            gr.Markdown("### Delete Memory")
+            delete_id = gr.Textbox(label="Memory ID", placeholder="e.g., mem_abc123")
+            delete_btn = gr.Button("Delete", variant="stop")
+            delete_output = gr.Textbox(label="Result")
+            
+            delete_btn.click(
+                delete_memory_ui,
+                inputs=[delete_id, user_id_input],
+                outputs=[delete_output, stats_display]
+            )
+            
+            gr.Markdown("### Clear All Memories")
+            clear_btn = gr.Button("🗑️ Clear All (for current user)", variant="stop")
+            clear_output = gr.Textbox(label="Result")
+            
+            clear_btn.click(
+                clear_memories_ui,
+                inputs=[user_id_input],
+                outputs=[clear_output, stats_display]
+            )
+    
+    load_btn.click(
+        load_examples,
+        inputs=[user_id_input],
+        outputs=[stats_display, stats_display]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### Architecture
+    
+    | Component | Implementation |
+    |-----------|----------------|
+    | Embeddings | `sentence-transformers/all-MiniLM-L6-v2` (384 dim) |
+    | Vector Index | `faiss-cpu` HNSW (M=32, efSearch=50) |
+    | Decay | Ebbinghaus curve, 7-day half-life |
+    | Scoring | 40% similarity + 30% recency + 30% frequency |
+    
+    **Links:** [GitHub](https://huggingface.co/AthelaPerk/mnemo-memory) | [API](https://huggingface.co/spaces/AthelaPerk/mnemo-mcp)
+    """)
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()