The Nothing

The Nothing

a.k.a. Mr. Decoupler — the MCP server that does nothing, on purpose.

Sometimes less is more.

---

The idea: sometimes less is more

Most MCP servers race to do more: connect to more databases, read more files, call more APIs. That's great when you need it. But for a lot of simple scenarios, you don't — and every extra connection is one more credential to manage, one more thing that can break, and one more way an AI can touch data it shouldn't.

The Nothing takes the opposite approach. It connects to no database, reads no dataset, makes no network calls, writes nothing to disk and remembers nothing between calls. What it does provide is a clean, stable seam — a tool contract your AI can talk to — so the AI is never wired directly to your data layer.

That's why we call it Mr. Decoupler. He stands politely between your AI and your data, hands back exactly what he was given, and lets you decide later (or never) what should actually sit behind him.

Why use a server that does nothing?

Use case	How Mr. Decoupler helps
Prototyping AI workflows before the database exists	Design prompts and agent flows against pass_through now; swap in a real data server later without changing what the AI sees.
Keeping AI away from production data	Give the agent a data-shaped tool that physically cannot read, write or delete anything.
Demos, workshops and teaching MCP	The smallest possible working MCP server: tools, a resource and a prompt, with zero setup.
Testing MCP clients and hosts	A predictable, deterministic server for checking that a client connects, lists tools and handles results.
Dry runs of data operations	Let the AI describe the operation and payload it would run; review it before anything is real.
Placeholders in multi-server configs	Reserve a slot for a future data source so configs, docs and prompts don't have to change later.
A deliberate "no action needed" path	Sometimes the right answer to "should I query the database?" is no. nothing makes that explicit.

What's inside

Kind	Name	Behavior
Tool	nothing	Accepts anything, returns .... No side effects.
Tool	pass_through	Returns payload exactly as received (identity). Optional operation label is recorded but never executed.
Tool	search	Always returns {"results": []}.
Tool	fetch	Returns an empty document for any id.
Resource	nothing://void	Contains ....
Prompt	less-is-more	Nudges the model to check whether doing nothing is enough.

Every tool is annotated read-only, idempotent, non-destructive and closed-world, so clients that respect MCP tool annotations can run them without confirmation prompts. search and fetch exist so search-oriented clients such as ChatGPT connectors accept the server; they find nothing, by design.

Install

Node.js 18+ is the only requirement.

npx -y the-nothing-mcp           # stdio (local clients)
npx -y the-nothing-mcp --http    # Streamable HTTP at http://0.0.0.0:3000/mcp (remote clients)

Options: --port 3000, --host 0.0.0.0, or env THE_NOTHING_TRANSPORT=http, PORT, HOST.

Connect it to your AI

Local clients (stdio)

Most local clients use the same mcpServers block:

{
  "mcpServers": {
    "the-nothing": {
      "command": "npx",
      "args": ["-y", "the-nothing-mcp"]
    }
  }
}

Client	Where it goes
Claude Desktop	Settings → Developer → Edit Config (claude_desktop_config.json)
Claude Code	claude mcp add the-nothing -- npx -y the-nothing-mcp
Cursor	~/.cursor/mcp.json (global) or .cursor/mcp.json (project)
Windsurf	~/.codeium/windsurf/mcp_config.json
Gemini CLI	~/.gemini/settings.json, or gemini mcp add the-nothing npx -y the-nothing-mcp
Cline / Roo Code / Kilo Code	MCP Servers → Configure → cline_mcp_settings.json
Zed	settings.json under context_servers
JetBrains AI Assistant / Junie	Settings → Tools → AI Assistant → MCP → Add → paste the JSON
Continue, LM Studio, Goose, and others	Their MCP settings; same command and args

VS Code + GitHub Copilot — install the The Nothing extension from the Marketplace (zero config), or add .vscode/mcp.json:

{
  "servers": {
    "the-nothing": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "the-nothing-mcp"]
    }
  }
}

OpenAI Codex CLI — ~/.codex/config.toml:

[mcp_servers.the-nothing]
command = "npx"
args = ["-y", "the-nothing-mcp"]

Remote clients (Streamable HTTP)

ChatGPT, Grok, claude.ai custom connectors and hosted agent APIs reach MCP servers over HTTPS, so run The Nothing in HTTP mode somewhere public:

npx -y the-nothing-mcp --http --port 3000
# or
docker build -t the-nothing . && docker run -p 3000:3000 the-nothing

Put it behind HTTPS (any host, or a tunnel such as Cloudflare Tunnel or ngrok for testing), then use https://your-host/mcp:

Client	How
ChatGPT	Settings → Apps & Connectors → enable Developer mode → Create → MCP server URL
Claude (claude.ai / Desktop / mobile)	Settings → Connectors → Add custom connector → URL
Grok (xAI API)	Add a remote MCP tool with server_url pointing at your /mcp endpoint
Gemini API / Google ADK	Use the SDK's MCP client with a Streamable HTTP transport
OpenAI Responses / Agents SDK	Add an mcp tool with server_url

The HTTP server is stateless (no sessions, no auth, nothing stored), answers GET /health, and sends permissive CORS headers. It needs no secrets, because there is nothing to protect.

Use it as a library

import { createServer } from "the-nothing-mcp";
const server = createServer(); // a fresh McpServer that does nothing

Development

npm install
npm test               # exercises every tool over stdio and HTTP
npm run build:vscode   # bundles the server into the VS Code extension

See PUBLISHING.md for releasing to npm, the official MCP Registry and the VS Code Marketplace.

FAQ

Does it really do nothing? Yes. Read src/server.js; it's short. There is no I/O apart from the MCP transport itself.

Then why not just have no server? Because a stable contract is worth something. The Nothing lets your AI, prompts and configs depend on an interface instead of an implementation. When you're ready for real data, replace Mr. Decoupler with a server that exposes the same tools, and nothing else has to change.

Is it safe to give to an autonomous agent? It's about as safe as software gets: it cannot reach anything.

License

MIT

mcp-name: io.github.Meador793/the-nothing

...