Image Edit Rmcp

🚀 Image Edit RMCP - Image Editing MCP Service

This project provides an MCP (Model Context Protocol) service similar to OpenAI's image editing function, enabling traditional language models to understand and process image content through image recognition and description.

🚀 Quick Start

This Image Edit RMCP service offers a range of image processing and AI - related functions. To quickly start using it, you can refer to the experience addresses and usage tutorials below.

✨ Features

Image Processing Functions

• Image Content Recognition: Analyze image content and generate descriptions using the Qwen3 - VL model.
• Image Cropping: Crop images by percentage coordinates.
• Image Rotation: Support 90° left rotation, 90° right rotation, and 180° flipping.
• Basic Image Information Retrieval: Obtain image size, format, and other information.
• Image OCR: Extract text content from images.
• AI Image Generation: Generate images based on text descriptions.
• AI Image Editing: Edit existing images based on text instructions.

Simple Image Hosting

It has built - in image upload and storage functions, supporting access to processed images via URL.

API Key Generation

Provide an interface for API key generation and management.

📦 Installation

Environment Requirements

• Rust 1.76 or higher
• Docker (optional, for containerized deployment)
• ModelScope API key (for AI functions)

Cargo Deployment (Recommended)

1. Install Rust

# Install Rust using rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Or install from the system package manager
# macOS: brew install rust
# Ubuntu/Debian: sudo apt install rustc cargo

2. Configure Environment Variables

Copy the environment variable template and configure your API key:

cp .env.example .env

Edit the .env file:

# ModelScope API key (required)
MODELSCOPE_API_KEY=your_api_key_here

# Server port
MCP_PORT=3000

# Security key (for image hosting upload)
SECRET_KEY=your_secret_key_here

# Cache directory
CACHE_DIR=~/.cache/image-edit-rmcp

# Cache URL (for generating public access links)
CACHE_URL=http://localhost:3000

3. Start the Project

# Clone the project (if not already cloned)
# git clone <repository-url>
# cd image-edit-rmcp

# Install dependencies and build
cargo build --release

# Run the service
cargo run --release

The service will start at http://localhost:3000. Use http://localhost:3000/{SECRET_KEY}/mcp to access the MCP service.

💻 Usage Examples

CherryStudio Integration

⚠️ Important Note

You need to enable the long - running mode. The AI image generation function takes a long time, so please be patient when using it.

Best Practices

1. Upload the image to be processed through the image hosting and obtain the URL.
2. Pass the URL of the image to be processed to the model via the prompt.

Image Content Recognition

Prompt:

https://muse-ai.oss-cn-hangzhou.aliyuncs.com/img/fd7409815bb94bddba84191e21a803a2.png
View this image

Image Content Cropping

Prompt:

https://muse-ai.oss-cn-hangzhou.aliyuncs.com/img/fd7409815bb94bddba84191e21a803a2.png
Crop out the sun in the image
Show the original image and the cropped result after cropping

Image Text Extraction

Prompt:

https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-Image/image2512/arena.png#center
Recognize the text in the image
And show the image

🔧 Technical Details

Tool Introduction

1. fetch_image - Get an Image from a URL

Function: Download an image from a specified URL, analyze the image content, and generate a description. Input Parameters:

• url (string): Image URL (required)
• focus (string, optional): Content that needs special attention

Output:

• Image URL
• Image name
• MIME type
• Image description text

2. rotate_image - Rotate an Image

Function: Rotate an image in the specified direction. Input Parameters:

• url (string): Image URL (required)
• direction (enum): Rotation direction, optional values:
  • Right90: Rotate 90° clockwise
  • Left90: Rotate 90° counter - clockwise
  • Flip180: Rotate 180°

Output:

• URL of the rotated image (PNG format)

3. crop_image - Crop an Image

Function: Crop an image by percentage coordinates. Input Parameters:

• url (string): Image URL (required)
• left (float, optional): Left percentage (0 - 100), default 0
• top (float, optional): Top percentage (0 - 100), default 0
• right (float, optional): Right percentage (0 - 100), default 100
• bottom (float, optional): Bottom percentage (0 - 100), default 100

Output:

• URL of the cropped image (PNG format)

4. get_image_info - Get Image Information

Function: Get the basic information of an image. Input Parameters:

• url (string): Image URL (required)

Output:

• width: Image width (pixels)
• height: Image height (pixels)
• total_pixels: Total number of pixels
• mime_type: MIME type
• size: File size (bytes)
• aspect_ratio: Aspect ratio (optional)

5. ocr_extract - OCR Text Extraction

Function: Extract text content from an image. Input Parameters:

• image_url (string): Image URL (required)

Output:

• Extracted text content

6. generate_image - AI Image Generation

Function: Generate an image based on a text description. Input Parameters:

• prompt (string): Image description (required)
• negative_prompt (string, optional): Content that is not desired to appear
• aspect_ratio (string, optional): Aspect ratio, optional values: 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, default 1:1
• resolution (string, optional): Resolution, optional values: 1k, 2k, 4k, default 1k
• steps (u32, optional): Sampling steps

Output:

• URL of the generated image

7. edit_image - AI Image Editing

Function: Edit an existing image based on text instructions. Input Parameters:

• image_url (string): URL of the image to be edited (required)
• prompt (string): Editing instructions (required)
• size (string, optional): Output image size
• steps (u32, optional): Sampling steps

Output:

• URL of the edited image

Tool Implementation

Technology Stack

• Backend Framework: Rust + Axum + RMCP
• Image Processing: image library (supports PNG, JPEG, GIF, BMP, WebP)
• AI Integration: ModelScope API (Qwen3 - VL, Z - Image - Turbo, Qwen - Image - Edit)
• Cache System: Local file cache, supporting HTTP access
• Web Interface: Axum static file service + HTML template

Core Implementation Principles

1. Image Processing Flow:
   • Receive HTTP URL input.
   • Download the image to memory.
   • Decode and process (rotate, crop) the image using the image library.
   • Encode the image into PNG format for output.
   • Cache the processing result to the local file system.
2. AI Function Integration:
   • Image Recognition: Call the ModelScope Qwen3 - VL model to analyze image content.
   • OCR Extraction: Use the Qwen3 - VL model to extract text from images.
   • Image Generation: Use the Z - Image - Turbo model to generate images based on text.
   • Image Editing: Use the Qwen - Image - Edit model to edit images based on instructions.
3. Cache Mechanism:
   • Calculate the hash value based on the URL and parameters.
   • Store the processing result in the local cache directory.
   • Provide public access to the cached files through the HTTP service.
   • Support the storage of metadata (image information, descriptions, etc.).
4. MCP Protocol Integration:
   • Implement the ServerHandler of the RMCP protocol.
   • Provide a standard tool call interface.
   • Support the httpstream transmission protocol.

Dependencies

The main dependencies (see Cargo.toml):

• rmcp: MCP protocol implementation
• axum: Web framework
• image: Image processing
• reqwest: HTTP client
• serde: JSON serialization
• tokio: Asynchronous runtime

📚 Documentation

Experience Addresses

• MCP Connection Address: https://image.cd.actrue.cn/kB7XMqsX31s90JPV/mcp (httpstream)
• Image Hosting Address: https://image.cd.actrue.cn/kB7XMqsX31s90JPV/upload
• API Key Generation Address: https://image.cd.actrue.cn/secret