Upload app.py with huggingface_hub

app.py

@@ -1,6 +1,6 @@
 """
-Mnemo v2 - Interactive Demo (CPU Optimized)
-Enhanced memory system with real embeddings, HNSW index, and temporal decay.
+Mnemo v2 - Interactive Demo with Metadata Filtering
+Enhanced memory system with filtering by tags, importance, and dates.
 """
 
 import gradio as gr
@@ -9,8 +9,7 @@ from datetime import datetime
 from typing import List
 import numpy as np
 
-# Import core components
-from mnemo_core import MnemoV2, compute_embedding, compute_embeddings_batch
+from mnemo_core import MnemoV2, MemoryFilter, compute_embedding, compute_embeddings_batch
 
 # Global persistent state
 MNEMO = MnemoV2()
@@ -20,18 +19,23 @@ def format_time(timestamp: float) -> str:
 
 def get_stats_text(user_id: str = "default") -> str:
     stats = MNEMO.get_stats(user_id=user_id or "default")
+    tags_str = ", ".join(stats['tags'][:10]) if stats['tags'] else "none"
     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"""
+- Unique tags: {stats['unique_tags']}
+- Tags: {tags_str}
+- Searches: {stats['total_searches']} (filtered: {stats['filtered_searches']})"""
+
+
+def get_available_tags(user_id: str) -> List[str]:
+    """Get available tags for dropdown."""
+    return MNEMO.get_all_tags(user_id=user_id or "default")
 
 
 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)
+        return "❌ Please enter content", get_stats_text(user_id), gr.update(choices=get_available_tags(user_id))
     
     tags_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else []
     embedding = compute_embedding(content)
@@ -46,39 +50,65 @@ def add_memory(content: str, importance: float, tags: str, user_id: str):
     
     op = result['operation']
     icon = {"ADD": "✅", "UPDATE": "🔄", "NOOP": "⚠️"}.get(op, "❓")
-    return f"{icon} {result['message']} (ID: {result['id']})", get_stats_text(user_id)
+    
+    return (
+        f"{icon} {result['message']} (ID: {result['id']})",
+        get_stats_text(user_id),
+        gr.update(choices=get_available_tags(user_id))
+    )
 
 
-def search_memories(query: str, k: int, min_score: float, user_id: str):
+def search_memories(
+    query: str,
+    k: int,
+    min_score: float,
+    user_id: str,
+    filter_tags_include: List[str],
+    filter_tags_exclude: List[str],
+    filter_min_importance: float,
+    filter_content_contains: str
+):
+    """Search memories with optional filters."""
     if not query.strip():
         return "❌ Please enter a search query"
     
     start = time.time()
     query_embedding = compute_embedding(query)
     
+    # Build filter
+    mem_filter = None
+    if any([filter_tags_include, filter_tags_exclude, 
+            filter_min_importance > 0, filter_content_contains]):
+        mem_filter = MemoryFilter(
+            tags_include_any=filter_tags_include if filter_tags_include else None,
+            tags_exclude=filter_tags_exclude if filter_tags_exclude else None,
+            min_importance=filter_min_importance if filter_min_importance > 0 else None,
+            content_contains=filter_content_contains if filter_content_contains else None
+        )
+    
     results = MNEMO.search_with_embedding(
         query_embedding=query_embedding,
         user_id=user_id or "default",
         k=k,
-        min_score=min_score
+        min_score=min_score,
+        filter=mem_filter
     )
     
     latency = (time.time() - start) * 1000
+    filter_str = " (filtered)" if mem_filter else ""
     
     if not results:
-        return f"No results found (searched in {latency:.1f}ms)"
+        return f"No results found{filter_str} (searched in {latency:.1f}ms)"
     
-    output = f"**Found {len(results)} results in {latency:.1f}ms**\n\n"
+    output = f"**Found {len(results)} results{filter_str} 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"
@@ -86,6 +116,42 @@ def search_memories(query: str, k: int, min_score: float, user_id: str):
     return output
 
 
