Skip to main content
Glama
compliant-empty-mcp

compliant-empty-mcp

README.md
# compliant-empty-mcp

An entirely empty MCP server that passes protocol conformance.

This is a rhetorical artifact: a fully-valid Model Context Protocol server that advertises zero tools, zero resources, and zero prompts. It exists to demonstrate that **"we have an MCP" is a valueless claim**. MCP is a protocol, not a product. A server can be 100% conformant and do absolutely nothing.

**Live instance:** https://compliant-empty-mcp-production.up.railway.app/mcp

Speaks MCP protocol version `2025-11-25`. Requires Node 20 or later. See [CHANGELOG.md](CHANGELOG.md) for what changed.

## Run it (stdio)

```bash
npx -y github:shinytoyrobots/compliant-empty-mcp
```

Or clone and build:

```bash
git clone https://github.com/shinytoyrobots/compliant-empty-mcp
cd compliant-empty-mcp
npm install
npm run build
npm start
```

The server speaks JSON-RPC 2.0 over stdio. It responds to `initialize`, `tools/list`, `resources/list`, and `prompts/list` — the last three with empty arrays. Any other method returns JSON-RPC error `-32601` ("Method not found").

## Run it (HTTP)

```bash
npm run start:http
```

This starts a Streamable HTTP transport on port 3000 (or `$PORT`). The MCP endpoint is `POST /mcp`.

Browser requests are checked against the `Origin` header, as the MCP spec requires, to block DNS rebinding. Allowed: `localhost`/`127.0.0.1`/`[::1]` on any port, and anything listed in `ALLOWED_ORIGINS` (comma-separated). Requests without an `Origin` header (curl, SDK clients) are unaffected.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"curl","version":"0.1"}}}'
```

## Test it

### Against the live instance

```bash
curl -X POST https://compliant-empty-mcp-production.up.railway.app/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
```

Response: `{"result":{"tools":[]},"jsonrpc":"2.0","id":1}`

### MCP Inspector

```bash
npx @modelcontextprotocol/inspector
```

In the Inspector UI, set **Transport Type** to "Streamable HTTP", **Connection Type** to "Direct", and **URL** to:

```
https://compliant-empty-mcp-production.up.railway.app/mcp
```

### Connect as an MCP client

Add to `~/.claude.json` (Claude Code) or `~/Library/Application Support/Claude/claude_desktop_config.json` (Claude Desktop):

```json
{
  "mcpServers": {
    "compliant-empty-mcp": {
      "type": "url",
      "url": "https://compliant-empty-mcp-production.up.railway.app/mcp"
    }
  }
}
```

The server will appear as a connected MCP with zero tools. That's the point.

### Conformance probe (local)

```bash
npm run build
npm run conformance
```

```
MCP conformance probe — compliant-empty-mcp

  [PASS] AC-2: initialize returns valid InitializeResult with serverInfo.name
  [PASS] Latest protocol version 2025-11-25 is negotiated
  [PASS] AC-3: tools/list returns { tools: [] }
  [PASS] AC-4: resources/list returns { resources: [] }
  [PASS] AC-5: prompts/list returns { prompts: [] }
  [PASS] AC-6: zero tools, zero resources, zero prompts at all times
  [PASS] AC-7: unsupported method returns error -32601
  [PASS] AC-9: stdio transport is the default and functional
  [PASS] AC-1: server terminates cleanly after stdin close

9/9 checks passed.
```

The same checks for the HTTP transport (including Origin handling):

```bash
npm run conformance:http
```

## Deploy your own

The HTTP server runs on any platform that hosts Node.js. A multi-stage `Dockerfile` is included.

**Railway**: import from GitHub. Set the custom start command to `npm run start:http` (under Service → Settings → Deploy).

**Render** (free tier): connect this repo, set build command `npm install && npm run build`, start command `npm run start:http`.

**Fly.io**: `fly launch` auto-detects the Dockerfile.

**Browser clients on another domain**: set `ALLOWED_ORIGINS` (comma-separated, e.g. `https://app.example.com`) or the server returns 403 for their requests. Non-browser clients are unaffected.

## How empty is it?

The full stdio implementation fits in one file (`src/index.ts`; `src/http.ts` adds the HTTP transport and Origin check):

```ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ListPromptsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  { name: "compliant-empty-mcp", version: "0.2.0" },
  { capabilities: { tools: {}, resources: {}, prompts: {} } },
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [] }));
server.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: [] }));
server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: [] }));

await server.connect(new StdioServerTransport());
```

That is the entire product. It is a valid MCP server. It does nothing.

## The point

Next time a vendor tells you they "have an MCP," ask what's in it.

## License

MIT