Long Term Memory MCP Server

README.md

@@ -1,14 +1,155 @@
 ---
 title: Long Term Memory MCP Server
-emoji: 🏃
-colorFrom: green
-colorTo: indigo
+emoji: 🧠
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.33.0
+sdk_version: "4.0.0"
 app_file: app.py
 pinned: false
 license: mit
-short_description: Long Term Memory MCP Server
+tags:
+  - mcp-server-track
+  - mcp
+  - memory
+  - rag
+  - llm
+  - conversation
+short_description: MCP Server providing long-term memory for LLM conversations
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🧠 Long Term Memory MCP Server
+
+**Tags**: mcp-server-track
+
+A Model Context Protocol (MCP) server that provides long-term memory capabilities for LLM conversations. This allows users to save important insights, conclusions, and context from conversations and retrieve them in future interactions.
+
+## 🎯 Problem Solved
+
+Current LLM interactions are stateless - they don't remember previous conversations or insights you've shared. This MCP server solves that by providing:
+
+- **Persistent Memory**: Save important insights and context from conversations
+- **Semantic Search**: Find relevant memories using natural language queries
+- **Context Continuity**: Build upon previous conversations and learnings
+- **Knowledge Accumulation**: Build a personal knowledge base over time
+
+## 🚀 Features
+
+### MCP Server Tools
+- `save_memory` - Save insights, conclusions, or context to long-term memory
+- `search_memory` - Search through memories using semantic similarity
+- `list_memories` - Browse all stored memories
+- `delete_memory` - Remove specific memories
+
+### Gradio Demo Interface
+- Interactive web interface for testing all MCP tools
+- Real-time memory statistics
+- Semantic search with adjustable similarity thresholds
+- Memory browsing and management
+
+## 🛠️ Technical Architecture
+
+- **MCP Protocol**: Standards-compliant MCP server
+- **Vector Storage**: ChromaDB for efficient semantic search
+- **Embeddings**: SentenceTransformers (all-MiniLM-L6-v2) for semantic understanding
+- **Interface**: Gradio web app for demonstration and testing
+- **Storage**: Persistent local database
+
+## 📦 Installation & Usage
+
+### Local Development
+```bash
+# Clone and install dependencies
+pip install -r requirements.txt
+
+# Run the application
+python app.py
+```
+
+### Hugging Face Spaces
+This Space runs both the MCP server and Gradio demo simultaneously.
+
+## 🎮 Demo Video
+
+[Demo Video Link](https://your-demo-video-link.com) - *Recording of the MCP server working with Claude Desktop*
+
+## 💡 Use Cases
+
+### Example Scenario
+1. **Initial Conversation**: You discuss quantum consciousness theories with an LLM
+2. **Save Insight**: Use `save_memory` to store key conclusions
+3. **Future Conversation**: LLM can `search_memory` to find relevant context
+4. **Continuity**: Build upon previous insights in new discussions
+
+### Sample Usage with Claude Desktop
+
+**Saving a memory:**
+```
+User: "Save this insight to memory: 'Consciousness might emerge from quantum processes in microtubules, as proposed by Penrose-Hameroff theory. This could explain the hard problem of consciousness.' Title: 'Quantum Consciousness Theory', Tags: 'consciousness, quantum, penrose, microtubules'"
+
+LLM: *Uses save_memory tool*
+✅ Memory saved successfully! ID: abc123...
+```
+
+**Searching memories:**
+```
+User: "What did we previously discuss about consciousness and quantum physics?"
+
+LLM: *Uses search_memory tool*
+🔍 Found relevant memory: "Quantum Consciousness Theory" - discusses how consciousness might emerge from quantum processes in microtubules...
+```
+
+## 🔧 MCP Client Configuration
+
+### Claude Desktop
+Add to your `claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "long-term-memory": {
+      "command": "python",
+      "args": ["path/to/mcp_server.py"],
+      "env": {}
+    }
+  }
+}
+```
+
+### Cursor IDE
+Configure in your MCP settings to connect to the server.
+
+## 📊 Memory Statistics
+
+The system tracks:
+- Total memories stored
+- Content length statistics
+- Tag usage patterns
+- Timestamp-based organization
+
+## 🔐 Privacy & Data
+
+- All data stored locally in ChromaDB
+- No external API calls for embeddings (uses local SentenceTransformers)
+- Full control over your memory data
+- Easy export/import capabilities
+
+## 🚧 Future Enhancements
+
+- [ ] Memory categorization and hierarchical organization
+- [ ] Conversation threading and context linking
+- [ ] Export/import functionality
+- [ ] Advanced search filters (date, tags, content type)
+- [ ] Memory summarization and consolidation
+- [ ] Integration with external knowledge bases
+
+## 🤝 Contributing
+
+This project was created for the [Hugging Face MCP Hackathon](https://huggingface.co/Agents-MCP-Hackathon). Contributions welcome!
+
+## 📝 License
+
+MIT License - Feel free to use and modify!
+
+---
+
+*Built with ❤️ for the Hugging Face MCP Hackathon - Track 1: MCP Server/Tool*

app.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Long Term Memory MCP Server & Gradio Demo
+A Model Context Protocol server that provides long-term memory capabilities for LLM conversations.
+"""
+
+import os
+import sys
+import threading
+import time
+import subprocess
+from pathlib import Path
+
+# Add the current directory to the Python path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from gradio_demo import demo
+
+def run_mcp_server():
+    """Run the MCP server in a separate thread."""
+    try:
+        # Import and run the MCP server
+        from mcp_server import main
+        import asyncio
+        
+        # Create new event loop for this thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        # Run the server
+        loop.run_until_complete(main())
+    except Exception as e:
+        print(f"MCP Server error: {e}")
+
+def main():
+    """Main entry point."""
+    print("🧠 Starting Long Term Memory MCP Server & Demo...")
+    
+    # Start MCP server in background thread
+    mcp_thread = threading.Thread(target=run_mcp_server, daemon=True)
+    mcp_thread.start()
+    
+    # Give the MCP server a moment to start
+    time.sleep(2)
+    
+    print("✅ MCP Server started!")
+    print("🚀 Launching Gradio demo...")
+    
+    # Launch Gradio demo
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

demo_script.md

@@ -0,0 +1,121 @@
+# 🎬 Demo Script & Testing Guide
+
+## Quick Start Testing
+
+### 1. Test Gradio Interface
+1. Visit the Hugging Face Space
+2. Try saving a memory in the "Save Memory" tab
+3. Search for it in the "Search Memory" tab
+4. Browse all memories in the "Browse Memories" tab
+
+### 2. Test MCP Server with Claude Desktop
+
+#### Setup:
+1. Add to your `claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "long-term-memory": {
+      "command": "python",
+      "args": ["run_mcp_server.py"],
+      "env": {},
+      "cwd": "/path/to/your/project"
+    }
+  }
+}
+```
+
+2. Restart Claude Desktop
+
+#### Demo Script for Video:
+
+**Scene 1: Introduction**
+"Hi! I'm demonstrating a Long Term Memory MCP Server that solves a key problem with LLM conversations - they don't remember previous discussions. Let me show you how this works."
+
+**Scene 2: Save a Memory**
+```
+User: "I want to save an important insight to my long-term memory. Use the save_memory tool with this content: 'Consciousness might emerge from quantum processes in microtubules according to the Penrose-Hameroff theory. This could explain the binding problem and why we have unified conscious experience.' Use the title 'Quantum Consciousness Theory' and tags 'consciousness, quantum, penrose, microtubules, binding-problem'"
+```
+
+**Scene 3: Save Another Memory** 
+```
+User: "Save another insight: 'Free will might be an illusion created by our brain's narrative construction. The feeling of choice comes after neural commitment to action.' Title: 'Free Will Illusion Theory', tags: 'free-will, neuroscience, consciousness, illusion'"
+```
+
+**Scene 4: Search Memories**
+```
+User: "Search my memories for information about consciousness and how it relates to quantum physics"
+```
+
+**Scene 5: Demonstrate Context Continuity**
+```
+User: "Based on what we previously discussed about consciousness, what are the implications for artificial intelligence? Use my memories to inform your response."
+```
+
+**Scene 6: List All Memories**
+```
+User: "Show me all the memories I have stored using the list_memories tool"
+```
+
+## Demo Scenarios
+
+### Scenario 1: Philosophy Student
+1. Save insights from reading different philosophers
+2. Search for connections between ideas
+3. Build upon previous understanding in new discussions
+
+### Scenario 2: Research Notes
+1. Save key findings from papers
+2. Find related research using semantic search
+3. Synthesize knowledge across sessions
+
+### Scenario 3: Personal Development
+1. Save insights from conversations about goals
+2. Track progress and learnings over time
+3. Reference past conclusions in future planning
+
+## Testing Checklist
+
+### Basic Functionality
+- [ ] Save memory with all fields
+- [ ] Save memory with minimal fields
+- [ ] Search with various queries
+- [ ] Search with different thresholds
+- [ ] List memories with different limits
+- [ ] View memory statistics
+
+### Edge Cases
+- [ ] Empty search query
+- [ ] Search with no results
+- [ ] Search when no memories exist
+- [ ] Very long content
+- [ ] Special characters in content
+- [ ] Multiple identical memories
+
+### MCP Integration
+- [ ] Server starts correctly
+- [ ] Tools are discovered by client
+- [ ] All tools execute successfully  
+- [ ] Error handling works
+- [ ] Multiple concurrent requests
+
+## Performance Benchmarks
+
+### Expected Performance
+- **Save Memory**: < 1 second
+- **Search 100 memories**: < 2 seconds  
+- **List memories**: < 0.5 seconds
+- **Memory footprint**: ~50MB for 1000 memories
+
+### Scalability Limits
+- **ChromaDB**: Handles 100K+ documents efficiently
+- **Embeddings**: 384-dimensional vectors (all-MiniLM-L6-v2)
+- **Storage**: ~1KB per memory average
+
+## Troubleshooting
+
+### Common Issues
+1. **"MCP not available"**: Install missing dependencies
+2. **Embedding model fails**: Check internet connection for initial download
+3. **ChromaDB errors**: Check write permissions for memory_db directory
+4. **Claude Desktop not connecting**: Verify config.json path an

dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directory for database
+RUN mkdir -p /app/memory_db
+
+# Expose port
+EXPOSE 7860
+
+# Set environment variables
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+
+# Run the application
+CMD ["python", "app.py"]

gradio_demo.py

@@ -0,0 +1,359 @@
+import gradio as gr
+import json
+import asyncio
+from datetime import datetime
+from typing import List, Dict, Any
+import uuid
+import chromadb
+from chromadb.config import Settings
+from sentence_transformers import SentenceTransformer
+from pathlib import Path
+
+class LongTermMemoryDemo:
+    def __init__(self):
+        self.db_path = "./memory_db"
+        Path(self.db_path).mkdir(exist_ok=True)
+        
+        # Initialize ChromaDB
+        self.chroma_client = chromadb.PersistentClient(
+            path=self.db_path,
+            settings=Settings(anonymized_telemetry=False)
+        )
+        
+        # Get or create collection
+        try:
+            self.collection = self.chroma_client.get_collection("memories")
+        except:
+            self.collection = self.chroma_client.create_collection(
+                name="memories",
+                metadata={"description": "Long-term memory storage for conversations"}
+            )
+        
+        # Initialize sentence transformer for embeddings
+        print("Loading SentenceTransformer model...")
+        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
+        print("Model loaded successfully!")
+    
+    def save_memory(self, content: str, title: str, tags: str = "", context: str = "") -> str:
+        """Save content to long-term memory."""
+        if not content or not title:
+            return "❌ Error: Content and title are required!"
+        
+        try:
+            tags_list = [tag.strip() for tag in tags.split(',') if tag.strip()] if tags else []
+            
+            memory_id = str(uuid.uuid4())
+            timestamp = datetime.now().isoformat()
+            
+            # Create embedding
+            embedding = self.encoder.encode(f"{title} {content}").tolist()
+            
+            # Prepare metadata
+            metadata = {
+                "title": title,
+                "timestamp": timestamp,
+                "tags": json.dumps(tags_list),
+                "context": context,
+                "content_length": len(content)
+            }
+            
+            # Save to ChromaDB
+            self.collection.add(
+                documents=[content],
+                embeddings=[embedding],
+                metadatas=[metadata],
+                ids=[memory_id]
+            )
+            
+            result = f"✅ **Memory saved successfully!**\n\n"
+            result += f"**ID**: `{memory_id}`\n"
+            result += f"**Title**: {title}\n"
+            result += f"**Timestamp**: {timestamp}\n"
+            if tags_list:
+                result += f"**Tags**: {', '.join(tags_list)}\n"
+            if context:
+                result += f"**Context**: {context}\n"
+            result += f"**Content Preview**: {content[:200]}{'...' if len(content) > 200 else ''}"
+            
+            return result
+        except Exception as e:
+            return f"❌ Error saving memory: {str(e)}"
+    
+    def search_memory(self, query: str, limit: int = 5, threshold: float = 0.3) -> str:
+        """Search through memories."""
+        if not query:
+            return "❌ Error: Search query is required!"
+        
+        try:
+            if self.collection.count() == 0:
+                return "📭 No memories stored yet. Save some memories first!"
+            
+            # Create query embedding
+            query_embedding = self.encoder.encode(query).tolist()
+            
+            # Search in ChromaDB
+            results = self.collection.query(
+                query_embeddings=[query_embedding],
+                n_results=min(limit, self.collection.count())
+            )
+            
+            if not results['documents'][0]:
+                return "🔍 No relevant memories found."
+            
+            # Filter by threshold and format results
+            response = f"🔍 **Search Results for**: \"{query}\"\n\n"
+            
+            found_relevant = False
+            for i, (doc, metadata, distance) in enumerate(zip(
+                results['documents'][0], 
+                results['metadatas'][0], 
+                results['distances'][0]
+            )):
+                similarity = 1 - distance
+                if similarity >= threshold:
+                    found_relevant = True
+                    tags = json.loads(metadata.get('tags', '[]'))
+                    
+                    response += f"### {i+1}. {metadata['title']} (Similarity: {similarity:.2f})\n"
+                    response += f"**Saved**: {metadata['timestamp']}\n"
+                    if tags:
+                        response += f"**Tags**: {', '.join(tags)}\n"
+                    if metadata.get('context'):
+                        response += f"**Context**: {metadata['context']}\n"
+                    response += f"**Content**: {doc}\n\n"
+                    response += "---\n\n"
+            
+            if not found_relevant:
+                response += f"No memories found above similarity threshold of {threshold:.2f}"
+            
+            return response
+        except Exception as e:
+            return f"❌ Error searching memories: {str(e)}"
+    
+    def list_memories(self, limit: int = 10) -> str:
+        """List all memories."""
+        try:
+            if self.collection.count() == 0:
+                return "📭 No memories stored yet."
+            
+            # Get all memories
+            results = self.collection.get()
+            
+            if not results['documents']:
+                return "📭 No memories found."
+            
+            response = f"📚 **All Memories** (showing up to {limit})\n\n"
+            
+            # Sort by timestamp (newest first)
+            memories = list(zip(results['ids'], results['documents'], results['metadatas']))
+            memories.sort(key=lambda x: x[2]['timestamp'], reverse=True)
+            
+            for i, (memory_id, doc, metadata) in enumerate(memories[:limit]):
+                tags = json.loads(metadata.get('tags', '[]'))
+                
+                response += f"### {i+1}. {metadata['title']}\n"
+                response += f"**ID**: `{memory_id}`\n"
+                response += f"**Saved**: {metadata['timestamp']}\n"
+                if tags:
+                    response += f"**Tags**: {', '.join(tags)}\n"
+                response += f"**Preview**: {doc[:150]}{'...' if len(doc) > 150 else ''}\n\n"
+                response += "---\n\n"
+            
+            if len(memories) > limit:
+                response += f"... and {len(memories) - limit} more memories"
+            
+            return response
+        except Exception as e:
+            return f"❌ Error listing memories: {str(e)}"
+    
+    def get_memory_stats(self) -> str:
+        """Get statistics about stored memories."""
+        try:
+            count = self.collection.count()
+            if count == 0:
+                return "📊 **Memory Statistics**: No memories stored yet."
+            
+            results = self.collection.get()
+            
+            # Calculate stats
+            total_content_length = sum(metadata['content_length'] for metadata in results['metadatas'])
+            avg_content_length = total_content_length / count if count > 0 else 0
+            
+            # Get all tags
+            all_tags = []
+            for metadata in results['metadatas']:
+                tags = json.loads(metadata.get('tags', '[]'))
+                all_tags.extend(tags)
+            
+            unique_tags = list(set(all_tags))
+            
+            stats = f"📊 **Memory Statistics**\n\n"
+            stats += f"**Total Memories**: {count}\n"
+            stats += f"**Total Content Length**: {total_content_length:,} characters\n"
+            stats += f"**Average Content Length**: {avg_content_length:.0f} characters\n"
+            stats += f"**Unique Tags**: {len(unique_tags)}\n"
+            if unique_tags:
+                stats += f"**Tags**: {', '.join(unique_tags[:10])}{'...' if len(unique_tags) > 10 else ''}\n"
+            
+            return stats
+        except Exception as e:
+            return f"❌ Error getting statistics: {str(e)}"
+
+# Initialize the demo
+print("Initializing Long Term Memory Demo...")
+ltm_demo = LongTermMemoryDemo()
+
+# Create Gradio interface
+with gr.Blocks(title="Long Term Memory MCP Server Demo", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧠 Long Term Memory MCP Server Demo
+    
+    This is a demonstration of an MCP (Model Context Protocol) Server that provides long-term memory capabilities for LLM conversations.
+    
+    ## Features:
+    - 💾 **Save Memory**: Store important insights, conclusions, or context
+    - 🔍 **Search Memory**: Find relevant information using semantic search
+    - 📚 **List Memories**: Browse all stored memories
+    - 📊 **Statistics**: View memory usage statistics
+    
+    ## How it works:
+    1. **Embeddings**: Uses SentenceTransformers to create semantic embeddings
+    2. **Vector Storage**: ChromaDB for efficient similarity search
+    3. **MCP Protocol**: Exposes tools that any MCP-compatible client can use
+    """)
+    
+    with gr.Tabs():
+        # Save Memory Tab
+        with gr.Tab("💾 Save Memory"):
+            gr.Markdown("### Save important insights or context to long-term memory")
+            
+            with gr.Row():
+                with gr.Column():
+                    save_title = gr.Textbox(
+                        label="Title",
+                        placeholder="Brief title for this memory...",
+                        lines=1
+                    )
+                    save_content = gr.Textbox(
+                        label="Content",
+                        placeholder="The insight, conclusion, or context you want to remember...",
+                        lines=5
+                    )
+                    save_tags = gr.Textbox(
+                        label="Tags (optional)",
+                        placeholder="quantum physics, consciousness, philosophy",
+                        lines=1
+                    )
+                    save_context = gr.Textbox(
+                        label="Context (optional)",
+                        placeholder="Why is this important? When was it discussed?",
+                        lines=2
+                    )
+                    save_btn = gr.Button("💾 Save Memory", variant="primary")
+                
+                with gr.Column():
+                    save_output = gr.Markdown()
+            
+            save_btn.click(
+                ltm_demo.save_memory,
+                inputs=[save_content, save_title, save_tags, save_context],
+                outputs=[save_output]
+            )
+        
+        # Search Memory Tab
+        with gr.Tab("🔍 Search Memory"):
+            gr.Markdown("### Search through your memories using semantic similarity")
+            
+            with gr.Row():
+                with gr.Column():
+                    search_query = gr.Textbox(
+                        label="Search Query",
+                        placeholder="quantum consciousness, reality nature, philosophical insights...",
+                        lines=2
+                    )
+                    with gr.Row():
+                        search_limit = gr.Slider(
+                            label="Max Results",
+                            minimum=1,
+                            maximum=20,
+                            value=5,
+                            step=1
+                        )
+                        search_threshold = gr.Slider(
+                            label="Similarity Threshold",
+                            minimum=0.0,
+                            maximum=1.0,
+                            value=0.3,
+                            step=0.05
+                        )
+                    search_btn = gr.Button("🔍 Search Memories", variant="primary")
+                
+                with gr.Column():
+                    search_output = gr.Markdown()
+            
+            search_btn.click(
+                ltm_demo.search_memory,
+                inputs=[search_query, search_limit, search_threshold],
+                outputs=[search_output]
+            )
+        
+        # List Memories Tab
+        with gr.Tab("📚 Browse Memories"):
+            gr.Markdown("### Browse all stored memories")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    list_limit = gr.Slider(
+                        label="Number of memories to show",
+                        minimum=5,
+                        maximum=50,
+                        value=10,
+                        step=5
+                    )
+                    list_btn = gr.Button("📚 List Memories", variant="primary")
+                    stats_btn = gr.Button("📊 Show Statistics", variant="secondary")
+                
+                with gr.Column(scale=3):
+                    list_output = gr.Markdown()
+            
+            list_btn.click(
+                ltm_demo.list_memories,
+                inputs=[list_limit],
+                outputs=[list_output]
+            )
+            
+            stats_btn.click(
+                ltm_demo.get_memory_stats,
+                outputs=[list_output]
+            )
+    
+    gr.Markdown("""
+    ---
+    
+    ## 🔧 MCP Server Usage
+    
+    This Gradio app is also an MCP Server! You can connect to it from MCP-compatible clients like:
+    - Claude Desktop
+    - Cursor IDE
+    - Other MCP clients
+    
+    ### Available MCP Tools:
+    - `save_memory` - Save content to long-term memory
+    - `search_memory` - Search through memories
+    - `list_memories` - List all memories
+    - `delete_memory` - Delete a specific memory
+    
+    ### Example Usage in Claude Desktop:
+    ```
+    "Save this insight to memory: 'Consciousness might be a quantum phenomenon 
+    that emerges from the collapse of wave functions in microtubules.' 
+    Title: 'Quantum Consciousness Theory', Tags: 'quantum, consciousness, microtubules'"
+    ```
+    
+    Then later:
+    ```
+    "Search my memories for information about consciousness and quantum physics"
+    ```
+    """)
+
+print("Gradio interface created successfully!")

langchain_memory_tools.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+LangChain tools for Long Term Memory integration with Ollama
+"""
+
+from langchain.tools import tool
+from langchain_ollama import OllamaLLM
+from langchain.agents import create_react_agent, AgentExecutor
+from langchain import hub
+from typing import Optional, Dict, Any, List
+import requests
+import json
+
+# Import your existing LTM demo class  
+from gradio_demo import LongTermMemoryDemo
+
+# Initialize shared memory instance
+ltm = LongTermMemoryDemo()
+
+@tool
+def save_memory(content: str, title: str, tags: str = "", context: str = "") -> str:
+    """
+    Save important insights, conclusions, or context to long-term memory.
+    Use this to remember key information from conversations that might be useful later.
+    
+    Args:
+        content: The insight or information to save
+        title: A brief descriptive title
+        tags: Optional comma-separated tags
+        context: Optional additional context
+    """
+    try:
+        return ltm.save_memory(content, title, tags, context)
+    except Exception as e:
+        return f"Error saving memory: {str(e)}"
+
+@tool
+def search_memory(query: str, limit: int = 5, threshold: float = 0.3) -> str:
+    """
+    Search through long-term memory for relevant information.
+    Use this to find previously saved insights or context related to current discussion.
+    
+    Args:
+        query: What to search for
+        limit: Max number of results (default: 5)
+        threshold: Similarity threshold 0-1 (default: 0.3)
+    """
+    try:
+        return ltm.search_memory(query, limit, threshold)
+    except Exception as e:
+        return f"Error searching memory: {str(e)}"
+
+@tool
+def list_memories(limit: int = 10) -> str:
+    """
+    List all stored memories to see what information is available.
+    Useful for getting an overview of stored knowledge.
+    
+    Args:
+        limit: Maximum number of memories to show (default: 10)
+    """
+    try:
+        return ltm.list_memories(limit)
+    except Exception as e:
+        return f"Error listing memories: {str(e)}"
+
+@tool
+def memory_stats() -> str:
+    """
+    Get statistics about stored memories.
+    Shows total count, tags, and other metadata.
+    """
+    try:
+        return ltm.get_memory_stats()
+    except Exception as e:
+        return f"Error getting stats: {str(e)}"
+
+# Example usage with Ollama
+def create_memory_enabled_agent(model_name: str = "llama3.2"):
+    """Create a LangChain agent with memory capabilities"""
+    
+    # Initialize Ollama LLM
+    llm = OllamaLLM(model=model_name)
+    
+    # Create tools list
+    tools = [save_memory, search_memory, list_memories, memory_stats]
+    
+    # Get the react prompt from hub
+    try:
+        prompt = hub.pull("hwchase17/react")
+    except:
+        # Fallback prompt if hub is not available
+        from langchain.prompts import PromptTemplate
+        
+        template = """Answer the following questions as best you can. You have access to the following tools:
+
+{tools}
+
+Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question
+
+Begin!
+
+Question: {input}
+Thought:{agent_scratchpad}"""
+        
+        prompt = PromptTemplate.from_template(template)
+    
+    # Create agent
+    agent = create_react_agent(llm, tools, prompt)
+    
+    # Create agent executor
+    agent_executor = AgentExecutor(
+        agent=agent,
+        tools=tools,
+        verbose=True,
+        handle_parsing_errors=True,
+        max_iterations=10
+    )
+    
+    return agent_executor
+
+# Example conversation loop
+def main():
+    """Example usage"""
+    print("🧠 Initializing Memory-Enabled Agent with Ollama...")
+    
+    try:
+        agent = create_memory_enabled_agent("llama3.2")  # или любая другая модель в Ollama
+        
+        print("✅ Agent ready! Type 'quit' to exit.")
+        print("💡 Try commands like:")
+        print("   - 'Save this insight: quantum computers might revolutionize AI with title Quantum AI and tags quantum,ai,future' ")
+        print("   - 'Search my memories for information about quantum computing'")
+        print("   - 'What memories do I have stored?'")
+        print("   - 'Show me memory statistics'")
+        print()
+        
+        while True:
+            try:
+                user_input = input("You: ").strip()
+                
+                if user_input.lower() in ['quit', 'exit', 'bye']:
+                    print("Goodbye!")
+                    break
+                
+                if not user_input:
+                    continue
+                
+                # Run the agent
+                response = agent.invoke({"input": user_input})
+                print(f"Agent: {response['output']}")
+                print()
+                
+            except KeyboardInterrupt:
+                print("\nGoodbye!")
+                break
+            except Exception as e:
+                print(f"Error: {e}")
+                continue
+                
+    except Exception as e:
+        print(f"Failed to initialize agent: {e}")
+        print("Make sure Ollama is running and the model is available.")
+        print("Try: ollama pull llama3.2")
+
+if __name__ == "__main__":
+    main()

local_run.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""
+Local runner for Memory-Enabled LangChain Agent
+"""
+
+from langchain_memory_tools import create_memory_enabled_agent
+
+
+def main():
+    print("🧠 Starting Memory-Enabled Chat with Ollama...")
+
+    # Убедитесь, что Ollama запущен и модель доступна
+    model_name = "llama3.2:3b"  # или другая модель в вашем Ollama
+
+    try:
+        agent = create_memory_enabled_agent(model_name)
+
+        print(f"✅ Agent with model '{model_name}' ready!")
+        print("💡 Example commands:")
+        print(
+            "   - Save this insight: 'Quantum computers use qubits' with title 'Quantum Computing Basics' and tags 'quantum,computing,physics'")
+        print("   - Search my memories for quantum")
+        print("   - List all my memories")
+        print("   - Show memory statistics")
+        print("   - Type 'quit' to exit")
+        print()
+
+        while True:
+            try:
+                user_input = input("You: ").strip()
+
+                if user_input.lower() in ['quit', 'exit', 'bye']:
+                    print("👋 Goodbye!")
+                    break
+
+                if not user_input:
+                    continue
+
+                print("🤔 Thinking...")
+                response = agent.invoke({"input": user_input})
+                print(f"🤖 Agent: {response['output']}")
+                print("-" * 50)
+
+            except KeyboardInterrupt:
+                print("\n👋 Goodbye!")
+                break
+            except Exception as e:
+                print(f"❌ Error: {e}")
+                print("Continuing...")
+                continue
+
+    except Exception as e:
+        print(f"❌ Failed to initialize agent: {e}")
+        print("\n🔧 Troubleshooting:")
+        print("1. Make sure Ollama is running: ollama serve")
+        print(f"2. Make sure model is available: ollama pull {model_name}")
+        print("3. Check if Ollama is accessible at http://localhost:11434")
+
+
+if __name__ == "__main__":
+    main()

ltm_mcp_server.py

@@ -0,0 +1,353 @@
+import asyncio
+import json
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Sequence
+from pathlib import Path
+import uuid
+
+import chromadb
+from chromadb.config import Settings
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+# MCP imports
+try:
+    from mcp.server import Server
+    from mcp.server.models import InitializationOptions
+    from mcp.server.stdio import stdio_server
+    from mcp.types import (
+        Resource,
+        Tool,
+        TextContent,
+        ImageContent,
+        EmbeddedResource,
+        LoggingLevel
+    )
+    MCP_AVAILABLE = True
+except ImportError:
+    print("MCP library not available, running in demo mode only")
+    MCP_AVAILABLE = False
+    
+    # Mock classes for demo mode
+    class Server:
+        def __init__(self, name): 
+            self.name = name
+        def list_tools(self): return lambda: None
+        def call_tool(self): return lambda: None
+    
+    class TextContent:
+        def __init__(self, type, text):
+            self.type = type
+            self.text = text
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("ltm-mcp-server")
+
+class LongTermMemoryServer:
+    def __init__(self):
+        self.server = Server("long-term-memory")
+        self.db_path = "./memory_db"
+        Path(self.db_path).mkdir(exist_ok=True)
+        
+        # Initialize ChromaDB
+        self.chroma_client = chromadb.PersistentClient(
+            path=self.db_path,
+            settings=Settings(anonymized_telemetry=False)
+        )
+        
+        # Get or create collection
+        try:
+            self.collection = self.chroma_client.get_collection("memories")
+        except:
+            self.collection = self.chroma_client.create_collection(
+                name="memories",
+                metadata={"description": "Long-term memory storage for conversations"}
+            )
+        
+        # Initialize sentence transformer for embeddings
+        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        self.setup_handlers()
+    
+    def setup_handlers(self):
+        @self.server.list_tools()
+        async def handle_list_tools() -> List[Tool]:
+            """List available tools."""
+            return [
+                Tool(
+                    name="save_memory",
+                    description="Save important insights, conclusions, or context from conversation to long-term memory",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "content": {
+                                "type": "string",
+                                "description": "The content/insight to save to memory"
+                            },
+                            "title": {
+                                "type": "string", 
+                                "description": "A short title/summary for this memory"
+                            },
+                            "tags": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "Optional tags to categorize this memory",
+                                "default": []
+                            },
+                            "context": {
+                                "type": "string",
+                                "description": "Additional context about when/why this was saved",
+                                "default": ""
+                            }
+                        },
+                        "required": ["content", "title"]
+                    }
+                ),
+                Tool(
+                    name="search_memory",
+                    description="Search through long-term memory for relevant information",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "Search query to find relevant memories"
+                            },
+                            "limit": {
+                                "type": "integer",
+                                "description": "Maximum number of results to return",
+                                "default": 5
+                            },
+                            "threshold": {
+                                "type": "number",
+                                "description": "Similarity threshold (0-1, higher = more similar)",
+                                "default": 0.3
+                            }
+                        },
+                        "required": ["query"]
+                    }
+                ),
+                Tool(
+                    name="list_memories",
+                    description="List all stored memories with basic info",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "limit": {
+                                "type": "integer",
+                                "description": "Maximum number of memories to return",
+                                "default": 10
+                            }
+                        }
+                    }
+                ),
+                Tool(
+                    name="delete_memory",
+                    description="Delete a specific memory by ID",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "memory_id": {
+                                "type": "string",
+                                "description": "The ID of the memory to delete"
+                            }
+                        },
+                        "required": ["memory_id"]
+                    }
+                )
+            ]
+
+        @self.server.call_tool()
+        async def handle_call_tool(name: str, arguments: Dict[str, Any]) -> Sequence[TextContent]:
+            """Handle tool calls."""
+            try:
+                if name == "save_memory":
+                    return await self._save_memory(**arguments)
+                elif name == "search_memory":
+                    return await self._search_memory(**arguments)
+                elif name == "list_memories":
+                    return await self._list_memories(**arguments)
+                elif name == "delete_memory":
+                    return await self._delete_memory(**arguments)
+                else:
+                    raise ValueError(f"Unknown tool: {name}")
+            except Exception as e:
+                logger.error(f"Error in tool {name}: {e}")
+                return [TextContent(type="text", text=f"Error: {str(e)}")]
+
+    async def _save_memory(self, content: str, title: str, tags: List[str] = None, context: str = "") -> Sequence[TextContent]:
+        """Save content to long-term memory."""
+        if tags is None:
+            tags = []
+            
+        memory_id = str(uuid.uuid4())
+        timestamp = datetime.now().isoformat()
+        
+        # Create embedding
+        embedding = self.encoder.encode(f"{title} {content}").tolist()
+        
+        # Prepare metadata
+        metadata = {
+            "title": title,
+            "timestamp": timestamp,
+            "tags": json.dumps(tags),
+            "context": context,
+            "content_length": len(content)
+        }
+        
+        # Save to ChromaDB
+        self.collection.add(
+            documents=[content],
+            embeddings=[embedding],
+            metadatas=[metadata],
+            ids=[memory_id]
+        )
+        
+        logger.info(f"Saved memory: {title} (ID: {memory_id})")
+        
+        result = f"✅ Memory saved successfully!\n\n"
+        result += f"**ID**: {memory_id}\n"
+        result += f"**Title**: {title}\n"
+        result += f"**Timestamp**: {timestamp}\n"
+        if tags:
+            result += f"**Tags**: {', '.join(tags)}\n"
+        if context:
+            result += f"**Context**: {context}\n"
+        result += f"**Content Preview**: {content[:200]}{'...' if len(content) > 200 else ''}"
+        
+        return [TextContent(type="text", text=result)]
+
+    async def _search_memory(self, query: str, limit: int = 5, threshold: float = 0.3) -> Sequence[TextContent]:
+        """Search through memories."""
+        if self.collection.count() == 0:
+            return [TextContent(type="text", text="No memories stored yet.")]
+        
+        # Create query embedding
+        query_embedding = self.encoder.encode(query).tolist()
+        
+        # Search in ChromaDB
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=min(limit, self.collection.count())
+        )
+        
+        if not results['documents'][0]:
+            return [TextContent(type="text", text="No relevant memories found.")]
+        
+        # Filter by threshold and format results
+        response = f"🔍 **Search Results for**: \"{query}\"\n\n"
+        
+        found_relevant = False
+        for i, (doc, metadata, distance) in enumerate(zip(
+            results['documents'][0], 
+            results['metadatas'][0], 
+            results['distances'][0]
+        )):
+            similarity = 1 - distance
+            if similarity >= threshold:
+                found_relevant = True
+                tags = json.loads(metadata.get('tags', '[]'))
+                
+                response += f"**{i+1}. {metadata['title']}** (Similarity: {similarity:.2f})\n"
+                response += f"*Saved*: {metadata['timestamp']}\n"
+                if tags:
+                    response += f"*Tags*: {', '.join(tags)}\n"
+                if metadata.get('context'):
+                    response += f"*Context*: {metadata['context']}\n"
+                response += f"*Content*: {doc}\n\n"
+                response += "---\n\n"
+        
+        if not found_relevant:
+            response += f"No memories found above similarity threshold of {threshold:.2f}"
+        
+        return [TextContent(type="text", text=response)]
+
+    async def _list_memories(self, limit: int = 10) -> Sequence[TextContent]:
+        """List all memories."""
+        if self.collection.count() == 0:
+            return [TextContent(type="text", text="No memories stored yet.")]
+        
+        # Get all memories (ChromaDB doesn't have a direct "get all" with limit)
+        results = self.collection.get()
+        
+        if not results['documents']:
+            return [TextContent(type="text", text="No memories found.")]
+        
+        response = f"📚 **All Memories** (showing up to {limit})\n\n"
+        
+        # Sort by timestamp (newest first)
+        memories = list(zip(results['ids'], results['documents'], results['metadatas']))
+        memories.sort(key=lambda x: x[2]['timestamp'], reverse=True)
+        
+        for i, (memory_id, doc, metadata) in enumerate(memories[:limit]):
+            tags = json.loads(metadata.get('tags', '[]'))
+            
+            response += f"**{i+1}. {metadata['title']}**\n"
+            response += f"*ID*: {memory_id}\n"
+            response += f"*Saved*: {metadata['timestamp']}\n"
+            if tags:
+                response += f"*Tags*: {', '.join(tags)}\n"
+            response += f"*Preview*: {doc[:150]}{'...' if len(doc) > 150 else ''}\n\n"
+            response += "---\n\n"
+        
+        if len(memories) > limit:
+            response += f"... and {len(memories) - limit} more memories"
+        
+        return [TextContent(type="text", text=response)]
+
+    async def _delete_memory(self, memory_id: str) -> Sequence[TextContent]:
+        """Delete a memory by ID."""
+        try:
+            # Check if memory exists
+            result = self.collection.get(ids=[memory_id])
+            if not result['documents']:
+                return [TextContent(type="text", text=f"❌ Memory with ID {memory_id} not found.")]
+            
+            # Get memory info before deletion
+            metadata = result['metadatas'][0]
+            title = metadata['title']
+            
+            # Delete from ChromaDB
+            self.collection.delete(ids=[memory_id])
+            
+            logger.info(f"Deleted memory: {title} (ID: {memory_id})")
+            
+            return [TextContent(type="text", text=f"✅ Memory deleted successfully!\n\n**Title**: {title}\n**ID**: {memory_id}")]
+            
+        except Exception as e:
+            logger.error(f"Error deleting memory {memory_id}: {e}")
+            return [TextContent(type="text", text=f"❌ Error deleting memory: {str(e)}")]
+
+    async def run(self):
+        """Run the MCP server."""
+        if not MCP_AVAILABLE:
+            print("MCP not available, cannot run server")
+            return
+            
+        async with stdio_server() as (read_stream, write_stream):
+            await self.server.run(
+                read_stream,
+                write_stream,
+                InitializationOptions(
+                    server_name="long-term-memory",
+                    server_version="1.0.0",
+                    capabilities=self.server.get_capabilities(
+                        notification_options=None,
+                        experimental_capabilities=None,
+                    ),
+                ),
+            )
+
+# Main entry point
+async def main():
+    if not MCP_AVAILABLE:
+        print("MCP server cannot run without MCP library")
+        return
+        
+    server = LongTermMemoryServer()
+    await server.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())

requirements.txt

@@ -0,0 +1,18 @@
+# Existing dependencies
+gradio>=4.0.0
+mcp>=1.0.0
+chromadb>=0.4.0
+sentence-transformers>=2.2.0
+numpy>=1.24.0
+asyncio-mqtt>=0.11.0
+pydantic>=2.0.0
+typing-extensions>=4.5.0
+
+# New dependencies for Ollama integration
+fastapi>=0.104.0
+uvicorn>=0.24.0
+langchain>=0.3.0
+langchain-ollama>=0.2.0
+langchain-community>=0.3.0
+langchainhub>=0.1.0
+requests>=2.31.0

run_mcp_server.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""
+Standalone MCP Server runner
+Use this script to run only the MCP server without Gradio
+"""
+
+import sys
+import asyncio
+from pathlib import Path
+
+# Add current directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from mcp_server import main
+
+if __name__ == "__main__":
+    print("🧠 Starting Long Term Memory MCP Server...")
+    asyncio.run(main())