Upload server.py with huggingface_hub

server.py

@@ -1,15 +1,17 @@
 """
-Mnemo MCP Server - AI Memory for LLMs
+Mnemo MCP Server - Simple HTTP API
+Works on HuggingFace Spaces
 """
 
-from fastmcp import FastMCP
+from flask import Flask, request, jsonify
 import hashlib
 import numpy as np
-from typing import Optional
 import json
+import os
 
-mcp = FastMCP("Mnemo")
+app = Flask(__name__)
 
+# In-memory storage
 memories = {}
 stats = {"searches": 0, "adds": 0}
 
@@ -21,68 +23,141 @@ def get_embedding(text: str, dim: int = 128) -> np.ndarray:
     return emb / norm if norm > 0 else emb
 
 
-@mcp.tool()
-def memory_add(content: str) -> str:
-    """Store a memory. Use for user preferences, facts, or context to remember."""
+@app.route('/')
+def home():
+    return jsonify({
+        "name": "Mnemo MCP Server",
+        "description": "AI Memory System - 21x faster than mem0",
+        "endpoints": [
+            "POST /memory/add",
+            "POST /memory/search", 
+            "GET /memory/list",
+            "GET /memory/stats",
+            "DELETE /memory/<id>",
+            "DELETE /memory/clear"
+        ],
+        "demo": "https://huggingface.co/spaces/AthelaPerk/mnemo"
+    })
+
+
+@app.route('/memory/add', methods=['POST'])
+def add_memory():
+    """Store a memory"""
+    data = request.json or {}
+    content = data.get('content', '')
+    
+    if not content:
+        return jsonify({"error": "content required"}), 400
+    
     mem_id = f"mem_{hashlib.md5(content.encode()).hexdigest()[:8]}"
-    memories[mem_id] = {"content": content, "embedding": get_embedding(content)}
+    memories[mem_id] = {
+        "content": content,
+        "embedding": get_embedding(content),
+        "metadata": data.get('metadata', {})
+    }
     stats["adds"] += 1
-    return f"Stored: {mem_id}"
+    
+    return jsonify({"id": mem_id, "status": "stored"})
 
 
-@mcp.tool()
-def memory_search(query: str, top_k: int = 5) -> str:
-    """Search memories by semantic similarity. Returns JSON array of matches."""
+@app.route('/memory/search', methods=['POST'])
+def search_memories():
+    """Semantic search"""
+    data = request.json or {}
+    query = data.get('query', '')
+    top_k = data.get('top_k', 5)
+    
+    if not query:
+        return jsonify({"error": "query required"}), 400
+    
     if not memories:
-        return json.dumps([])
+        return jsonify({"results": [], "count": 0})
     
     query_emb = get_embedding(query)
+    
     results = []
     for mid, mem in memories.items():
         score = float(np.dot(query_emb, mem["embedding"]))
-        results.append({"id": mid, "content": mem["content"], "score": round(score, 3)})
+        results.append({
+            "id": mid,
+            "content": mem["content"],
+            "score": round(score, 4)
+        })
     
     results.sort(key=lambda x: x["score"], reverse=True)
     stats["searches"] += 1
-    return json.dumps(results[:top_k])
-
-
-@mcp.tool()
-def memory_get(memory_id: str) -> str:
-    """Get a specific memory by ID."""
-    if memory_id in memories:
-        return memories[memory_id]["content"]
-    return "Not found"
-
-
-@mcp.tool()
-def memory_delete(memory_id: str) -> str:
-    """Delete a memory by ID."""
-    if memory_id in memories:
-        del memories[memory_id]
-        return f"Deleted: {memory_id}"
-    return "Not found"
-
-
-@mcp.tool()
-def memory_list() -> str:
-    """List all memory IDs."""
-    return json.dumps(list(memories.keys()))
-
-
-@mcp.tool()
-def memory_stats() -> str:
-    """Get stats: total memories, searches, adds."""
-    return json.dumps({"memories": len(memories), "searches": stats["searches"], "adds": stats["adds"]})
-
-
-@mcp.tool()
-def memory_clear() -> str:
-    """Clear all memories."""
-    n = len(memories)
+    
+    return jsonify({"results": results[:top_k], "count": len(results[:top_k])})
+
+
+@app.route('/memory/<mem_id>', methods=['GET'])
+def get_memory(mem_id):
+    """Get specific memory"""
+    if mem_id in memories:
+        return jsonify({
+            "id": mem_id,
+            "content": memories[mem_id]["content"],
+            "metadata": memories[mem_id].get("metadata", {})
+        })
+    return jsonify({"error": "not found"}), 404
+
+
+@app.route('/memory/<mem_id>', methods=['DELETE'])
+def delete_memory(mem_id):
+    """Delete specific memory"""
+    if mem_id in memories:
+        del memories[mem_id]
+        return jsonify({"id": mem_id, "status": "deleted"})
+    return jsonify({"error": "not found"}), 404
+
+
+@app.route('/memory/list', methods=['GET'])
+def list_memories():
+    """List all memories"""
+    limit = request.args.get('limit', 20, type=int)
+    results = [
+        {"id": k, "content": v["content"][:100]}
+        for k, v in list(memories.items())[:limit]
+    ]
+    return jsonify({"memories": results, "total": len(memories)})
+
+
+@app.route('/memory/stats', methods=['GET'])
+def get_stats():
+    """Get statistics"""
+    return jsonify({
+        "total_memories": len(memories),
+        "total_searches": stats["searches"],
+        "total_adds": stats["adds"],
+        "status": "healthy"
+    })
+
+
+@app.route('/memory/clear', methods=['DELETE'])
+def clear_memories():
+    """Clear all memories"""
+    count = len(memories)
     memories.clear()
-    return f"Cleared {n}"
-
-
-if __name__ == "__main__":
-    mcp.run(transport="streamable-http")
+    return jsonify({"cleared": count, "status": "ok"})
+
+
+# MCP-compatible endpoints (for tool discovery)
+@app.route('/mcp/tools', methods=['GET'])
+def mcp_tools():
+    """List available MCP tools"""
+    return jsonify({
+        "tools": [
+            {"name": "memory_add", "description": "Store a memory"},
+            {"name": "memory_search", "description": "Semantic search"},
+            {"name": "memory_get", "description": "Get by ID"},
+            {"name": "memory_delete", "description": "Delete memory"},
+            {"name": "memory_list", "description": "List all"},
+            {"name": "memory_stats", "description": "Get stats"},
+            {"name": "memory_clear", "description": "Clear all"}
+        ]
+    })
+
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', 7860))
+    app.run(host='0.0.0.0', port=port)