mem100x
Version:
⚡ The FASTEST MCP memory server ever built - 66k+ entities/sec with intelligent context detection
279 lines • 11.1 kB
JavaScript
;
/**
* Tool handlers for MCP server
* Separates tool logic from server setup for better maintainability
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.toolHandlers = void 0;
exports.handleSetContext = handleSetContext;
exports.handleGetContextInfo = handleGetContextInfo;
exports.handleCreateEntities = handleCreateEntities;
exports.handleSearchNodes = handleSearchNodes;
exports.handleReadGraph = handleReadGraph;
exports.handleOpenNodes = handleOpenNodes;
exports.handleCreateRelations = handleCreateRelations;
exports.handleDeleteRelations = handleDeleteRelations;
exports.handleAddObservations = handleAddObservations;
exports.handleDeleteObservations = handleDeleteObservations;
exports.handleDeleteEntities = handleDeleteEntities;
exports.handleBeginTransaction = handleBeginTransaction;
exports.handleCommitTransaction = handleCommitTransaction;
exports.handleRollbackTransaction = handleRollbackTransaction;
exports.handleCreateBackup = handleCreateBackup;
exports.handleRestoreBackup = handleRestoreBackup;
exports.handleGetNeighbors = handleGetNeighbors;
exports.handleFindShortestPath = handleFindShortestPath;
const tool_schemas_js_1 = require("./tool-schemas.js");
// Context management handlers
function handleSetContext(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.set_context.parse(args);
const message = ctx.manager.setContext(validated.context);
return { message };
}
function handleGetContextInfo(args, ctx) {
tool_schemas_js_1.toolSchemas.get_context_info.parse(args); // Validate empty object
return ctx.manager.getContextInfo();
}
// Entity operation handlers
function handleCreateEntities(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.create_entities.parse(args);
const created = ctx.manager.createEntities(validated.entities, validated.context);
const duration = performance.now() - ctx.startTime;
const rate = Math.round(validated.entities.length / (duration / 1000));
return {
created,
performance: {
duration: `${duration.toFixed(2)}ms`,
rate: `${rate} entities/sec`,
},
};
}
function handleSearchNodes(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.search_nodes.parse(args);
const results = ctx.manager.searchNodes(validated);
const duration = performance.now() - ctx.startTime;
return {
...results,
performance: {
duration: `${duration.toFixed(2)}ms`,
resultCount: results.entities.length,
},
};
}
function handleReadGraph(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.read_graph.parse(args);
const graph = ctx.manager.readGraph(validated.limit, validated.offset || 0, validated.context);
const duration = performance.now() - ctx.startTime;
return {
...graph,
performance: {
duration: `${duration.toFixed(2)}ms`,
entityCount: graph.entities.length,
relationCount: graph.relations.length,
},
};
}
function handleOpenNodes(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.open_nodes.parse(args);
const result = ctx.manager.openNodes(validated.names);
const duration = performance.now() - ctx.startTime;
return {
...result,
performance: {
duration: `${duration.toFixed(2)}ms`,
entitiesFound: result.entities.length,
relationsFound: result.relations.length,
},
};
}
// Relation operation handlers
function handleCreateRelations(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.create_relations.parse(args);
const created = ctx.manager.createRelations(validated.relations);
const duration = performance.now() - ctx.startTime;
return {
created,
performance: {
duration: `${duration.toFixed(2)}ms`,
rate: `${Math.round(validated.relations.length / (duration / 1000))} relations/sec`,
},
};
}
function handleDeleteRelations(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.delete_relations.parse(args);
ctx.manager.deleteRelations(validated.relations);
const duration = performance.now() - ctx.startTime;
return {
success: true,
relationsDeleted: validated.relations.length,
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
// Observation operation handlers
function handleAddObservations(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.add_observations.parse(args);
ctx.manager.addObservations(validated.observations);
const duration = performance.now() - ctx.startTime;
return {
success: true,
observationsAdded: validated.observations.length,
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
function handleDeleteObservations(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.delete_observations.parse(args);
ctx.manager.deleteObservations(validated.deletions);
const duration = performance.now() - ctx.startTime;
return {
success: true,
deletionsProcessed: validated.deletions.length,
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
// Entity deletion handler
function handleDeleteEntities(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.delete_entities.parse(args);
ctx.manager.deleteEntities(validated.entityNames);
const duration = performance.now() - ctx.startTime;
return {
success: true,
entitiesDeleted: validated.entityNames.length,
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
// Transaction handlers
function handleBeginTransaction(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.begin_transaction.parse(args);
const transactionId = ctx.manager.beginTransaction(validated.name);
const duration = performance.now() - ctx.startTime;
return {
success: true,
transactionId,
message: `Transaction ${transactionId} started`,
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
function handleCommitTransaction(args, ctx) {
tool_schemas_js_1.toolSchemas.commit_transaction.parse(args); // Validate empty object
ctx.manager.commitTransaction();
const duration = performance.now() - ctx.startTime;
return {
success: true,
message: 'Transaction committed successfully',
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
function handleRollbackTransaction(args, ctx) {
tool_schemas_js_1.toolSchemas.rollback_transaction.parse(args); // Validate empty object
ctx.manager.rollbackTransaction();
const duration = performance.now() - ctx.startTime;
return {
success: true,
message: 'Transaction rolled back successfully',
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
// Backup and restore handlers
function handleCreateBackup(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.create_backup.parse(args);
const backupInfo = ctx.manager.createBackup(validated.backupPath || '', // Empty string will be handled by the manager
validated.context || ctx.manager.currentContext);
const duration = performance.now() - ctx.startTime;
return {
success: true,
backupPath: backupInfo.path,
size: backupInfo.size,
context: backupInfo.context,
timestamp: backupInfo.timestamp,
message: `Backup created successfully at ${backupInfo.path}`,
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
function handleRestoreBackup(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.restore_backup.parse(args);
if (!validated.confirmRestore) {
throw new Error('Restore operation must be confirmed by setting confirmRestore to true');
}
const restoreInfo = ctx.manager.restoreBackup(validated.backupPath, validated.context ?? ctx.manager.currentContext);
const duration = performance.now() - ctx.startTime;
return {
success: true,
restoredFrom: restoreInfo.backupPath,
context: restoreInfo.context,
entitiesRestored: restoreInfo.stats.entityCount,
relationsRestored: restoreInfo.stats.relationCount,
message: `Database restored successfully from ${restoreInfo.backupPath}`,
performance: { duration: `${duration.toFixed(2)}ms` },
};
}
// Graph traversal handlers
function handleGetNeighbors(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.get_neighbors.parse(args);
const result = ctx.manager.getNeighbors(validated.entityName, {
direction: validated.direction || 'both',
relationType: validated.relationType,
depth: validated.depth || 1,
includeRelations: validated.includeRelations !== false,
context: validated.context
});
const duration = performance.now() - ctx.startTime;
return {
...result,
performance: {
duration: `${duration.toFixed(2)}ms`,
nodesVisited: result.entities.length,
relationsFound: result.relations?.length || 0,
depth: validated.depth || 1
},
};
}
function handleFindShortestPath(args, ctx) {
const validated = tool_schemas_js_1.toolSchemas.find_shortest_path.parse(args);
const result = ctx.manager.findShortestPath(validated.from, validated.to, {
bidirectional: validated.bidirectional !== false,
relationType: validated.relationType,
maxDepth: validated.maxDepth || 6,
context: validated.context
});
const duration = performance.now() - ctx.startTime;
return {
found: result.found,
path: result.path,
distance: result.distance,
performance: {
duration: `${duration.toFixed(2)}ms`,
nodesExplored: result.nodesExplored || 0,
pathLength: result.distance
},
};
}
// Tool handler registry
exports.toolHandlers = {
// Context management
'set_context': handleSetContext,
'get_context_info': handleGetContextInfo,
// Entity operations
'create_entities': handleCreateEntities,
'search_nodes': handleSearchNodes,
'read_graph': handleReadGraph,
'open_nodes': handleOpenNodes,
// Relation operations
'create_relations': handleCreateRelations,
'delete_relations': handleDeleteRelations,
// Observation operations
'add_observations': handleAddObservations,
'delete_observations': handleDeleteObservations,
// Entity deletion
'delete_entities': handleDeleteEntities,
// Transaction management
'begin_transaction': handleBeginTransaction,
'commit_transaction': handleCommitTransaction,
'rollback_transaction': handleRollbackTransaction,
// Backup and restore
'create_backup': handleCreateBackup,
'restore_backup': handleRestoreBackup,
// Graph traversal
'get_neighbors': handleGetNeighbors,
'find_shortest_path': handleFindShortestPath,
};
//# sourceMappingURL=tool-handlers.js.map