+def search_by_tags_only(
+    tags: List[str],
+    match_all: bool,
+    k: int,
+    user_id: str
+):
+    """Search by tags without semantic query."""
+    if not tags:
+        return "❌ Please select at least one tag"
+    
+    start = time.time()
+    results = MNEMO.search_by_tags(
+        tags=tags,
+        user_id=user_id or "default",
+        match_all=match_all,
+        k=k
+    )
+    latency = (time.time() - start) * 1000
+    
+    match_str = "ALL" if match_all else "ANY"
+    
+    if not results:
+        return f"No memories found with {match_str} tags: {', '.join(tags)}"
+    
+    output = f"**Found {len(results)} memories with {match_str} tags 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"- Importance: `{r['importance']:.2f}`\n"
+        output += f"- Tags: `{', '.join(r['tags'])}`\n"
+        output += "\n---\n\n"
+    
+    return output
+
+
 def list_memories_ui(user_id: str, limit: int):
     memories = MNEMO.list_memories(user_id=user_id or "default", limit=limit)
     
@@ -95,9 +161,8 @@ def list_memories_ui(user_id: str, limit: int):
     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['id']}** (importance: {m['importance']:.2f})\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"
@@ -123,13 +188,13 @@ def clear_memories_ui(user_id: str):
 
 def load_examples(user_id: str):
     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"]),
+        ("User prefers dark mode and VS Code for development", 1.0, ["preferences", "development", "tools"]),
+        ("Project deadline is March 15th 2026 for the Q1 release", 0.9, ["project", "deadline", "work"]),
+        ("Favorite programming language is Python, also uses TypeScript", 0.8, ["preferences", "languages", "development"]),
+        ("Weekly standup meetings are every Monday at 10am", 0.7, ["meetings", "schedule", "work"]),
+        ("User is allergic to peanuts - important health info", 1.0, ["health", "critical", "personal"]),
+        ("Prefers cappuccino with oat milk for coffee orders", 0.5, ["preferences", "food", "personal"]),
+        ("Working on a machine learning project for recommendation systems", 0.8, ["project", "ml", "work"]),
         ("Lives in San Francisco, timezone is PST", 0.6, ["personal", "location"]),
     ]
     
@@ -148,14 +213,19 @@ def load_examples(user_id: str):
         if result['operation'] in ('ADD', 'UPDATE'):
             added += 1
     
