Zanny's Persistent Memory Manager
by zannyonear1h1
Verified
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MCPServer = void 0;
const express_1 = __importDefault(require("express"));
const memoryManager_1 = require("./memoryManager");
const config_1 = require("./config");
const logger_1 = __importDefault(require("./logger"));
class MCPServer {
app;
memoryManager;
constructor() {
this.app = (0, express_1.default)();
this.memoryManager = new memoryManager_1.MemoryManager();
this.setupMiddleware();
this.setupRoutes();
}
/**
* Set up middleware for the Express application
*/
setupMiddleware() {
this.app.use(express_1.default.json({ limit: '50mb' })); // Allow large payloads
this.app.use(express_1.default.urlencoded({ extended: true }));
// Log all requests using structured logging to avoid interfering with JSON-RPC
this.app.use((req, res, next) => {
logger_1.default.info(JSON.stringify({
method: req.method,
url: req.url,
timestamp: new Date().toISOString()
}));
next();
});
}
/**
* Set up routes for the Express application
*/
setupRoutes() {
// Health check
this.app.get('/health', (req, res) => {
res.status(200).json({ status: 'OK', name: config_1.config.name });
});
// MCP JSON-RPC endpoints
this.app.post('/tools/list', this.handleToolsList.bind(this));
this.app.post('/tools/call', this.handleToolsCall.bind(this));
// Legacy API routes (keeping for backward compatibility)
this.app.post('/api/memories', this.storeMemory.bind(this));
this.app.get('/api/memories', this.listMemories.bind(this));
this.app.get('/api/memories/:id', this.getMemory.bind(this));
this.app.delete('/api/memories/:id', this.deleteMemory.bind(this));
this.app.post('/api/detect', this.detectTriggers.bind(this));
// Error handler
this.app.use((err, req, res, next) => {
const errorObj = { error: err.message };
logger_1.default.error(JSON.stringify(errorObj));
res.status(500).json(errorObj);
});
}
/**
* Handle JSON-RPC tools/list request
*/
handleToolsList(req, res) {
const jsonRpcReq = req.body;
// Validate JSON-RPC request
if (!this.isValidJsonRpcRequest(jsonRpcReq)) {
res.status(400).json(this.createJsonRpcError(jsonRpcReq?.id || null, -32600, 'Invalid JSON-RPC request'));
return;
}
// List of available tools
const tools = [
{
name: 'store_memory',
description: 'Store a new memory in the memory bank',
parameters: {
type: 'object',
properties: {
content: {
type: 'string',
description: 'Memory content to store'
},
tags: {
type: 'array',
items: {
type: 'string'
},
description: 'Optional tags for the memory'
}
},
required: ['content']
}
},
{
name: 'retrieve_memory',
description: 'Retrieve a memory by its ID',
parameters: {
type: 'object',
properties: {
id: {
type: 'string',
description: 'Memory ID to retrieve'
}
},
required: ['id']
}
},
{
name: 'search_memories',
description: 'Search memories by content or tags',
parameters: {
type: 'object',
properties: {
search: {
type: 'string',
description: 'Search term to look for in memory content'
},
tags: {
type: 'array',
items: {
type: 'string'
},
description: 'Tags to filter memories by'
}
}
}
},
{
name: 'list_memories',
description: 'List all stored memories',
parameters: {
type: 'object',
properties: {}
}
},
{
name: 'delete_memory',
description: 'Delete a memory by its ID',
parameters: {
type: 'object',
properties: {
id: {
type: 'string',
description: 'Memory ID to delete'
}
},
required: ['id']
}
},
{
name: 'detect_command',
description: 'Detect and process memory commands in natural language text',
parameters: {
type: 'object',
properties: {
text: {
type: 'string',
description: 'Natural language text to analyze for memory commands'
}
},
required: ['text']
}
}
];
// Create JSON-RPC response
const response = {
jsonrpc: '2.0',
id: jsonRpcReq.id,
result: tools
};
res.status(200).json(response);
}
/**
* Handle JSON-RPC tools/call request
*/
async handleToolsCall(req, res) {
const jsonRpcReq = req.body;
// Validate JSON-RPC request
if (!this.isValidJsonRpcRequest(jsonRpcReq)) {
res.status(400).json(this.createJsonRpcError(jsonRpcReq?.id || null, -32600, 'Invalid JSON-RPC request'));
return;
}
const toolName = jsonRpcReq.params?.name;
const toolParams = jsonRpcReq.params?.parameters || {};
try {
let result;
// Call the appropriate tool function based on the tool name
switch (toolName) {
case 'store_memory':
result = await this.memoryManager.storeMemory(toolParams.content, toolParams.tags);
break;
case 'retrieve_memory':
result = await this.memoryManager.getMemoryById(toolParams.id);
if (!result) {
res.status(200).json(this.createJsonRpcError(jsonRpcReq.id, 404, 'Memory not found'));
return;
}
break;
case 'search_memories':
result = await this.memoryManager.searchMemories(toolParams.search, toolParams.tags);
break;
case 'list_memories':
result = await this.memoryManager.listAllMemories();
break;
case 'delete_memory':
result = await this.memoryManager.deleteMemory(toolParams.id);
if (!result) {
res.status(200).json(this.createJsonRpcError(jsonRpcReq.id, 404, 'Memory not found'));
return;
}
result = { success: true, message: `Memory with ID ${toolParams.id} has been deleted` };
break;
case 'detect_command':
result = await this.processCommand(toolParams.text);
break;
default:
res.status(200).json(this.createJsonRpcError(jsonRpcReq.id, -32601, 'Method not found', { toolName }));
return;
}
// Create JSON-RPC response
const response = {
jsonrpc: '2.0',
id: jsonRpcReq.id,
result
};
res.status(200).json(response);
}
catch (error) {
// Create JSON-RPC error response
const errorResponse = this.createJsonRpcError(jsonRpcReq.id, -32000, error.message || 'Server error', { stack: error.stack });
res.status(200).json(errorResponse);
}
}
/**
* Validate a JSON-RPC request
*/
isValidJsonRpcRequest(req) {
return (req &&
req.jsonrpc === '2.0' &&
req.id !== undefined &&
typeof req.method === 'string');
}
/**
* Create a JSON-RPC error response
*/
createJsonRpcError(id, code, message, data) {
return {
jsonrpc: '2.0',
id: id === null ? 0 : id,
error: {
code,
message,
...(data ? { data } : {})
}
};
}
/**
* Start the MCP server
*/
start() {
const port = config_1.config.port;
this.app.listen(port, () => {
logger_1.default.info(JSON.stringify({
event: 'server_start',
name: config_1.config.name,
port,
timestamp: new Date().toISOString()
}));
});
}
/**
* Store a new memory
*/
async storeMemory(req, res) {
try {
const { content, tags } = req.body;
if (!content) {
res.status(400).json({ error: 'Content is required' });
return;
}
const memory = await this.memoryManager.storeMemory(content, tags);
res.status(201).json(memory);
}
catch (error) {
logger_1.default.error(`Error storing memory: ${error}`);
res.status(500).json({ error: `Failed to store memory: ${error}` });
}
}
/**
* Get a specific memory by ID
*/
async getMemory(req, res) {
try {
const { id } = req.params;
const memory = await this.memoryManager.getMemoryById(id);
if (!memory) {
res.status(404).json({ error: 'Memory not found' });
return;
}
res.status(200).json(memory);
}
catch (error) {
logger_1.default.error(`Error getting memory: ${error}`);
res.status(500).json({ error: `Failed to get memory: ${error}` });
}
}
/**
* List or search memories
*/
async listMemories(req, res) {
try {
const { search, tags } = req.query;
let memories;
if (search || tags) {
const tagsArray = tags ? String(tags).split(',') : undefined;
memories = await this.memoryManager.searchMemories(search ? String(search) : undefined, tagsArray);
}
else {
memories = await this.memoryManager.listAllMemories();
}
res.status(200).json(memories);
}
catch (error) {
logger_1.default.error(`Error listing memories: ${error}`);
res.status(500).json({ error: `Failed to list memories: ${error}` });
}
}
/**
* Delete a memory by ID
*/
async deleteMemory(req, res) {
try {
const { id } = req.params;
const deleted = await this.memoryManager.deleteMemory(id);
if (!deleted) {
res.status(404).json({ error: 'Memory not found' });
return;
}
res.status(204).send();
}
catch (error) {
logger_1.default.error(`Error deleting memory: ${error}`);
res.status(500).json({ error: `Failed to delete memory: ${error}` });
}
}
/**
* Detect trigger keywords in text
*/
async detectTriggers(req, res) {
try {
const { text } = req.body;
if (!text) {
res.status(400).json({ error: 'Text is required' });
return;
}
const lowerText = text.toLowerCase();
const triggers = config_1.config.triggerKeywords.filter(keyword => lowerText.includes(keyword.toLowerCase()));
const triggered = triggers.length > 0;
logger_1.default.info(`Trigger detection: ${triggered ? 'Triggered' : 'Not triggered'} by "${text}"`);
if (triggered) {
// Check for command patterns
const result = this.processCommand(text);
res.status(200).json({
triggered,
triggers,
result
});
}
else {
res.status(200).json({
triggered,
triggers: []
});
}
}
catch (error) {
logger_1.default.error(`Error detecting triggers: ${error}`);
res.status(500).json({ error: `Failed to detect triggers: ${error}` });
}
}
/**
* Process a command based on the input text
*/
async processCommand(text) {
const lowerText = text.toLowerCase();
// Store memory pattern
const storePattern = /(remember|store|save|memorize)( this)?:? (.*)/i;
const storeMatch = text.match(storePattern);
if (storeMatch && storeMatch[3]) {
const content = storeMatch[3].trim();
const memory = await this.memoryManager.storeMemory(content);
return {
action: 'store',
memory,
message: `I've stored that memory for you. You can reference it with ID: ${memory.id}`
};
}
// Recall memory pattern (by search)
const recallPattern = /(recall|remember|retrieve|get)( memory)? (about|regarding|related to|on)? (.*)/i;
const recallMatch = text.match(recallPattern);
if (recallMatch && recallMatch[4]) {
const searchTerm = recallMatch[4].trim();
const memories = await this.memoryManager.searchMemories(searchTerm);
if (memories.length > 0) {
return {
action: 'recall',
memories,
message: `I found ${memories.length} memories about "${searchTerm}"`
};
}
else {
return {
action: 'recall',
memories: [],
message: `I couldn't find any memories about "${searchTerm}"`
};
}
}
// Delete memory pattern
const deletePattern = /(delete|remove|forget)( memory)? (with id|id|#)? (.*)/i;
const deleteMatch = text.match(deletePattern);
if (deleteMatch && deleteMatch[4]) {
const memoryId = deleteMatch[4].trim();
const deleted = await this.memoryManager.deleteMemory(memoryId);
if (deleted) {
return {
action: 'delete',
success: true,
message: `Memory with ID ${memoryId} has been deleted`
};
}
else {
return {
action: 'delete',
success: false,
message: `No memory found with ID ${memoryId}`
};
}
}
// List all memories pattern
if (/(list|show) all memories/i.test(lowerText)) {
const memories = await this.memoryManager.listAllMemories();
return {
action: 'list',
memories,
message: `You have ${memories.length} stored memories`
};
}
// Default action - no specific command detected
return {
action: 'unknown',
message: 'I detected memory-related keywords, but I couldn\'t identify a specific command. You can store, recall, or delete memories.'
};
}
}
exports.MCPServer = MCPServer;