Merge pull request #1 from mudler/memory

Add memory MCP

Author: mudler

.github/workflows/image.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        mcp: [duckduckgo, weather]
+        mcp: [duckduckgo, weather, memory]
     permissions:
       packages: write
       contents: read

README.md

@@ -101,6 +101,60 @@ mcp:
     }
 ```
 
+### 🧠 Memory Server
+
+A persistent memory storage server that allows AI models to store, retrieve, and manage information across sessions.
+
+**Features:**
+- Persistent JSON file storage
+- Add, list, and remove memory entries
+- Unique ID generation for each entry
+- Timestamp tracking for entries
+- Configurable storage location
+- JSON schema validation for inputs/outputs
+
+**Tools:**
+- `add_memory` - Add a new entry to memory storage
+- `list_memory` - List all memory entries
+- `remove_memory` - Remove a memory entry by ID
+
+**Configuration:**
+- `MEMORY_FILE_PATH` - Environment variable to set the memory file path (default: `/data/memory.json`)
+
+**Memory Entry Format:**
+```json
+{
+  "id": "1703123456789000000",
+  "content": "User prefers coffee over tea",
+  "created_at": "2023-12-21T10:30:56.789Z"
+}
+```
+
+**Docker Image:**
+```bash
+docker run -e MEMORY_FILE_PATH=/custom/path/memory.json ghcr.io/mudler/mcps/memory:latest
+```
+
+**LocalAI configuration ( to add to the model config):**
+```yaml
+mcp:
+  stdio: |
+    {
+      "mcpServers": {
+        "memory": {
+          "command": "docker",
+          "env": {
+            "MEMORY_FILE_PATH": "/data/memory.json"
+          },
+          "args": [
+            "run", "-i", "--rm", "-v", "/host/data:/data",
+            "ghcr.io/mudler/mcps/memory:master"
+          ]
+        }
+      }
+    }
+```
+
 ## Development
 
 ### Prerequisites
@@ -123,6 +177,7 @@ make dev
 # Build specific server
 make MCP_SERVER=duckduckgo build
 make MCP_SERVER=weather build
+make MCP_SERVER=memory build
 
 # Run tests and checks
 make ci-local
@@ -178,6 +233,9 @@ Docker images are automatically built and pushed to GitHub Container Registry:
 - `ghcr.io/mudler/mcps/weather:latest` - Latest Weather server
 - `ghcr.io/mudler/mcps/weather:v1.0.0` - Tagged versions
 - `ghcr.io/mudler/mcps/weather:master` - Development versions
+- `ghcr.io/mudler/mcps/memory:latest` - Latest Memory server
+- `ghcr.io/mudler/mcps/memory:v1.0.0` - Tagged versions
+- `ghcr.io/mudler/mcps/memory:master` - Development versions
 
 ## Contributing
 

memory/main.go

@@ -0,0 +1,216 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+// Memory entry structure
+type MemoryEntry struct {
+	ID        string    `json:"id"`
+	Content   string    `json:"content"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// Memory storage structure
+type MemoryStorage struct {
+	Entries []MemoryEntry `json:"entries"`
+}
+
+// Input types for different operations
+type AddMemoryInput struct {
+	Content string `json:"content" jsonschema:"the content to store in memory"`
+}
+
+type RemoveMemoryInput struct {
+	ID string `json:"id" jsonschema:"the ID of the memory entry to remove"`
+}
+
+// Output types
+type AddMemoryOutput struct {
+	ID        string    `json:"id" jsonschema:"the ID of the created memory entry"`
+	Content   string    `json:"content" jsonschema:"the stored content"`
+	CreatedAt time.Time `json:"created_at" jsonschema:"when the entry was created"`
+}
+
+type ListMemoryOutput struct {
+	Entries []MemoryEntry `json:"entries" jsonschema:"list of all memory entries"`
+}
+
+type RemoveMemoryOutput struct {
+	Success bool   `json:"success" jsonschema:"whether the removal was successful"`
+	Message string `json:"message" jsonschema:"status message"`
+}
+
+// Global variable to store the memory file path
+var memoryFilePath string
+
+// Load memory entries from JSON file
+func loadMemory() (*MemoryStorage, error) {
+	if _, err := os.Stat(memoryFilePath); os.IsNotExist(err) {
+		// File doesn't exist, return empty storage
+		return &MemoryStorage{Entries: []MemoryEntry{}}, nil
+	}
+
+	data, err := os.ReadFile(memoryFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read memory file: %w", err)
+	}
+
+	var storage MemoryStorage
+	if err := json.Unmarshal(data, &storage); err != nil {
+		return nil, fmt.Errorf("failed to parse memory file: %w", err)
+	}
+
+	return &storage, nil
+}
+
+// Save memory entries to JSON file
+func saveMemory(storage *MemoryStorage) error {
+	data, err := json.MarshalIndent(storage, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal memory data: %w", err)
+	}
+
+	if err := os.WriteFile(memoryFilePath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write memory file: %w", err)
+	}
+
+	return nil
+}
+
+// Generate a unique ID for memory entries
+func generateID() string {
+	return fmt.Sprintf("%d", time.Now().UnixNano())
+}
+
+// Add memory entry
+func AddMemory(ctx context.Context, req *mcp.CallToolRequest, input AddMemoryInput) (
+	*mcp.CallToolResult,
+	AddMemoryOutput,
+	error,
+) {
+	storage, err := loadMemory()
+	if err != nil {
+		return nil, AddMemoryOutput{}, err
+	}
+
+	entry := MemoryEntry{
+		ID:        generateID(),
+		Content:   input.Content,
+		CreatedAt: time.Now(),
+	}
+
+	storage.Entries = append(storage.Entries, entry)
+
+	if err := saveMemory(storage); err != nil {
+		return nil, AddMemoryOutput{}, err
+	}
+
+	output := AddMemoryOutput{
+		ID:        entry.ID,
+		Content:   entry.Content,
+		CreatedAt: entry.CreatedAt,
+	}
+
+	return nil, output, nil
+}
+
+// List all memory entries
+func ListMemory(ctx context.Context, req *mcp.CallToolRequest, input struct{}) (
+	*mcp.CallToolResult,
+	ListMemoryOutput,
+	error,
+) {
+	storage, err := loadMemory()
+	if err != nil {
+		return nil, ListMemoryOutput{}, err
+	}
+
+	output := ListMemoryOutput{
+		Entries: storage.Entries,
+	}
+
+	return nil, output, nil
+}
+
+// Remove memory entry by ID
+func RemoveMemory(ctx context.Context, req *mcp.CallToolRequest, input RemoveMemoryInput) (
+	*mcp.CallToolResult,
+	RemoveMemoryOutput,
+	error,
+) {
+	storage, err := loadMemory()
+	if err != nil {
+		return nil, RemoveMemoryOutput{}, err
+	}
+
+	// Find and remove the entry
+	found := false
+	for i, entry := range storage.Entries {
+		if entry.ID == input.ID {
+			storage.Entries = append(storage.Entries[:i], storage.Entries[i+1:]...)
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		output := RemoveMemoryOutput{
+			Success: false,
+			Message: fmt.Sprintf("Memory entry with ID '%s' not found", input.ID),
+		}
+		return nil, output, nil
+	}
+
+	if err := saveMemory(storage); err != nil {
+		return nil, RemoveMemoryOutput{}, err
+	}
+
+	output := RemoveMemoryOutput{
+		Success: true,
+		Message: fmt.Sprintf("Memory entry with ID '%s' removed successfully", input.ID),
+	}
+
+	return nil, output, nil
+}
+
+func main() {
+	// Get memory file path from environment variable, default to ./memory.json
+	memoryFilePath = os.Getenv("MEMORY_FILE_PATH")
+	if memoryFilePath == "" {
+		memoryFilePath = "/data/memory.json"
+	}
+
+	os.MkdirAll(filepath.Dir(memoryFilePath), 0755)
+
+	// Create a server with memory tools
+	server := mcp.NewServer(&mcp.Implementation{Name: "memory", Version: "v1.0.0"}, nil)
+
+	// Register memory tools
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "add_memory",
+		Description: "Add a new entry to memory storage",
+	}, AddMemory)
+
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "list_memory",
+		Description: "List all memory entries",
+	}, ListMemory)
+
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "remove_memory",
+		Description: "Remove a memory entry by ID",
+	}, RemoveMemory)
+
+	if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
+		log.Fatal(err)
+	}
+}