appletv-mcp

<!-- mcp-name: io.github.trevor-nichols/appletv-mcp -->

# Apple TV MCP: A local MCP server that lets AI agents control — and see — your Apple TV

<p align="center">
  <img
    src="docs/assets/apple-tv-mcp-hero.png"
    alt="Apple TV MCP — AI control and visual navigation for Apple TV"
    width="100%"
  />
</p>

Open apps, navigate tvOS, control playback, type searches, adjust volume, manage power, and take screenshots so a multimodal agent can actually inspect what happened.

```text
You:
Open YouTube and search for OpenAI.

Agent:
→ opens YouTube
→ takes a screenshot
→ sees the current interface
→ navigates to Search
→ types "OpenAI"
→ takes another screenshot
→ verifies the results
```

Apple TV MCP turns your Apple TV into a locally controlled, visually observable device for MCP-capable AI agents.

No hosted backend. No custom Apple TV app. No cloud account.

---

## Why Apple TV MCP?

Most Apple TV automation is blind.

A script can press Right or Select, but it usually has no idea what appeared on the screen afterward.

Apple TV MCP combines **semantic control** with **point-in-time visual observation**.

| Traditional Apple TV automation  | Apple TV MCP                                                |
| -------------------------------- | ----------------------------------------------------------- |
| Send blind remote commands       | Take screenshots between actions                            |
| Build app-specific scripts       | Navigate arbitrary tvOS interfaces                          |
| Guess whether an action worked   | Inspect the screen and verify                               |
| Custom integration per AI system | Standard MCP tool interface                                 |
| Remote commands only             | Apps, playback, text, power, volume, navigation, and vision |

The result is a feedback loop an AI agent can actually use:

```text
screenshot
    ↓
model sees tvOS
    ↓
chooses an action
    ↓
press / type / open
    ↓
screenshot again
    ↓
verify
```

Semantic tools are still preferred whenever possible. Screenshots make the difference when the task requires navigating an interface that does not expose a direct API.

---

## Install in seconds

Apple TV MCP requires Python 3.14.

### Recommended

```bash
uv tool install appletv-mcp
```

Or:

```bash
pipx install appletv-mcp
```

Then pair your Apple TV:

```bash
atvremote wizard
```

Configure Apple TV MCP:

```bash
appletv-mcp configure
```

Check the setup:

```bash
appletv-mcp doctor
```

And start the MCP server:

```bash
appletv-mcp serve
```

### From source

```bash
git clone https://github.com/trevor-nichols/appletv-mcp.git
cd appletv-mcp
uv sync --locked
uv run appletv-mcp configure
uv run appletv-mcp doctor
uv run appletv-mcp serve
```

---

## What can it do?

Apple TV MCP exposes fourteen tools grouped around what an agent actually wants to accomplish.

### See

* Take a screenshot of the current Apple TV screen
* Read device, connection, playback, and media state
* Inspect available Apple TV capabilities

### Apps

* List installed applications
* Open an application by name
* Open an application by bundle identifier
* Open deep links and custom application URLs

### Navigate

* Up
* Down
* Left
* Right
* Select
* Back
* Home
* Menu
* Other supported remote actions

Remote navigation is intentionally treated as non-idempotent. Apple TV MCP does not blindly replay navigation commands after an uncertain connection failure.

### Playback

* Play
* Pause
* Toggle play/pause
* Stop
* Next
* Previous
* Seek to an absolute position
* Skip forward or backward

### Text

Type directly into a focused tvOS text field.

This is useful for:

* Search
* Usernames
* App navigation
* Query entry

### Volume

* Read volume when available
* Set an absolute volume level
* Adjust volume relatively

### Power

* Turn the Apple TV on
* Turn the Apple TV off

Power operations use different retry semantics so a reconnect attempt cannot accidentally wake a device immediately after a successful power-off command.

---

## Give your agent eyes

The optional screenshot backend is what makes Apple TV MCP more than a remote control.

The MCP tool:

```text
apple_tv_screenshot
```

returns the current Apple TV screen as native MCP image content.

That means a multimodal MCP client can call the tool and inspect the returned image directly.

For example:

```text
Agent:
apple_tv_screenshot()

→ sees the Apple TV Home Screen
→ sees YouTube highlighted

apple_tv_press(button="select")

apple_tv_screenshot()

→ sees the YouTube interface
```

The model does not need access to a local `screen.png` path and does not receive base64 inside a text response.

The PNG itself is returned through MCP.

### Screenshots are point-in-time

