Package Exports

image-tools-mcp
image-tools-mcp/dist/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (image-tools-mcp) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Image Tools MCP

A Model Context Protocol (MCP) service for retrieving image dimensions and compressing images, supporting both URL and local file sources.

中文文档

Features

Retrieve image dimensions from URLs
Get image dimensions from local files
Compress images from URLs using TinyPNG/TinyJPG API
Compress local images using TinyPNG/TinyJPG API
Convert images to different formats (webp, jpeg/jpg, png)
Returns width, height, type, MIME type, and compression information

Installation

npm install image-tools-mcp

Usage

Using as an MCP Service

This service provides four tool functions:

get_image_size - Get dimensions of remote images
get_local_image_size - Get dimensions of local images
compress_image_from_url - Compress remote images using TinyPNG/TinyJPG API
compress_local_image - Compress local images using TinyPNG/TinyJPG API

Client Integration

To use this MCP service, you need to connect to it from an MCP client. Here are examples of how to integrate with different clients:

Using with Claude Desktop

Install Claude Desktop from claude.ai/download
Configure Claude Desktop to use this MCP server by editing the configuration file:

{
  "mcpServers": {
    "image-tools": {
      "command": "npx",
      "args": ["image-tools-mcp"],
      "env": {
        "TINIFY_API_KEY": "<YOUR_TINIFY_API_KEY>"
      }
    }
  }
}

Restart Claude Desktop
Ask Claude to get image dimensions: "Can you tell me the dimensions of this image: https://example.com/image.jpg?"

Using with MCP Client Library

import { McpClient } from "@modelcontextprotocol/client";

// Initialize the client
const client = new McpClient({
  transport: "stdio" // or other transport options
});

// Connect to the server
await client.connect();

// Get image dimensions from URL
const urlResult = await client.callTool("get_image_size", {
  options: {
    imageUrl: "https://example.com/image.jpg"
  }
});
console.log(JSON.parse(urlResult.content[0].text));
// Output: { width: 800, height: 600, type: "jpg", mime: "image/jpeg" }

// Get image dimensions from local file
const localResult = await client.callTool("get_local_image_size", {
  options: {
    imagePath: "D:/path/to/image.png"
  }
});
console.log(JSON.parse(localResult.content[0].text));
// Output: { width: 1024, height: 768, type: "png", mime: "image/png", path: "D:/path/to/image.png" }

// Compress image from URL
const compressUrlResult = await client.callTool("compress_image_from_url", {
  options: {
    imageUrl: "https://example.com/image.jpg",
    outputFormat: "webp" // Optional: convert to webp, jpeg/jpg, or png
  }
});
console.log(JSON.parse(compressUrlResult.content[0].text));
// Output: { originalSize: 102400, compressedSize: 51200, compressionRatio: "50.00%", tempFilePath: "/tmp/compressed_1615456789.webp", format: "webp" }

// Compress local image
const compressLocalResult = await client.callTool("compress_local_image", {
  options: {
    imagePath: "D:/path/to/image.png",
    outputPath: "D:/path/to/compressed.webp", // Optional
    outputFormat: "image/webp" // Optional: convert to image/webp, image/jpeg, or image/png
  }
});
console.log(JSON.parse(compressLocalResult.content[0].text));
// Output: { originalSize: 102400, compressedSize: 51200, compressionRatio: "50.00%", outputPath: "D:/path/to/compressed.webp", format: "webp" }

Tool Schemas

get_image_size

{
  options: {
    imageUrl: string // URL of the image to retrieve dimensions for
  }
}

get_local_image_size

{
  options: {
    imagePath: string // Absolute path to the local image file
  }
}

compress_image_from_url

{
  options: {
    imageUrl: string // URL of the image to compress
    outputFormat?: "webp" | "jpeg" | "jpg" | "png" // Optional output format
  }
}

compress_local_image

{
  options: {
    imagePath: string // Absolute path to the local image file
    outputPath?: string // Optional absolute path for the compressed output image
    outputFormat?: "image/webp" | "image/jpeg" | "image/jpg" | "image/png" // Optional output format
  }
}

Technical Implementation

This project is built on the following libraries:

probe-image-size - For image dimension detection
tinify - For image compression via the TinyPNG/TinyJPG API

Environment Variables

TINIFY_API_KEY - Required for image compression functionality. Get your API key from TinyPNG

License

MIT