Optimized Memory MCP Server V2

MIT License
Overview InspectNew Schema Related Servers Reviews Score
src/index.ts
#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
	CallToolRequestSchema,
	ErrorCode,
	ListToolsRequestSchema,
	ListResourcesRequestSchema,
	ListResourceTemplatesRequestSchema,
	ReadResourceRequestSchema,
	McpError,
} from "@modelcontextprotocol/sdk/types.js";
import sharp from "sharp";
import { promises as fs } from "fs";
import path from "path";
import sizeOf from "image-size";
import { promisify } from "util";

const sizeOfAsync = promisify(sizeOf);

interface ProcessingResult {
	originalSize: number;
	optimizedSize: number;
	originalFormat: string;
	newFormat: string;
	resolution: string;
	enhancements: string[];
	outputPath: string;
}

export class ImageProcessorServer {
	private server: Server;
	private readonly supportedFormats = [".jpg", ".jpeg", ".png"];

	constructor() {
		this.server = new Server(
			{
				name: "webperfect",
				version: "1.0.0",
			},
			{
				capabilities: {
					tools: {},
					resources: {},
				},
			}
		);

		this.setupToolHandlers();
		this.setupResourceHandlers();

		this.server.onerror = (error) => console.error("[MCP Error]", error);
		process.on("SIGINT", async () => {
			await this.server.close();
			process.exit(0);
		});
	}

	private async processImage(
		inputPath: string,
		outputDir: string,
		progressCallback: (message: string) => void
	): Promise<ProcessingResult> {
		const filename = path.basename(inputPath);
		progressCallback(`Processing ${filename}...`);

		try {
			// Read original file info
			const originalStats = await fs.stat(inputPath);
			const originalSize = originalStats.size;
			const originalFormat = path.extname(inputPath).toLowerCase().slice(1);

			// Create output directory if it doesn't exist
			await fs.mkdir(outputDir, { recursive: true });

			// Initialize sharp pipeline
			let pipeline = sharp(inputPath);
			const enhancements: string[] = [];

			// Get image metadata and stats
			const metadata = await pipeline.metadata();
			const stats = await pipeline.stats();

			// Step 1: Strong noise reduction
			pipeline = pipeline.median(5);
			enhancements.push("noise_reduction");

			// Step 2: Auto levels and curves
			pipeline = pipeline.normalise().linear(
				stats.entropy < 0.7 ? 1.2 : 0.9, // Brightness adjustment
				stats.entropy < 0.7 ? -0.1 : 0.1 // Contrast adjustment
			);
			enhancements.push("auto_levels_curves");

			// Step 3: Texture enhancement
			pipeline = pipeline
				.modulate({
					brightness: 1.1,
					saturation: 1.1,
				})
				.sharpen({
					sigma: 0.8,
					m1: 0.3,
					m2: 0.5,
				});
			enhancements.push("texture_enhancement");

			// Step 4: Scale to target resolution
			// Default to 1920 if width is undefined
			const baseWidth = metadata.width || 1920;
			const targetWidth = baseWidth > 1920 ? 3840 : 1920;
			const targetHeight = metadata.height
				? Math.round(metadata.height * (targetWidth / baseWidth))
				: Math.round(targetWidth * 0.75); // 4:3 aspect ratio as fallback

			pipeline = pipeline.resize(targetWidth, targetHeight, {
				fit: "inside",
				withoutEnlargement: true,
				kernel: "lanczos3",
			});
			enhancements.push("resolution_optimization");

			// Save as WebP with optimized settings
			const outputFilename = `${path.basename(
				inputPath,
				path.extname(inputPath)
			)}.webp`;
			const outputPath = path.join(outputDir, outputFilename);

			await pipeline
				.webp({
					quality: 85,
					effort: 6,
					smartSubsample: true,
					nearLossless: false,
				})
				.toFile(outputPath);

			const optimizedStats = await fs.stat(outputPath);
			progressCallback(`Completed ${filename}`);

			return {
				originalSize,
				optimizedSize: optimizedStats.size,
				originalFormat,
				newFormat: "webp",
				resolution: `${targetWidth}x${targetHeight}`,
				enhancements,
				outputPath,
			};
		} catch (error) {
			throw new McpError(
				ErrorCode.InternalError,
				`Failed to process ${filename}: ${
					error instanceof Error ? error.message : String(error)
				}`
			);
		}
	}

