Everything (test server) MCP — Use Cases, Install & Live Demo

Name: Everything (test server) MCP Server
Author: modelcontextprotocol

Why use it

Key features

Covers the full MCP surface: tools, resources, prompts, sampling, completion
Includes deliberately slow tools so you can test cancellation/streaming
Zero external dependencies — runs fully offline
Great fixture for client unit/integration tests

Live Demo

What it looks like in practice

everything.replay ▶ ready

0/0

Install

Pick your client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-everything"
      ]
    }
  }
}

Open Claude Desktop → Settings → Developer → Edit Config. Restart after saving.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-everything"
      ]
    }
  }
}

Cursor uses the same mcpServers schema as Claude Desktop. Project config wins over global.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-everything"
      ]
    }
  }
}

Click the MCP Servers icon in the Cline sidebar, then "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-everything"
      ]
    }
  }
}

Same shape as Claude Desktop. Restart Windsurf to pick up changes.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "everything",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-everything"
      ]
    }
  ]
}

Continue uses an array of server objects rather than a map.

~/.config/zed/settings.json

{
  "context_servers": {
    "everything": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-everything"
        ]
      }
    }
  }
}

Add to context_servers. Zed hot-reloads on save.

claude mcp add everything -- npx -y @modelcontextprotocol/server-everything

One-liner. Verify with claude mcp list. Remove with claude mcp remove.

Use Cases

Real-world ways to use Everything (test server)

Verify your MCP client implementation handles every protocol feature

👤 Developers building or debugging MCP clients, SDKs, or integrations ⏱ ~20 min intermediate

When to use: You're shipping a new MCP client, integration, or wrapper and want to prove it handles tools+resources+prompts+sampling before pointing at a real server.

Prerequisites

Your MCP client under test — Claude Desktop, your custom client, or a test harness

Flow

Launch everything server and list its capabilities

Connect to the everything server. List every tool, resource, and prompt it exposes.✓ Copied

→ Complete inventory — confirms your client can discover the full surface
Exercise each capability

Call echo, then add, then longRunningOperation with 10s duration. Read the static resource and a dynamic one. Invoke the simple_prompt prompt.✓ Copied

→ Each call completes or streams correctly; cancellation works
Test edge cases

Try sampling (sampleLLM tool), completion on a prompt argument, and a tool with deliberate error. Check your client handles each path.✓ Copied

→ No crashes; errors surface with proper MCP error codes

Outcome: A checked-off matrix of MCP features your client actually implements, with evidence.

Pitfalls

Not all clients implement sampling — Sampling is client-optional; if yours doesn't support it, the sampleLLM tool will surface a clear error — expected, not a bug

Learn the MCP protocol by poking at a real server

👤 Developers new to MCP who've read the spec and want to see it live ⏱ ~45 min intermediate

When to use: You're studying the protocol and want a server whose source code you can also read side-by-side.

Flow

Run the server with stdio transport and watch the traffic

Run npx -y @modelcontextprotocol/server-everything and connect a client. Capture the JSON-RPC exchange (tool list, call, response).✓ Copied

→ Raw protocol frames you can map to the spec
Read the matching source

Open modelcontextprotocol/servers/src/everything — trace which file implements the tool, resource, prompt handlers you just saw.✓ Copied

→ 1:1 mapping between wire protocol and server code
Modify and test

Fork the server, add a new tool that returns the current server uptime, restart, and call it.✓ Copied

→ Your new tool appears in list_tools and responds to calls

Outcome: You understand MCP at the wire level, not just SDK-level.

Pitfalls

Treating everything-server features as production-ready patterns — The server is deliberately over-featured for testing; real servers should expose only tools you actually need

Combine with: fastmcp

Combinations

Pair with other MCPs for X10 leverage

everything + fastmcp

Test that your FastMCP-built server behaves like the reference

Connect to both my FastMCP server and the everything server. For each capability the everything server exposes, check whether my server handles it equivalently.✓ Copied

everything + mcp-agent

Run agent evals against a server with known behaviors

Set up an mcp-agent pointing at the everything server. Run a test suite that validates tool-call, resource-read, and prompt-invoke flows.✓ Copied

Tools

What this MCP exposes

Tool	Inputs	When to call	Cost
echo	message: str	Smoke test: confirm request/response works	free
add	a: number, b: number	Simple typed-input test	free
longRunningOperation	duration: int (seconds), steps: int	Test streaming/progress + cancellation paths in your client	free
sampleLLM	prompt: str, maxTokens: int	Test MCP sampling feature — server requests the client to run an LLM call	depends on client's sampling backend
getTinyImage	none	Test binary resource delivery	free
printEnv	none	Diagnose what env vars your MCP client passes through	free
annotatedMessage	messageType: str, includeImage: bool	Test rendering of annotated content (priority, audience)	free

Cost & Limits

What this costs to run

API quota: None — fully local
Tokens per call: Tiny
Monetary: Free
Tip: Only concern: longRunningOperation and sampleLLM can cost real time or tokens on your client's LLM; keep test runs short.

Security

Permissions, secrets, blast radius

Credential storage: None

Data egress: None by default; printEnv exposes whatever env vars your client passed — don't point it at a process with secrets while demoing

Not for production use. It's a test fixture — features are deliberately quirky.
printEnv will surface whatever env the client passes. Don't attach it to a context with real secrets.

Troubleshooting

Common errors and fixes

Client shows no tools after connect

Confirm stdio transport matches. Some clients require the server process to be long-lived; check your client's 'command' config runs without exiting.

Verify: Run `npx -y @modelcontextprotocol/server-everything` directly; it should block waiting for input

sampleLLM returns 'sampling not supported'

Your client doesn't implement MCP sampling (many don't). Expected for most clients today. Skip that tool.

longRunningOperation doesn't stream progress

Your client may not subscribe to progress notifications. Check its docs for progress handler support.

Alternatives

Everything (test server) vs others

Alternative	When to use it instead	Tradeoff
FastMCP	You want to build your own test server, not use the reference	More work; lets you isolate specific behaviors
Any real server (github, filesystem, etc.)	You want to test against realistic, narrow tool surfaces instead of the kitchen sink	Smaller surface — might miss features your client needs to support

More

Resources

📖 Read the official README on GitHub

🐙 Browse open issues

🔍 Browse all 400+ MCP servers and Skills