moa-mcp-server
Version:
MCP Server for Memory of Agents (MOA) API - Memory Management & Intelligent Memory endpoints only
284 lines (277 loc) • 13 kB
JavaScript
#!/usr/bin/env node
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
import { ConfigManager } from './services/config.js';
import { MOAAPIService } from './services/moa-api.js';
import { storeMemoryTool, handleStoreMemory } from './tools/create-memory.js';
import { listMemoriesTool, handleListMemories } from './tools/list-memories.js';
import { searchMemoriesTool, handleSearchMemories } from './tools/search-memories.js';
import { getMemoryTool, handleGetMemory } from './tools/get-memory.js';
import { updateMemoryTool, handleUpdateMemory } from './tools/update-memory.js';
import { deleteMemoryTool, handleDeleteMemory } from './tools/delete-memory.js';
import { getMemoryStatsTool, handleGetMemoryStats } from './tools/get-memory-stats.js';
import { bulkDeleteMemoriesTool, handleBulkDeleteMemories } from './tools/bulk-delete-memories.js';
import { getRecentMemoriesTool, handleGetRecentMemories } from './tools/get-recent-memories.js';
import { getMemoryTagsTool, handleGetMemoryTags } from './tools/get-memory-tags.js';
import { processMemoryTool, handleProcessMemory } from './tools/process-memory.js';
import { exportMemoriesTool, handleExportMemories } from './tools/export-memories.js';
import { getMemoryProcessingStatusTool, handleGetMemoryProcessingStatus } from './tools/get-memory-processing-status.js';
import { reprocessMemoryTool, handleReprocessMemory } from './tools/reprocess-memory.js';
import { queryMemoriesTool, handleQueryMemories } from './tools/query-memories.js';
import { batchQueryMemoriesTool, handleBatchQueryMemories } from './tools/batch-query-memories.js';
import { getQuerySuggestionsTool, handleGetQuerySuggestions } from './tools/get-query-suggestions.js';
import { getSuggestionsAnalyticsTool, handleGetSuggestionsAnalytics } from './tools/get-suggestions-analytics.js';
import { checkMemoryHealthTool, handleCheckMemoryHealth } from './tools/check-memory-health.js';
import { readFileSync } from 'fs';
const args = process.argv.slice(2);
if (args.includes('--version') || args.includes('-v')) {
try {
const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
console.log(pkg.version);
process.exit(0);
}
catch (error) {
console.error('Error reading package.json:', error);
process.exit(0);
}
}
if (args.includes('--help') || args.includes('-h')) {
console.log(`
MOA MCP Server - Memory of Agents Model Context Protocol Server
Usage: moa-mcp-server [options]
Options:
-h, --help Show this help message
-v, --version Show version number
--setup Run initial setup wizard
--test Test server connection
Description:
This MCP server provides access to Memory of Agents (MOA) API endpoints
for memory management and intelligent memory querying.
Supported Tools:
Memory Management:
- store_memory: Store new memories with automatic AI processing
- list_memories: List memories with pagination
- search_memories: Basic text search across memories
- get_memory: Get specific memory by ID
- update_memory: Update memory content/metadata
- delete_memory: Delete a memory permanently
- get_memory_stats: Get memory statistics
- bulk_delete_memories: Delete multiple memories
- get_recent_memories: Get recently accessed memories
- get_memory_tags: Get all unique tags
- process_memory: Manually trigger memory processing
- export_memories: Export memories in JSON/CSV format
- get_memory_processing_status: Check processing status
- reprocess_memory: Reprocess memory with latest models
Intelligent Memory:
- query_memories: AI-powered semantic memory search
- batch_query_memories: Execute multiple queries efficiently
- get_query_suggestions: Get AI-powered query suggestions
- get_suggestions_analytics: Analytics about suggestion system
- check_memory_health: Comprehensive system health check
Environment Variables:
MOA_API_KEY - Your MOA API key (required)
MOA_BASE_URL - MOA API base URL (default: https://beta-api.memof.ai)
`);
process.exit(0);
}
if (args.includes('--setup')) {
import('./setup.js').then(() => process.exit(0));
process.exit(0);
}
async function main() {
try {
const configManager = ConfigManager.getInstance();
const config = configManager.getConfig();
const moaService = new MOAAPIService(config.moa);
if (args.includes('--test')) {
console.log('Testing MOA API connection...');
const isConnected = await moaService.testConnection();
if (isConnected) {
console.log('MOA API connection successful');
process.exit(0);
}
else {
console.error('MOA API connection failed');
process.exit(1);
}
}
const isConnected = await moaService.testConnection();
if (!isConnected) {
throw new Error('Failed to connect to MOA API. Please check your API key and network connection.');
}
const server = new Server({
name: config.server.name,
version: config.server.version,
}, {
capabilities: {
tools: {
store_memory: {
description: 'Store new memories with automatic AI processing',
},
list_memories: {
description: 'List memories with pagination and filtering',
},
search_memories: {
description: 'Basic text search across memories',
},
get_memory: {
description: 'Retrieve specific memory by ID with full details',
},
update_memory: {
description: 'Update memory content and metadata',
},
delete_memory: {
description: 'Permanently delete a memory',
},
get_memory_stats: {
description: 'Get comprehensive memory statistics and analytics',
},
bulk_delete_memories: {
description: 'Delete multiple memories at once',
},
get_recent_memories: {
description: 'Get recently accessed or created memories',
},
get_memory_tags: {
description: 'Get all unique tags from memories',
},
process_memory: {
description: 'Manually trigger memory processing with AI analysis',
},
export_memories: {
description: 'Export memories in JSON or CSV format',
},
get_memory_processing_status: {
description: 'Check processing status and progress of a memory',
},
reprocess_memory: {
description: 'Reprocess memory with latest AI models',
},
query_memories: {
description: 'Universal intelligent memory query with AI-powered understanding',
},
batch_query_memories: {
description: 'Execute multiple queries efficiently in batch',
},
get_query_suggestions: {
description: 'Get AI-powered query suggestions based on patterns',
},
get_suggestions_analytics: {
description: 'Analytics about suggestion system performance',
},
check_memory_health: {
description: 'Comprehensive health check of memory system',
},
},
},
});
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
storeMemoryTool,
listMemoriesTool,
searchMemoriesTool,
getMemoryTool,
updateMemoryTool,
deleteMemoryTool,
getMemoryStatsTool,
bulkDeleteMemoriesTool,
getRecentMemoriesTool,
getMemoryTagsTool,
processMemoryTool,
exportMemoriesTool,
getMemoryProcessingStatusTool,
reprocessMemoryTool,
queryMemoriesTool,
batchQueryMemoriesTool,
getQuerySuggestionsTool,
getSuggestionsAnalyticsTool,
checkMemoryHealthTool,
],
};
});
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
try {
switch (name) {
case 'store_memory':
return await handleStoreMemory(moaService, args);
case 'list_memories':
return await handleListMemories(moaService, args);
case 'search_memories':
return await handleSearchMemories(moaService, args);
case 'get_memory':
return await handleGetMemory(moaService, args);
case 'update_memory':
return await handleUpdateMemory(moaService, args);
case 'delete_memory':
return await handleDeleteMemory(moaService, args);
case 'get_memory_stats':
return await handleGetMemoryStats(moaService, args);
case 'bulk_delete_memories':
return await handleBulkDeleteMemories(moaService, args);
case 'get_recent_memories':
return await handleGetRecentMemories(moaService, args);
case 'get_memory_tags':
return await handleGetMemoryTags(moaService, args);
case 'process_memory':
return await handleProcessMemory(moaService, args);
case 'export_memories':
return await handleExportMemories(moaService, args);
case 'get_memory_processing_status':
return await handleGetMemoryProcessingStatus(moaService, args);
case 'reprocess_memory':
return await handleReprocessMemory(moaService, args);
case 'query_memories':
return await handleQueryMemories(moaService, args);
case 'batch_query_memories':
return await handleBatchQueryMemories(moaService, args);
case 'get_query_suggestions':
return await handleGetQuerySuggestions(moaService, args);
case 'get_suggestions_analytics':
return await handleGetSuggestionsAnalytics(moaService, args);
case 'check_memory_health':
return await handleCheckMemoryHealth(moaService, args);
default:
throw new Error(`Unknown tool: ${name}`);
}
}
catch (error) {
return {
content: [
{
type: 'text',
text: `Error executing tool ${name}: ${error.message}`,
},
],
isError: true,
};
}
});
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('MOA MCP Server running. Waiting for requests...');
}
catch (error) {
console.error('Failed to start MOA MCP Server:', error);
process.exit(1);
}
}
process.on('SIGINT', async () => {
console.error('Shutting down MOA MCP Server...');
process.exit(0);
});
process.on('SIGTERM', async () => {
console.error('Shutting down MOA MCP Server...');
process.exit(0);
});
process.on('unhandledRejection', (reason, promise) => {
console.error('Unhandled Rejection at:', promise, 'reason:', reason);
process.exit(1);
});
main().catch((error) => {
console.error('Fatal error:', error);
process.exit(1);
});