	private setupToolHandlers() {
		this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
			tools: [
				{
					name: "process_images",
					description: "Process and optimize a batch of images",
					inputSchema: {
						type: "object",
						properties: {
							inputDir: {
								type: "string",
								description: "Directory containing input images",
							},
							outputDir: {
								type: "string",
								description: "Directory for optimized images",
							},
						},
						required: ["inputDir", "outputDir"],
					},
				},
			],
		}));

		this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
			if (request.params.name !== "process_images") {
				throw new McpError(
					ErrorCode.MethodNotFound,
					`Unknown tool: ${request.params.name}`
				);
			}

			const { inputDir, outputDir } = request.params.arguments as {
				inputDir: string;
				outputDir: string;
			};

			try {
				// Get all image files
				const files = await fs.readdir(inputDir);
				const imageFiles = files.filter((file) => {
					const ext = path.extname(file).toLowerCase();
					return this.supportedFormats.includes(ext);
				});

				console.log(`Found ${imageFiles.length} images to process`);

				// Process all images
				const results: ProcessingResult[] = [];
				for (const file of imageFiles) {
					try {
						const result = await this.processImage(
							path.join(inputDir, file),
							outputDir,
							(message) => console.log(message)
						);
						results.push(result);
					} catch (err) {
						console.error(`Error processing ${file}:`, err);
					}
				}

				// Generate summary report
				const summary = {
					totalFiles: results.length,
					totalOriginalSize: `${(
						results.reduce((sum, r) => sum + r.originalSize, 0) /
						1024 /
						1024
					).toFixed(2)}MB`,
					totalOptimizedSize: `${(
						results.reduce((sum, r) => sum + r.optimizedSize, 0) /
						1024 /
						1024
					).toFixed(2)}MB`,
					details: results.map((r) => ({
						file: path.basename(r.outputPath),
						originalFormat: r.originalFormat,
						originalSize: `${(r.originalSize / 1024).toFixed(2)}KB`,
						optimizedSize: `${(r.optimizedSize / 1024).toFixed(2)}KB`,
						resolution: r.resolution,
						enhancements: r.enhancements,
					})),
				};

				// Save processing log
				const logPath = path.join(outputDir, "processing-log.json");
				await fs.writeFile(logPath, JSON.stringify(summary, null, 2));

				return {
					content: [
						{
							type: "text",
							text: JSON.stringify(summary, null, 2),
						},
					],
				};
			} catch (error) {
				throw new McpError(
					ErrorCode.InternalError,
					`Processing failed: ${
						error instanceof Error ? error.message : String(error)
					}`
				);
			}
		});
	}

	private setupResourceHandlers() {
		// Resource template for accessing processing logs by date
		this.server.setRequestHandler(
			ListResourceTemplatesRequestSchema,
			async () => ({
				resourceTemplates: [
					{
						uriTemplate: "logs/{date}",
						name: "Processing logs by date",
						description:
							"Access image processing logs for a specific date (YYYY-MM-DD format)",
						mimeType: "application/json",
					},
					{
						uriTemplate: "stats/monthly/{month}",
						name: "Monthly processing statistics",
						description:
							"Get image processing statistics for a specific month (YYYY-MM format)",
						mimeType: "application/json",
					},
				],
			})
		);

		// Static resources for overall statistics
		this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
			resources: [
				{
					uri: "stats/summary",
					name: "Processing statistics summary",
					description:
						"Overall image processing statistics and performance metrics",
					mimeType: "application/json",
				},
				{
					uri: "config/optimization-presets",
					name: "Optimization presets",
					description:
						"Available image optimization presets and their settings",
					mimeType: "application/json",
				},
			],
		}));

		// Resource content handler
		this.server.setRequestHandler(
			ReadResourceRequestSchema,
			async (request) => {
				const { uri } = request.params;

				// Handle log requests by date
				const logMatch = uri.match(/^logs\/(\d{4}-\d{2}-\d{2})$/);
				if (logMatch) {
					const date = logMatch[1];
					return {
						contents: [
							{
								uri,
								mimeType: "application/json",
								text: JSON.stringify(
									{
										date,
										entries: [
											{
												timestamp: `${date}T10:00:00Z`,
												imagesProcessed: 15,
												totalInputSize: "5.2MB",
												totalOutputSize: "1.1MB",
												compressionRatio: "78.8%",
												averageProcessingTime: "1.2s",
											},
										],
									},
									null,
									2
								),
							},
						],
					};
				}

				// Handle monthly statistics
				const monthMatch = uri.match(/^stats\/monthly\/(\d{4}-\d{2})$/);
				if (monthMatch) {
					const month = monthMatch[1];
					return {
						contents: [
							{
								uri,
								mimeType: "application/json",
								text: JSON.stringify(
									{
										month,
										totalImagesProcessed: 450,
										averageCompressionRatio: "82%",
										popularFormats: {
											input: ["JPEG", "PNG"],
											output: ["WebP"],
										},
										totalStorageSaved: "150MB",
									},
									null,
									2
								),
							},
						],
					};
				}

				// Handle summary statistics
				if (uri === "stats/summary") {
					return {
						contents: [
							{
								uri,
								mimeType: "application/json",
								text: JSON.stringify(
									{
										totalImagesProcessed: 5280,
										averageCompressionRatio: "81%",
										totalStorageSaved: "1.8GB",
										popularEnhancements: [
											"noise_reduction",
											"auto_levels_curves",
											"texture_enhancement",
										],
										performanceMetrics: {
											averageProcessingTime: "1.5s",
											peakThroughput: "45 images/minute",
										},
									},
									null,
									2
								),
							},
						],
					};
				}

				// Handle optimization presets
				if (uri === "config/optimization-presets") {
					return {
						contents: [
							{
								uri,
								mimeType: "application/json",
								text: JSON.stringify(
									{
										presets: {
											web_standard: {
												maxWidth: 1920,
												format: "webp",
												quality: 85,
												enhancements: ["noise_reduction", "auto_levels_curves"],
											},
											web_high_quality: {
												maxWidth: 3840,
												format: "webp",
												quality: 90,
												enhancements: [
													"noise_reduction",
													"auto_levels_curves",
													"texture_enhancement",
												],
											},
											thumbnail: {
												maxWidth: 400,
												format: "webp",
												quality: 80,
												enhancements: ["noise_reduction"],
											},
										},
									},
									null,
									2
								),
							},
						],
					};
				}

				throw new McpError(
					ErrorCode.InvalidRequest,
					`Resource not found: ${uri}`
				);
			}
		);
	}

	async processImages({
		inputDir,
		outputDir,
	}: {
		inputDir: string;
		outputDir: string;
	}) {
		try {
			// Get all image files
			const files = await fs.readdir(inputDir);
			const imageFiles = files.filter((file) => {
				const ext = path.extname(file).toLowerCase();
				return this.supportedFormats.includes(ext);
			});

			console.log(`Found ${imageFiles.length} images to process`);

			// Process all images
			const results: ProcessingResult[] = [];
			for (const file of imageFiles) {
				try {
					const result = await this.processImage(
						path.join(inputDir, file),
						outputDir,
						(message) => console.log(message)
					);
					results.push(result);
				} catch (err) {
					console.error(`Error processing ${file}:`, err);
				}
			}

			// Generate summary report
			const summary = {
				totalFiles: results.length,
				totalOriginalSize: `${(
					results.reduce((sum, r) => sum + r.originalSize, 0) /
					1024 /
					1024
				).toFixed(2)}MB`,
				totalOptimizedSize: `${(
					results.reduce((sum, r) => sum + r.optimizedSize, 0) /
					1024 /
					1024
				).toFixed(2)}MB`,
				details: results.map((r) => ({
					file: path.basename(r.outputPath),
					originalFormat: r.originalFormat,
					originalSize: `${(r.originalSize / 1024).toFixed(2)}KB`,
					optimizedSize: `${(r.optimizedSize / 1024).toFixed(2)}KB`,
					resolution: r.resolution,
					enhancements: r.enhancements,
				})),
			};

			// Save processing log
			const logPath = path.join(outputDir, "processing-log.json");
			await fs.writeFile(logPath, JSON.stringify(summary, null, 2));

			return summary;
		} catch (error) {
			throw new McpError(
				ErrorCode.InternalError,
				`Processing failed: ${
					error instanceof Error ? error.message : String(error)
				}`
			);
		}
	}

	async run() {
		const transport = new StdioServerTransport();
		await this.server.connect(transport);
		console.error("WebPerfect MCP Server running on stdio");
	}
}

const server = new ImageProcessorServer();
server.run().catch(console.error);