APISelf MCP

Local desktop applications, served to your AI agent as MCP tools from a single

endpoint on your own machine.

Most MCP servers wrap a cloud API. These wrap applications that do things on the

machine itself: Whisper transcription, screen recording, image and video

generation, document conversion, peer-to-peer file transfer, notifications.

Try it without installing anything

There is a hosted, read-only server that lets an agent browse the catalogue

before you install a thing. Four tools, no account, no local setup:

claude mcp add --transport http apiself-catalogue https://apiself.com/mcp

That is the shop window. The rest of this page is the thing itself.

The local endpoint

Install the APISelf Manager, install the boxes you want, and every one of them

appears as MCP tools on:

http://127.0.0.1:7474/api/mcp

Install another box and its tools show up there with no configuration. Remove it

and they disappear. There is no per-box MCP code to write or keep in sync.

Installing the Manager

# Linux
curl -fsSL https://apiself.com/install/en/setup.sh | bash

# macOS
curl -fsSL https://apiself.com/install/en/setup-macos.sh | bash

# Windows (PowerShell)
irm https://apiself.com/install/en/install-windows.ps1 | iex

The Manager runs on `localhost:7474`. Settings → AI integration prints the

ready-made configuration for each client below, with the session token filled

in.

Connecting a client

Claude Code — one command, no config file:

claude mcp add --transport http apiself http://127.0.0.1:7474/api/mcp \
  --header "X-APISelf-Token: "

Cursor — `mcp.json`:

{
  "mcpServers": {
    "apiself": {
      "url": "http://127.0.0.1:7474/api/mcp",
      "headers": { "X-APISelf-Token": "" }
    }
  }
}

Claude Desktop — via `mcp-remote`:

{
  "mcpServers": {
    "apiself": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "http://127.0.0.1:7474/api/mcp",
        "--header", "X-APISelf-Token: "
      ]
    }
  }
}

Gemini CLI, GitHub Copilot and ChatGPT are also generated for you in the same

place.

What you get

Each installed box contributes its own tools, so the total depends on what you

installed - a full catalogue is several hundred operations. The snapshot below

counts domain endpoints only, with health, info and audit excluded.

The catalogue changes as boxes ship, so treat this as a picture rather than a

contract. The live list is at , and the

`list_boxes` tool on the hosted server above returns it directly.

The tool-count problem

Several hundred tools drowns an agent. Context fills with definitions the task

will never use, and selection accuracy drops long before the context window

does.

Above a threshold the server stops returning the full catalogue from

`tools/list` and returns three meta-tools instead:

The agent searches for what a task needs and pulls in only that. The Manager's

own tools stay directly available in both modes, because a request like

"install the QR code box" should not require a search step first.

The threshold is 50 by default and is configurable:

APISELF_MCP_TOOL_SEARCH_THRESHOLD=120   # raise it
APISELF_MCP_TOOL_SEARCH_THRESHOLD=0     # always return the full list
APISELF_MCP_TOOL_SEARCH_THRESHOLD=-1    # always search

How the tools are generated

Every box ships an OpenAPI document describing its REST API. The Manager reads

those documents at startup and derives the MCP tool definitions from them, so:

• adding an endpoint to a box adds a tool, with no MCP code anywhere
• tool descriptions come from the API descriptions and stay in sync by

construction

• tool names are namespaced by box, e.g. `transcribe__post_api_transcribe`
• descriptions are served in the Manager's language, not only English

Boxes also call each other over the same REST APIs, so an agent asking one box

to hand work to another is using a path that already exists rather than one

built for agents.

Where things run

Everything is on `127.0.0.1` on a desktop install: no LAN listener, nothing for

`nmap` to find. Installed over SSH on a Linux machine with no display, the

Manager detects that, binds `0.0.0.0` and enables LAN access so you can reach it

from another computer. Either default can be changed during first run or later

in settings.

Boxes with AI features ship a local model as the default. Cloud models are

bring-your-own-key: the key goes into the AI Gateway box, the only place one is

stored, and other boxes route through it without ever seeing it.

Things worth knowing before you install

It is closed source. It is a paid product from one person and there is no

version of opening it that survives that. What is true instead: your data sits

on your own disk as plain SQLite and ordinary files, and every box's HTTP

interface is documented, so nothing is trapped if APISelf disappears.

The apps are paid, with a free tier that does not expire. When a trial ends

the box degrades to Free rather than stopping, and nothing you created is lost.

The Manager itself is free.

The binaries are not code-signed yet. Windows shows a SmartScreen warning

and macOS Gatekeeper asks for confirmation on first launch. It is a cost not yet

covered and the first thing that gets paid for.

There is no sandbox. A box runs as a normal process under your user account,

the same as any desktop application you install.

Links

• Catalogue and documentation:
• How it fits together:
• Machine-readable catalogue:
• Hosted catalogue MCP server: `https://apiself.com/mcp`

Questions about the OpenAPI-to-MCP mapping or the tool-search approach are

welcome as issues here.