Apple TV MCP does **not** continuously watch the screen.

A screenshot describes what was rendered at the moment it was captured.

If the agent performs another action afterward, the previous screenshot may already be stale.

The intended pattern is:

```text
observe
→ act
→ observe
→ verify
```

---

## Enable screenshots

Screenshot support is optional.

Apple TV control continues to work normally without it.

Install the separate helper:

```bash
uv tool install appletv-screenshot
```

The screenshot system uses a separate Apple developer / RemoteXPC pairing from the pairing used by `pyatv`.

Pair for developer access:

```bash
pymobiledevice3 remote pair
```

Then configure the screenshot helper for one Apple TV:

```bash
appletv-screenshot configure --udid <UDID>
```

Verify everything together:

```bash
appletv-mcp doctor
```

A healthy installation will report both Apple TV control and screen capture.

The screenshot helper has its own configuration, dependencies, and lifecycle. `pymobiledevice3` is not imported by the main `appletv-mcp` package.

For deeper screenshot setup and transport troubleshooting, see:

```text
sidecars/appletv-screenshot/README.md
```

---

## Quick start

The complete happy path is:

```bash
# Install
uv tool install appletv-mcp

# Pair for Apple TV control
atvremote wizard

# Choose the Apple TV
appletv-mcp configure

# Optional: install visual observation
uv tool install appletv-screenshot

# Optional: developer pairing for screenshots
pymobiledevice3 remote pair
appletv-screenshot configure --udid <UDID>

# Verify
appletv-mcp doctor

# Run the MCP server
appletv-mcp serve
```

---

## Connect your MCP client

Apple TV MCP uses local **stdio MCP transport**.

Any MCP client capable of launching a local stdio server can use it.

A typical configuration looks like:

```json
{
  "mcpServers": {
    "appletv-mcp": {
      "command": "appletv-mcp",
      "args": ["serve"]
    }
  }
}
```

If Apple TV MCP is running from a cloned repository instead:

```json
{
  "mcpServers": {
    "appletv-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/appletv-mcp",
        "run",
        "appletv-mcp",
        "serve"
      ]
    }
  }
}
```

The server does not expose an HTTP endpoint and does not require OAuth.

---

## Tools

| Tool                     | Purpose                                    |
| ------------------------ | ------------------------------------------ |
| `apple_tv_status`        | Read structured device and playback state  |
| `apple_tv_capabilities`  | Inspect normalized feature availability    |
| `apple_tv_list_apps`     | List launchable applications               |
| `apple_tv_power`         | Turn the Apple TV on or off                |
| `apple_tv_open_app`      | Open an application                        |
| `apple_tv_open_url`      | Open a URL or deep link                    |
| `apple_tv_press`         | Press Apple TV remote buttons              |
| `apple_tv_playback`      | Control playback                           |
| `apple_tv_seek`          | Seek to an absolute playback position      |
| `apple_tv_skip`          | Skip forward or backward                   |
| `apple_tv_set_text`      | Replace focused keyboard text              |
| `apple_tv_set_volume`    | Set an absolute volume                     |
| `apple_tv_adjust_volume` | Adjust volume relatively                   |
| `apple_tv_screenshot`    | Return one screenshot as MCP image content |

The screenshot tool is the only tool that returns image content rather than a structured result.

---

## How it works

Apple TV MCP keeps control and visual observation intentionally separate.

```text
                         AI Agent
                            │
                            ▼
                      Apple TV MCP
                      /           \
                     /             \
                    ▼               ▼
              semantic control   screen capture
                    │               │
                  pyatv      appletv-screenshot
                    │               │
                    │         pymobiledevice3
                    │               │
                    │          RemoteXPC / DVT
                    │               │
                    └──── Apple TV ─┘
```

### Control

Apple TV control is provided through `pyatv`.

Apple TV MCP adds a semantic application layer on top for:

* deterministic app resolution
* capability checking
* connection lifecycle
* safe retry behavior
* non-idempotent command protection
* normalized MCP results

The stable Apple TV identifier is authoritative.

The last known IP address is only an optimization. If the Apple TV changes addresses, Apple TV MCP can rediscover it by identifier and update the preferred host.

### Vision

Screenshots use the separate `appletv-screenshot` helper.

The helper uses `pymobiledevice3` to reach Apple's developer services over RemoteXPC and request a screenshot through DVT.

Its default transport strategy is:

```text
macOS:
native → userspace → tunneld

Linux / Windows:
userspace → tunneld
```

The normal Wi-Fi userspace path does not require root or a permanent