Update app.py with smart injection and real embeddings

app.py

@@ -0,0 +1,276 @@
+"""
+Mnemo Demo - Gradio Interface
+Demonstrates smart memory injection and semantic search
+"""
+
+import gradio as gr
+from mnemo import Mnemo, should_inject_memory
+
+# Initialize global Mnemo instance
+memory = Mnemo(use_real_embeddings=True)
+
+# Pre-load some example memories
+EXAMPLE_MEMORIES = [
+    "User prefers Python programming and dark mode interfaces",
+    "Project deadline is March 15th for the API redesign",
+    "Previous analysis identified gender bias in Victorian psychiatry diagnoses",
+    "Framework has 5 checkpoints: gender, class, age, occupation, marital status",
+    "User's favorite coffee is cappuccino with oat milk, no sugar",
+    "Team standup meeting every Tuesday at 2pm in conference room 401",
+    "Working on machine learning model for customer churn prediction"
+]
+
+def initialize_demo():
+    """Initialize with example memories"""
+    memory.clear()
+    for mem in EXAMPLE_MEMORIES:
+        memory.add(mem)
+    return f"✅ Initialized with {len(EXAMPLE_MEMORIES)} example memories"
+
+def add_memory(content: str):
+    """Add a new memory"""
+    if not content.strip():
+        return "❌ Please enter some content", get_all_memories()
+    
+    mem_id = memory.add(content.strip())
+    return f"✅ Added memory: {mem_id}", get_all_memories()
+
+def search_memories(query: str, top_k: int = 5):
+    """Search memories"""
+    if not query.strip():
+        return "❌ Please enter a search query"
+    
+    results = memory.search(query.strip(), top_k=int(top_k))
+    
+    if not results:
+        return "No memories found"
+    
+    output = []
+    for r in results:
+        output.append(f"**[{r.id}]** (score: {r.score:.3f})")
+        output.append(f"{r.content}")
+        output.append(f"_Strategies: semantic={r.strategy_scores.get('semantic', 0):.2f}, bm25={r.strategy_scores.get('bm25', 0):.2f}, graph={r.strategy_scores.get('graph', 0):.2f}_")
+        output.append("---")
+    
+    return "\n".join(output)
+
+def check_injection(query: str, context: str = ""):
+    """Check if memory should be injected"""
+    should, reason = should_inject_memory(query, context)
+    
+    status = "✅ **INJECT MEMORY**" if should else "⏭️ **SKIP MEMORY**"
+    
+    return f"{status}\n\nReason: `{reason}`"
+
+def get_context_for_injection(query: str, top_k: int = 3):
+    """Get formatted context for prompt injection"""
+    if not query.strip():
+        return "❌ Please enter a query"
+    
+    context = memory.get_context(query.strip(), top_k=int(top_k))
+    
+    if not context:
+        return "_No relevant context found_"
+    
+    return f"```\n{context}\n```"
+
+def get_all_memories():
+    """Get all stored memories"""
+    if len(memory) == 0:
+        return "_No memories stored_"
+    
+    output = []
+    for mem in memory.list_all():
+        output.append(f"• **{mem.id}**: {mem.content[:100]}...")
+    
+    return "\n".join(output)
+
+def get_stats():
+    """Get system statistics"""
+    stats = memory.get_stats()
+    
+    output = []
+    for k, v in stats.items():
+        output.append(f"• **{k}**: {v}")
+    
+    return "\n".join(output)
+
+def clear_memories():
+    """Clear all memories"""
+    memory.clear()
+    return "✅ All memories cleared", "_No memories stored_"
+
+
+# Gradio Interface
+with gr.Blocks(title="Mnemo - AI Memory System", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧠 Mnemo - AI Memory System
+    
+    **Smart memory injection for LLMs, chatbots, and AI agents**
+    
+    > 21x faster than mem0 • Context-check algorithm • Real embeddings
+    """)
+    
+    with gr.Tab("💾 Memory Store"):
+        gr.Markdown("### Add and view memories")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                memory_input = gr.Textbox(
+                    label="New Memory",
+                    placeholder="Enter a memory to store...",
+                    lines=2
+                )
+                add_btn = gr.Button("➕ Add Memory", variant="primary")
+                add_status = gr.Markdown()
+            
+            with gr.Column(scale=3):
+                memories_display = gr.Markdown(label="Stored Memories")
+        
+        with gr.Row():
+            init_btn = gr.Button("🔄 Load Example Memories")
+            clear_btn = gr.Button("🗑️ Clear All")
+        
+        add_btn.click(add_memory, inputs=[memory_input], outputs=[add_status, memories_display])
+        init_btn.click(initialize_demo, outputs=[add_status])
+        init_btn.click(get_all_memories, outputs=[memories_display])
+        clear_btn.click(clear_memories, outputs=[add_status, memories_display])
+    
+    with gr.Tab("🔍 Search"):
+        gr.Markdown("### Search stored memories")
+        
+        with gr.Row():
+            search_input = gr.Textbox(
+                label="Search Query",
+                placeholder="Enter search query...",
+                lines=1
+            )
+            top_k_slider = gr.Slider(
+                minimum=1, maximum=10, value=5, step=1,
+                label="Number of Results"
+            )
+        
+        search_btn = gr.Button("🔍 Search", variant="primary")
+        search_results = gr.Markdown(label="Results")
+        
+        search_btn.click(
+            search_memories,
+            inputs=[search_input, top_k_slider],
+            outputs=[search_results]
+        )
+    
+    with gr.Tab("🎯 Smart Injection"):
+        gr.Markdown("""
+        ### Should memory be injected?
+        
+        The context-check algorithm detects if a query references prior context and needs memory injection.
+        
+        **Inject when:** "Based on your previous analysis...", "Compare to earlier...", "Using your framework..."
+        
+        **Skip when:** "What is Python?", "This is a NEW topic...", standalone questions
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                injection_query = gr.Textbox(
+                    label="Query to Check",
+                    placeholder="Enter a query to check...",
+                    lines=2
+                )
+                injection_context = gr.Textbox(
+                    label="Additional Context (optional)",
+                    placeholder="Any additional context...",
+                    lines=1
+                )
+                check_btn = gr.Button("🎯 Check Injection", variant="primary")
+            
+            with gr.Column():
+                injection_result = gr.Markdown(label="Result")
+        
+        check_btn.click(
+            check_injection,
+            inputs=[injection_query, injection_context],
+            outputs=[injection_result]
+        )
+        
+        gr.Markdown("### Get Context for Injection")
+        
+        with gr.Row():
+            context_query = gr.Textbox(
+                label="Query",
+                placeholder="Enter query to get context for...",
+                lines=1
+            )
+            context_top_k = gr.Slider(
+                minimum=1, maximum=5, value=3, step=1,
+                label="Number of Memories"
+            )
+        
+        context_btn = gr.Button("📝 Get Context")
+        context_output = gr.Markdown(label="Formatted Context")
+        
+        context_btn.click(
+            get_context_for_injection,
+            inputs=[context_query, context_top_k],
+            outputs=[context_output]
+        )
+    
+    with gr.Tab("📊 Stats"):
+        gr.Markdown("### System Statistics")
+        
+        stats_btn = gr.Button("🔄 Refresh Stats")
+        stats_display = gr.Markdown()
+        
+        stats_btn.click(get_stats, outputs=[stats_display])
+    
+    with gr.Tab("ℹ️ About"):
+        gr.Markdown("""
+        ## About Mnemo
+        
+        Mnemo (named after Mnemosyne, Greek goddess of memory) is an open-source memory system for AI applications.
+        
+        ### Features
+        
+        - **🎯 Smart Injection** - Context-check algorithm with 90% accuracy
+        - **🧬 Real Embeddings** - sentence-transformers (with hash fallback)
+        - **🔍 Multi-Strategy Search** - Semantic + BM25 + Knowledge Graph
+        - **📈 Feedback Learning** - Improves over time
+        - **⚡ Fast** - 21x faster than mem0
+        - **🔒 Private** - Fully local, no API keys needed
+        
+        ### Installation
+        
+        ```bash
+        pip install mnemo-memory
+        ```
+        
+        ### Quick Start
+        
+        ```python
+        from mnemo import Mnemo
+        
+        m = Mnemo()
+        m.add("User prefers dark mode")
+        
+        if m.should_inject("Based on user preferences..."):
+            context = m.get_context("preferences")
+            # Use context in prompt
+        ```
+        
+        ### Links
+        
+        - [HuggingFace Model](https://huggingface.co/AthelaPerk/mnemo-memory)
+        - [MCP Server](https://huggingface.co/spaces/AthelaPerk/mnemo-mcp)
+        
+        ---
+        
+        MIT License • Built with ❤️ for the AI community
+        """)
+
+
+# Initialize with examples on load
+demo.load(initialize_demo)
+demo.load(get_all_memories, outputs=[])
+
+if __name__ == "__main__":
+    demo.launch()