-    return f"✅ Loaded {added} example memories", get_stats_text(user_id)
+    return (
+        f"✅ Loaded {added} example memories",
+        get_stats_text(user_id),
+        gr.update(choices=get_available_tags(user_id))
+    )
 
 
+# Build the Gradio interface
 with gr.Blocks(title="Mnemo v2", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🧠 Mnemo v2 - Enhanced Memory for LLMs
+    # 🧠 Mnemo v2 - Enhanced Memory with Filtering
     
-    **Features:** 🔍 Semantic embeddings | ⚡ HNSW search | 📉 Temporal decay | 📊 Relevance scoring | 🔄 Auto-dedup | 👥 Multi-user
+    **Features:** 🔍 Semantic search | 🏷️ Tag filtering | ⚡ HNSW index | 📉 Temporal decay | 🔄 Auto-dedup
     """)
     
     with gr.Row():
@@ -165,47 +235,170 @@ with gr.Blocks(title="Mnemo v2", theme=gr.themes.Soft()) as demo:
     stats_display = gr.Markdown(get_stats_text())
     
     with gr.Tabs():
+        # SEARCH TAB
         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")
+                with gr.Column(scale=2):
+                    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")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("**Filters (optional)**")
+                    filter_tags_include = gr.Dropdown(
+                        label="Include tags (any)",
+                        choices=[],
+                        multiselect=True
+                    )
+                    filter_tags_exclude = gr.Dropdown(
+                        label="Exclude tags",
+                        choices=[],
+                        multiselect=True
+                    )
+                    filter_min_importance = gr.Slider(
+                        0, 1, value=0, step=0.1,
+                        label="Min importance"
+                    )
+                    filter_content = gr.Textbox(
+                        label="Content contains",
+                        placeholder="substring to match"
+                    )
+            
             search_btn = gr.Button("Search", variant="primary")
             search_output = gr.Markdown()
-            search_btn.click(search_memories, [search_query, search_k, search_min_score, user_id_input], search_output)
+            
+            search_btn.click(
+                search_memories,
+                inputs=[
+                    search_query, search_k, search_min_score, user_id_input,
+                    filter_tags_include, filter_tags_exclude,
+                    filter_min_importance, filter_content
+                ],
+                outputs=search_output
+            )
+        
+        # TAG SEARCH TAB
+        with gr.Tab("🏷️ Search by Tags"):
+            gr.Markdown("Search memories by tags only (no semantic query needed)")
+            
+            tag_search_tags = gr.Dropdown(
+                label="Select tags",
+                choices=[],
+                multiselect=True
+            )
+            with gr.Row():
+                tag_match_all = gr.Checkbox(label="Match ALL tags", value=False)
+                tag_search_k = gr.Slider(1, 50, value=10, step=1, label="Max Results")
+            
+            tag_search_btn = gr.Button("Search by Tags", variant="primary")
+            tag_search_output = gr.Markdown()
+            
+            tag_search_btn.click(
+                search_by_tags_only,
+                inputs=[tag_search_tags, tag_match_all, tag_search_k, user_id_input],
+                outputs=tag_search_output
+            )
         
+        # ADD MEMORY TAB
         with gr.Tab("➕ Add Memory"):
-            add_content = gr.Textbox(label="Memory Content", placeholder="e.g., User prefers dark mode", lines=3)
+            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="preferences, settings")
+                add_tags = gr.Textbox(
+                    label="Tags (comma-separated)",
+                    placeholder="e.g., preferences, settings, personal"
+                )
             add_btn = gr.Button("Add Memory", variant="primary")
             add_output = gr.Textbox(label="Result")
-            add_btn.click(add_memory, [add_content, add_importance, add_tags, user_id_input], [add_output, stats_display])
+            
+            add_btn.click(
+                add_memory,
+                inputs=[add_content, add_importance, add_tags, user_id_input],
+                outputs=[add_output, stats_display, filter_tags_include]
+            )
         
+        # LIST TAB
         with gr.Tab("📋 List"):
             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, [user_id_input, list_limit], list_output)
+            
+            list_btn.click(
+                list_memories_ui,
+                inputs=[user_id_input, list_limit],
+                outputs=list_output
+            )
         
+        # MANAGE TAB
         with gr.Tab("⚙️ Manage"):
             delete_id = gr.Textbox(label="Memory ID to Delete")
             delete_btn = gr.Button("Delete", variant="stop")
             delete_output = gr.Textbox(label="Result")
-            delete_btn.click(delete_memory_ui, [delete_id, user_id_input], [delete_output, stats_display])
+            
+            delete_btn.click(
+                delete_memory_ui,
+                inputs=[delete_id, user_id_input],
+                outputs=[delete_output, stats_display]
+            )
             
             clear_btn = gr.Button("🗑️ Clear All", variant="stop")
             clear_output = gr.Textbox(label="Result")
-            clear_btn.click(clear_memories_ui, [user_id_input], [clear_output, stats_display])
+            
+            clear_btn.click(
+                clear_memories_ui,
+                inputs=[user_id_input],
+                outputs=[clear_output, stats_display]
+            )
+    
+    # Update tag dropdowns when examples are loaded
+    def update_tags_and_stats(user_id):
+        tags = get_available_tags(user_id)
+        return (
+            get_stats_text(user_id),
+            gr.update(choices=tags),
+            gr.update(choices=tags),
+            gr.update(choices=tags)
+        )
     
-    load_btn.click(load_examples, [user_id_input], [stats_display, stats_display])
+    load_btn.click(
+        load_examples,
+        inputs=[user_id_input],
+        outputs=[stats_display, stats_display, filter_tags_include]
+    ).then(
+        lambda uid: (gr.update(choices=get_available_tags(uid)), 
+                     gr.update(choices=get_available_tags(uid)),
+                     gr.update(choices=get_available_tags(uid))),
+        inputs=[user_id_input],
+        outputs=[filter_tags_include, filter_tags_exclude, tag_search_tags]
+    )
     
     gr.Markdown("""
     ---
-    | Embeddings | Vector Index | Decay | Scoring |
-    |------------|--------------|-------|---------|
-    | all-MiniLM-L6-v2 (384d) | FAISS HNSW | 7-day half-life | 40% sim + 30% rec + 30% freq |
+    ### Filter Options
+    
+    | Filter | Description |
+    |--------|-------------|
+    | Include tags (any) | Results must have at least one of these tags |
+    | Exclude tags | Results must NOT have any of these tags |
+    | Min importance | Only memories with importance >= this value |
+    | Content contains | Substring match in memory content |
+    
+    ### Architecture
+    
+    | Component | Implementation |
+    |-----------|----------------|
+    | Embeddings | `sentence-transformers/all-MiniLM-L6-v2` (384d) |
+    | Vector Index | FAISS IndexFlatIP (cosine similarity) |
+    | Tag Index | Inverted index for O(1) tag lookup |
+    | Filtering | Post-search filtering with expanded candidate set |
     """)
 
 if __name__ == "__main__":