Image Processing Shouldn't Break Your Flow

Image processing tasks are small but they interrupt everything. A designer sends over a photo that's the wrong dimensions. A client's logo is a 4MB PNG that needs to be a 40KB WebP. A product photo needs smart-cropping for a thumbnail but the subject is off-center. None of these take more than ten seconds to describe — but each one takes you out of your editor, into a terminal, into an image app, or into a back-and-forth with the designer.

With MCP, your AI assistant handles it directly. The Iteration Layer's Image Transformation API ships as an MCP server — connect it once, and Claude Code or Cursor can resize, smart crop, convert, compress, and chain up to 30 operations together from a chat prompt. You describe what you need, the assistant builds the operation sequence, and you get the result without leaving your session.

What MCP Is

Model Context Protocol is an open standard that lets AI assistants discover and call external tools. Think of it as a plugin system for AI — you connect a service, and the assistant can use it when relevant.

When you connect the Image Transformation API as an MCP server, your assistant gains the ability to:

• Resize images to specific dimensions
• Crop images (including AI-powered smart crop)
• Convert between formats (PNG, JPEG, WebP, AVIF)
• Chain up to 30 operations in a single request
• Apply filters, adjust colors, and optimize file sizes

All from a natural language prompt.

Setting Up in Claude Code

Claude Code supports MCP servers natively. Add the Iteration Layer server with a single command:

claude mcp add iterationlayer --transport http https://api.iterationlayer.com/mcp

The first time you use an Iteration Layer tool, a browser window opens for OAuth authentication. Log in, authorize access, and you're connected. No API keys to manage.

To verify the server is available, start a conversation and ask Claude Code what MCP tools it has access to. You should see transform_image listed among the available tools.

Setting Up in Cursor

Add to your .cursor/mcp.json:

{
  "mcpServers": {
    "iterationlayer": {
      "type": "http",
      "url": "https://api.iterationlayer.com/mcp"
    }
  }
}

Save and restart. The Image Transformation tool is now available in your Cursor AI conversations. Authentication works the same way — OAuth in the browser on first use.

Using It Conversationally

The strength of MCP is that you describe intent, not API parameters. The assistant translates natural language into the right combination of operations.

Resize for a landing page hero:

"Resize this to 1200x630, convert to WebP at 85% quality."

The assistant translates that into two operations — a resize with cover fit and a convert to WebP with quality 85 — and returns the processed image.

Smart crop a product photo:

"Smart crop this product photo to 400x400 — keep the product centered."

The assistant calls the smart_crop operation, which uses AI object detection to find the main subject before cropping. No coordinate math on your part.

Compress for email:

"Make this under 500KB for an email attachment."

The assistant uses the compress_to_size operation, which reduces JPEG quality first, then dimensions, to hit the target file size.

Chain multiple operations:

"Take this PNG, resize it to 800x600 cover, sharpen it slightly, convert to WebP, and make sure it's under 200KB."

That's four operations in one request — resize, sharpen, convert, and compress_to_size. The assistant chains them in the correct order.

Batch processing in conversation:

"I have five product images at these URLs. Resize each to 1000x1000 with contain fit, add a white background, and convert to JPEG at quality 90."

The assistant makes five API calls, each with three operations: resize with contain, remove_transparency with white, and convert to JPEG.

Quick format conversion:

"Convert this screenshot from PNG to AVIF."

A single convert operation. The assistant picks up the format from your description and handles the rest.

Prepare social media variants:

"I need this image as a 1080x1080 square for Instagram and a 1200x630 rectangle for Twitter, both as WebP."

The assistant makes two calls with different resize dimensions, both followed by a WebP conversion.

24 Operations, One Tool

The Image Transformation API supports 24 operations that chain sequentially. Through MCP, your assistant can combine them in a single request:

• Geometry: resize, crop, smart_crop, extend, trim, rotate, flip, flop
• Color: modulate (brightness/saturation/hue), tint, grayscale, invert_colors, auto_contrast, gamma
• Quality: blur, sharpen, denoise, threshold, opacity
• Output: convert (format + quality), compress_to_size, upscale (2x/3x/4x)
• Transparency: remove_transparency

Each operation's output feeds into the next, so "resize then convert then compress" is one API call with three operations. The 30-operation limit is generous — most real tasks need three to five.

What Happens Under the Hood

When you describe an image transformation in natural language, the assistant doesn't just forward your text to the API. It constructs a structured API request with the correct operation types, parameters, and ordering.

For example, when you say "resize this to 800x600 and convert to WebP," the assistant builds:

{
  "file": {
    "type": "url",
    "name": "image.jpg",
    "url": "https://...",
  },
  "operations": [
    {
        "type": "resize",
        "width_in_px": 800,
        "height_in_px": 600,
        "fit": "cover",
    },
    {
        "type": "convert",
        "format": "webp",
        "quality": 85,
    }
  ]
}

The assistant makes decisions you didn't specify: it picks cover as the default fit strategy (the most common choice), sets quality to 85 (a sensible default for web images), and orders the operations correctly (resize before convert). If you need different defaults — contain instead of cover, or quality 75 instead of 85 — just say so, and the assistant adjusts.

The MCP server handles authentication, request formatting, and response parsing. The assistant receives the processed image back and can display it in the conversation, save it to a file, or pass it to the next step in your workflow.

Real Workflows Where MCP Shines

During development. You're building a product page and need placeholder images at specific dimensions. Instead of opening Figma or Photoshop, describe the size you need and the assistant transforms the source image on the spot.

Code review with visuals. A PR includes new image assets. Ask the assistant to check the dimensions, convert to the right format, or verify the file size meets your budget — all without leaving the review.

Content creation. You're writing documentation and need to include screenshots. The assistant can resize them to a consistent width, convert to WebP for the web, and sharpen them after downscaling.

Quick fixes. A client emails an image that's too large, the wrong format, or needs a transparent background removed. Describe what you need, and the assistant handles it in seconds.

When to Use MCP vs the API Directly

MCP is ideal for ad-hoc work — resizing an image during development, converting a screenshot, quick-cropping a photo. The assistant handles the API details so you stay focused on your work.

For production pipelines — processing uploads at scale, generating thumbnails for a CMS, optimizing images for a CDN — use the API directly via the TypeScript or Python SDK. The SDK gives you full control over error handling, retries, and integration with your existing codebase.

The dividing line is automation. If you're doing it once or a few times interactively, MCP saves time. If you're doing it thousands of times as part of an automated workflow, the SDK is the right tool.

Get Started

Sign up for a free account at iterationlayer.com — no credit card required. Run the claude mcp add command above, authenticate in the browser, and start transforming images from your next Claude Code or Cursor conversation.

The docs cover every operation, every parameter, and every output format. Start with a simple resize — it's the fastest way to see how conversational image transformation works.