# Claude Computer Use Coordinate Normalizer MCP for AI Agents MCP

> Claude Computer Use Coordinate Normalizer handles the math of mapping any screen resolution to the fixed 1024x768 viewport required by Anthropic's computer use API. It ensures your agent clicks exactly where it thinks it is, regardless of whether you are running on a 4K monitor or a standard laptop screen.

## Overview
- **Category:** automation
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_x4tE2envbthgS5K9zuOTSJF7s4loqDzmPj6LxQsU/mcp
- **Tags:** anthropic, computer-use, coordinate-normalization, viewport, automation-tools

## Description

When you build agents that interact with a desktop, the biggest headache is resolution mismatch. You might see an icon at a specific pixel on your 1440p monitor, but your agent sees a completely different coordinate space because it's locked into a fixed viewport. This MCP fixes that by acting as a translation layer. It takes any raw screen coordinate and converts it into the standardized format the API expects. You don't have to write custom scaling logic or worry about boundary errors every time you change your testing environment. By connecting this through Vinkius, you get a reliable way to ensure your agent's clicks, drags, and typing happen at the precise pixel intended. It handles all the proportional math and keeps everything within the target boundaries so your automation doesn't miss its mark.

## Tools

### get_viewport_constants
Provides the fixed width and height boundaries required by the API. This ensures your agent always knows the target limits.

### verify_dimensions
Checks that your input resolution is valid and greater than zero. It prevents errors caused by invalid screen data.

### calculate_coordinate
Converts raw pixel locations into the standardized 1024x768 viewport space. It handles all the proportional scaling math for you.

## Prompt Examples

**Prompt:** 
```
I'm looking at a 4K screen and want to click the center. What coordinates should I use?
```

**Response:** 
```
For a 3840x2160 resolution, the normalized viewport coordinates are:

| Axis | Value |
| :--- | :--- |
| **X** | 512 |
| **Y** | 384 |
```

**Prompt:** 
```
Is this resolution valid for processing?
```

**Response:** 
```
The resolution **0x0** is invalid. All dimensions must be greater than zero to perform coordinate mapping.
```

**Prompt:** 
```
undefined
```

**Response:** 
```
undefined
```

**Prompt:** 
```
undefined
```

**Response:** 
```
undefined
```

## Capabilities

### Map screen pixels to viewport space
Converts any raw resolution into the standardized 1024x768 format.

### Validate display dimensions
Checks that your input resolution is valid and greater than zero.

### Access standard API constants
Retrieves the fixed width and height boundaries needed for accurate mapping.

### Prevent out-of-bounds clicks
Clamps coordinates so they stay within the active viewport area.

## Use Cases

### Testing on different hardware
You need to run an agent on a laptop and a 4K workstation, so you use calculate_coordinate to keep clicks consistent.

### Automating web browsers
An agent needs to click a button at a specific pixel, and this MCP ensures the coordinate is correctly scaled for the API viewport.

### UI Regression Testing
You want to verify that an element hasn't moved, using get_viewport_constants to check against known boundaries.

## Benefits

- Eliminate coordinate drift by using calculate_coordinate for every interaction.
- Stop your agent from clicking outside the bounds with automatic boundary clamping.
- Ensure consistent behavior across 1080p, 4K, and ultra-wide monitors.
- Simplify your automation logic by offloading all scaling math to this MCP.
- Avoid runtime errors using verify_dimensions to validate screen inputs before processing.

## How It Works

The bottom line is that your agent's clicks will finally land where they are supposed to on the target viewport.

1. Connect your preferred AI client to this MCP via Vinkius.
2. Provide the raw pixel coordinates and the source screen resolution.
3. The agent receives the precisely mapped 1024x768 viewport coordinates.

## Frequently Asked Questions

**What does the `calculate_coordinate` tool do?**
It takes your screen width, height, and target X/Y pixels to calculate the corresponding normalized coordinates within the 1024x768 space.

**How does it handle coordinates outside the screen?**
The server uses clamping logic to ensure all returned values stay within the 0-1024 and 0-768 boundaries, preventing interaction errors.

**Can I use this for any resolution?**
Yes, as long as you provide the source screen width and height, the tool will calculate the correct proportional mapping.