# Set up Aster — MCP server, Android app, AI client

> Install aster-mcp from npm, run aster start, sideload the Android app, approve the device and point Claude Code at http://localhost:5988/mcp.

Aster here is the open-source Model Context Protocol server and Android companion app for AI-driven phone control, published on npm as aster-mcp. It is unrelated to Aster DM Healthcare, Aster Data Systems or the ASTER instrument on NASA’s Terra satellite.

Source: https://aster.matterwardlabs.com/setup/ · Part of Aster (https://github.com/satyajiit/aster-mcp) · Last generated 2026-09-13

## Before you start

- **Server — Node.js >= 20.** Any machine that stays awake: laptop, desktop, mini PC or NAS. macOS, Linux and Windows all work.
- **Phone — Android 8.0+ (API 26).** The companion APK pins minSdk 26. Anything older cannot install it, and no root is needed on anything newer.
- **Network — Same LAN, or Tailscale.** The phone dials out to the server, so the two only need to see each other — no inbound port forwarding.

No root, no ADB cable and no Google account are required at any point. If the phone and the server cannot sit on the same LAN, join both to [Tailscale](https://tailscale.com/) and use the tailnet address everywhere this page says “server address”.

## Step 1 — Install the MCP server

The server is an npm package, aster-mcp, currently version 0.1.16. Install it globally on the machine that will stay awake — a laptop, a desktop, a NAS or a mini PC.

```bash
npm install -g aster-mcp
```

Note: Node.js >= 20 is required. Running the server inside Termux on the phone itself is untested and unsupported; use the app's on-device MCP mode instead.

## Step 2 — Start the server

One command brings up all three listeners: 5987 for the Device WebSocket, 5988 for the API + MCP HTTP, 5989 for the Web dashboard. The terminal prints the exact WebSocket address to type into the phone.

```bash
aster start
```

Note: Keep these ports on your LAN or your tailnet. Do not port-forward 5987 or 5988 to the public internet — the device link is plain ws:// and terminates no TLS of its own.

## Step 3 — Install the Android companion

Download the latest APK from GitHub Releases and sideload it. It runs on Android 8.0+ (API 26) and needs no root. Use your daily phone, or a spare Android you want to hand over to your AI entirely.

Note: Accessibility Service is the one permission Aster cannot work without — it is what reads the screen and drives taps. Notifications, SMS, phone, location and storage are each optional and asked for separately.

## Step 4 — Point the phone at the server

Open Aster on the phone, enter the WebSocket address the terminal printed — ws://<server-ip>:5987 — and tap Connect. For a dedicated AI phone, plug it into a charger and leave it there.

Note: The address is a LAN IP and is only valid on that network. If you move between Wi-Fi networks, join both ends to Tailscale and use the stable tailnet address instead.

## Step 5 — Approve the device

A new device arrives as pending and can connect but not be commanded. Approve it from the CLI, or click Approve in the dashboard at http://localhost:5989.

```bash
aster devices approve <deviceId>
```

Note: A device left pending is the single most common setup failure: it shows as connected while every tool call times out. There are no tokens or per-device keys — approval is the whole access-control model.

## Step 6 — Point your AI client at the MCP endpoint

Add Aster to your client as a streamable-HTTP MCP server at http://localhost:5988/mcp. All 49 tools then appear namespaced aster_*, so a call looks like aster_take_screenshot.

```json
{
  "mcpServers": {
    "aster": {
      "type": "http",
      "url": "http://localhost:5988/mcp"
    }
  }
}
```

Note: One address per audience: 5987 goes in the phone, 5988/mcp goes in the AI client, 5989 goes in your browser. Pasting the wrong port into the wrong app is the second most common setup failure.


## Connecting an AI client

### Claude Code and Claude Desktop

Add the entry below to your project's .mcp.json, or to the Claude Desktop MCP settings, and restart the client. Aster registers 49 tools, every one of them prefixed aster_.

```json
{
  "mcpServers": {
    "aster": {
      "type": "http",
      "url": "http://localhost:5988/mcp"
    }
  }
}
```

### OpenClaw, MoltBot and ClawdBot

Aster ships as a skill on ClawHub, the registry agent clients such as OpenClaw, MoltBot and ClawdBot install skills from. Install it from the hub, or fetch the skill file straight from the repository if your client takes a raw URL.

```bash
clawhub install aster

# or take the skill file directly:
curl -O https://raw.githubusercontent.com/satyajiit/aster-mcp/main/skill/SKILL.md
```

### AnythingLLM and any MCP client

There is nothing Aster-specific to install. The server speaks standard streamable-HTTP MCP, so any compliant client works by pointing it at the endpoint. On a LAN, swap localhost for the server machine’s address.

```text
http://localhost:5988/mcp
```

### OpenAlly

OpenAlly runs on the same phone and drives Aster over Android Binder IPC — no server, no network hop, nothing to configure. Install both apps, approve the on-device handshake once, and OpenAlly has the full on-device action catalog (77 actions, unprefixed). This is the only path that needs no MCP endpoint at all.


## Checking it works

Two commands separate “the server is up” from “the phone is reachable”. Run both before blaming the AI client.

```bash
aster status
curl http://localhost:5988/api/health
```

What each check proves:

- **aster status** — Prints the human-readable snapshot the running server writes to ~/.aster/status.json: the advertised addresses, and every device with its approval state. A device listed as pending is connected but cannot be commanded yet.
- **curl http://localhost:5988/api/health** — Returns { "status": "ok", "timestamp": ... }. This is the endpoint to poll from scripts and monitors; GET /api/stats next to it returns device counts.
- **Your AI client** — Ask it to list its tools. You should see 49 names, all beginning aster_ — aster_take_screenshot is the cheapest one to try first. If the list is empty, the client never reached http://localhost:5988/mcp; if a call hangs, the device is still pending.