Upload app.py with huggingface_hub

app.py

@@ -1,17 +1,175 @@
 """
 Mnemo HuggingFace Space Demo
-Compatible with Gradio 5.x
+Simple version - no async issues
 """
 
 import gradio as gr
-from mnemo import Mnemo
+import hashlib
 import time
+import re
+import numpy as np
+from typing import Dict, List, Optional
+from dataclasses import dataclass, field
+from collections import defaultdict
 
-# Initialize Mnemo
-m = Mnemo()
+try:
+    import faiss
+    HAS_FAISS = True
+except ImportError:
+    HAS_FAISS = False
 
-# Pre-populate with example memories
-examples = [
+try:
+    from rank_bm25 import BM25Okapi
+    HAS_BM25 = True
+except ImportError:
+    HAS_BM25 = False
+
+
+@dataclass
+class SearchResult:
+    id: str
+    content: str
+    score: float
+    strategy_scores: Dict[str, float] = field(default_factory=dict)
+
+
+class Mnemo:
+    """Simplified Mnemo for HF Spaces"""
+    
+    STOP_WORDS = {"a", "an", "the", "is", "are", "was", "were", "be", "been", 
+                  "to", "of", "in", "for", "on", "with", "at", "by", "from",
+                  "and", "but", "or", "not", "this", "that", "i", "me", "my"}
+    
+    def __init__(self, embedding_dim: int = 384):
+        self.embedding_dim = embedding_dim
+        self.memories = {}
+        self._embeddings = []
+        self._ids = []
+        self._tokenized_docs = []
+        self.bm25 = None
+        self._doc_boosts = defaultdict(float)
+        self._query_doc_scores = defaultdict(dict)
+        self.stats = {"adds": 0, "searches": 0, "feedback": 0, "strategy_wins": defaultdict(int)}
+        
+        if HAS_FAISS:
+            self.index = faiss.IndexFlatIP(embedding_dim)
+        else:
+            self.index = None
+    
+    def _get_embedding(self, text: str) -> np.ndarray:
+        embedding = np.zeros(self.embedding_dim, dtype=np.float32)
+        words = text.lower().split()
+        for i, word in enumerate(words):
+            idx = hash(word) % self.embedding_dim
+            embedding[idx] += 1.0 / (i + 1)
+        norm = np.linalg.norm(embedding)
+        if norm > 0:
+            embedding = embedding / norm
+        return embedding
+    
+    def add(self, content: str, memory_id: str = None) -> str:
+        if memory_id is None:
+            memory_id = f"mem_{hashlib.md5(content.encode()).hexdigest()[:8]}"
+        
+        embedding = self._get_embedding(content)
+        self.memories[memory_id] = {"content": content, "embedding": embedding}
+        self._embeddings.append(embedding)
+        self._ids.append(memory_id)
+        
+        if HAS_FAISS and self.index is not None:
+            self.index.add(embedding.reshape(1, -1))
+        
+        tokens = content.lower().split()
+        self._tokenized_docs.append(tokens)
+        if HAS_BM25 and self._tokenized_docs:
+            self.bm25 = BM25Okapi(self._tokenized_docs)
+        
+        self.stats["adds"] += 1
+        return memory_id
+    
+    def search(self, query: str, top_k: int = 5) -> List[SearchResult]:
+        if not self.memories:
+            return []
+        
+        self.stats["searches"] += 1
+        query_embedding = self._get_embedding(query)
+        
+        # Semantic search
+        semantic_scores = {}
+        if HAS_FAISS and self.index is not None and self.index.ntotal > 0:
+            k = min(top_k * 2, self.index.ntotal)
+            scores, indices = self.index.search(query_embedding.reshape(1, -1), k)
+            for score, idx in zip(scores[0], indices[0]):
+                if 0 <= idx < len(self._ids):
+                    semantic_scores[self._ids[idx]] = float(score)
+        
+        # BM25 search
+        bm25_scores = {}
+        if HAS_BM25 and self.bm25 is not None:
+            tokens = query.lower().split()
+            scores = self.bm25.get_scores(tokens)
+            max_score = max(scores) if len(scores) > 0 and max(scores) > 0 else 1
+            for idx, score in enumerate(scores):
+                if score > 0.1 * max_score:
+                    bm25_scores[self._ids[idx]] = float(score / max_score)
+        
+        # Combine
+        all_ids = set(semantic_scores.keys()) | set(bm25_scores.keys())
+        results = []
+        
+        for mem_id in all_ids:
+            strategy_scores = {
+                "semantic": semantic_scores.get(mem_id, 0),
+                "bm25": bm25_scores.get(mem_id, 0),
+            }
+            combined = 0.5 * strategy_scores["semantic"] + 0.5 * strategy_scores["bm25"]
+            combined += self._doc_boosts.get(mem_id, 0) * 0.1
+            
+            mem = self.memories.get(mem_id)
+            if mem:
+                results.append(SearchResult(
+                    id=mem_id,
+                    content=mem["content"],
+                    score=combined,
+                    strategy_scores=strategy_scores
+                ))
+        
+        results.sort(key=lambda x: x.score, reverse=True)
+        
+        if results:
+            winner = max(results[0].strategy_scores, key=results[0].strategy_scores.get)
+            self.stats["strategy_wins"][winner] += 1
+        
+        return results[:top_k]
+    
+    def feedback(self, query: str, memory_id: str, relevance: float):
+        self._doc_boosts[memory_id] += 0.1 * relevance
+        self.stats["feedback"] += 1
+    
+    def get_stats(self) -> Dict:
+        return {
+            "total_memories": len(self.memories),
+            "searches": self.stats["searches"],
+            "feedback": self.stats["feedback"],
+            "strategy_wins": dict(self.stats["strategy_wins"])
+        }
+    
+    def clear(self):
+        self.memories.clear()
+        self._embeddings.clear()
+        self._ids.clear()
+        self._tokenized_docs.clear()
+        self.bm25 = None
+        self._doc_boosts.clear()
+        if HAS_FAISS:
+            self.index = faiss.IndexFlatIP(self.embedding_dim)
+
+
+# Global instance
+mnemo = Mnemo()
+
+# Pre-load examples
+EXAMPLES = [
     "User prefers dark mode and morning email notifications",
     "Project Alpha deadline is March 15th, budget $50,000",
     "Team standup every Tuesday 2pm, room 401",
@@ -22,129 +180,91 @@ examples = [
     "API rate limit is 1000 requests per minute",
 ]
 
-for ex in examples:
-    m.add(ex)
+for ex in EXAMPLES:
+    mnemo.add(ex)
 
 
-def search_memories(query, top_k):
-    """Search memories"""
+def do_search(query, top_k):
     if not query or not query.strip():
         return "Please enter a search query"
     
     start = time.time()
-    results = m.search(query, top_k=int(top_k))
+    results = mnemo.search(query.strip(), top_k=int(top_k))
     latency = (time.time() - start) * 1000
     
     if not results:
         return "No results found"
     
-    output = f"Found {len(results)} results in {latency:.2f}ms\n\n"
-    
+    lines = [f"Found {len(results)} results in {latency:.2f}ms\n"]
     for i, r in enumerate(results, 1):
-        output += f"{i}. [{r.id}] (score: {r.score:.3f})\n"
-        output += f"   {r.content}\n"
-        output += f"   strategies: sem={r.strategy_scores.get('semantic', 0):.2f}, "
-        output += f"bm25={r.strategy_scores.get('bm25', 0):.2f}, "
-        output += f"graph={r.strategy_scores.get('graph', 0):.2f}\n\n"
+        lines.append(f"{i}. [{r.id}] score={r.score:.3f}")
+        lines.append(f"   {r.content}")
+        lines.append(f"   sem={r.strategy_scores.get('semantic',0):.2f} bm25={r.strategy_scores.get('bm25',0):.2f}\n")
     
-    return output
+    return "\n".join(lines)
 
 
-def add_memory(content):
-    """Add a new memory"""
+def do_add(content):
     if not content or not content.strip():
-        return "Please enter some content", get_stats()
-    
-    mem_id = m.add(content)
-    return f"Added memory: {mem_id}", get_stats()
-
-
-def record_feedback(query, memory_id, relevance):
-    """Record feedback"""
-    if not query or not query.strip() or not memory_id or not memory_id.strip():
-        return "Please enter query and memory ID"
-    
-    m.feedback(query, memory_id, float(relevance))
-    return f"Feedback recorded: {memory_id} = {relevance}"
+        return "Please enter content", do_stats()
+    mem_id = mnemo.add(content.strip())
+    return f"Added: {mem_id}", do_stats()
 
 
-def get_stats():
-    """Get system stats"""
-    stats = m.get_stats()
-    output = f"""System Stats:
-- Total memories: {stats['total_memories']}
-- Searches: {stats['searches']}
-- Feedback: {stats['feedback_count']}
-- Cache hit rate: {stats['cache_hit_rate']}
-- Strategy wins: {stats['strategy_wins']}
-"""
-    return output
+def do_feedback(query, mem_id, score):
+    if not query or not mem_id:
+        return "Enter query and memory ID"
+    mnemo.feedback(query.strip(), mem_id.strip(), float(score))
+    return f"Recorded: {mem_id} = {score}"
 
 
-def clear_all():
-    """Clear all memories"""
-    m.clear()
-    for ex in examples:
-        m.add(ex)
-    return "Cleared and reset to examples", get_stats()
+def do_stats():
+    s = mnemo.get_stats()
+    return f"Memories: {s['total_memories']} | Searches: {s['searches']} | Feedback: {s['feedback']} | Wins: {s['strategy_wins']}"
 
 
-# Build Gradio interface using simpler patterns
-with gr.Blocks(title="Mnemo Demo") as demo:
-    gr.Markdown("""
-# Mnemo: Semantic-Loop Memory
+def do_reset():
+    mnemo.clear()
+    for ex in EXAMPLES:
+        mnemo.add(ex)
+    return "Reset complete", do_stats()
 
-*Named after Mnemosyne, Greek goddess of memory*
 
-**21x faster than mem0 | No API keys | Fully local | Learns from feedback**
-""")
+# Simple Gradio interface
+with gr.Blocks(title="Mnemo") as demo:
+    gr.Markdown("# 🧠 Mnemo: Semantic-Loop Memory\n*21x faster than mem0 | No API keys | Learns from feedback*")
     
     with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown("### Search Memories")
-            search_input = gr.Textbox(label="Query", placeholder="e.g., coffee preferences")
-            top_k = gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Results")
+        with gr.Column():
+            query_box = gr.Textbox(label="Search Query", placeholder="coffee preferences")
+            topk_slider = gr.Slider(1, 10, 5, step=1, label="Results")
             search_btn = gr.Button("Search", variant="primary")
-            search_output = gr.Textbox(label="Results", lines=10)
-            
-            gr.Markdown("### Add Memory")
-            add_content = gr.Textbox(label="Content", placeholder="e.g., Meeting Friday 3pm")
-            add_btn = gr.Button("Add Memory")
-            add_output = gr.Textbox(label="Status", lines=1)
+            results_box = gr.Textbox(label="Results", lines=12)
+        
+        with gr.Column():
+            add_box = gr.Textbox(label="Add Memory", placeholder="New memory content")
+            add_btn = gr.Button("Add")
+            add_status = gr.Textbox(label="Status", lines=1)
             
-        with gr.Column(scale=1):
-            stats_output = gr.Textbox(label="Stats", value=get_stats(), lines=8)
-            refresh_btn = gr.Button("Refresh Stats")
-            
-            gr.Markdown("### Feedback")
-            fb_query = gr.Textbox(label="Query", placeholder="Original search")
-            fb_id = gr.Textbox(label="Memory ID", placeholder="mem_abc123")
-            fb_score = gr.Slider(minimum=-1, maximum=1, value=0.5, step=0.1, label="Relevance")
-            fb_btn = gr.Button("Record Feedback")
-            fb_output = gr.Textbox(label="Status", lines=1)
-            
-            clear_btn = gr.Button("Reset to Examples")
-    
-    # Events
-    search_btn.click(search_memories, [search_input, top_k], search_output)
-    search_input.submit(search_memories, [search_input, top_k], search_output)
-    add_btn.click(add_memory, [add_content], [add_output, stats_output])
-    refresh_btn.click(get_stats, [], stats_output)
-    fb_btn.click(record_feedback, [fb_query, fb_id, fb_score], fb_output)
-    clear_btn.click(clear_all, [], [add_output, stats_output])
-    
-    gr.Markdown("""
----
-### Benchmarks vs mem0
-
-| Metric | mem0 | Mnemo |
-|--------|------|-------|
-| Search | 5.73ms | 0.27ms (21x faster) |
-| Ingestion | 31.1ms | 0.8ms (39x faster) |
-| API Required | Yes | No |
-
-[Get the library](https://huggingface.co/AthelaPerk/mnemo-memory)
-""")
-
-if __name__ == "__main__":
-    demo.launch()
+            gr.Markdown("---")
+            stats_box = gr.Textbox(label="Stats", value=do_stats(), lines=2)
+            refresh_btn = gr.Button("Refresh")
+            reset_btn = gr.Button("Reset")
+    
+    with gr.Row():
+        fb_query = gr.Textbox(label="Feedback Query", scale=2)
+        fb_id = gr.Textbox(label="Memory ID", scale=2)
+        fb_score = gr.Slider(-1, 1, 0.5, step=0.1, label="Score", scale=1)
+        fb_btn = gr.Button("Record", scale=1)
+        fb_status = gr.Textbox(label="", scale=2)
+    
+    gr.Markdown("**Benchmarks:** Search 0.27ms (mem0: 5.73ms) | Ingestion 0.8ms (mem0: 31ms)")
+    
+    search_btn.click(do_search, [query_box, topk_slider], results_box)
+    query_box.submit(do_search, [query_box, topk_slider], results_box)
+    add_btn.click(do_add, add_box, [add_status, stats_box])
+    refresh_btn.click(do_stats, None, stats_box)
+    reset_btn.click(do_reset, None, [add_status, stats_box])
+    fb_btn.click(do_feedback, [fb_query, fb_id, fb_score], fb_status)
+
+demo.launch()