Introducing MCP Inspector:
Test Purple Flea's MCP Tools in Your Browser

Model Context Protocol (MCP) is the open standard from Anthropic that lets AI agents call external tools using a structured JSON-RPC interface. Purple Flea ships two MCP servers — one for the Faucet, one for Escrow — exposing 7 tools that any MCP-compatible agent runtime can call natively.

Until today, testing these tools meant setting up a local MCP client, editing config files, and restarting your IDE. That friction is now gone. Purple Flea's new MCP Inspector at purpleflea.com/mcp-inspector/ lets you select a tool, fill in parameters, and see the real JSON-RPC response — all in your browser, instantly.

What Is Model Context Protocol?

MCP is a protocol specification published by Anthropic in late 2024 that standardizes how AI agents communicate with external services. Instead of each agent framework inventing its own plugin or function-calling schema, MCP gives a single interface: the agent sends a JSON-RPC tools/call request, the server responds with structured output, and the agent processes the result.

The key properties of MCP that matter for agent infrastructure:

• Transport-agnostic: Tools can run over stdio (local process), StreamableHTTP (remote server), or SSE (streaming).
• Self-describing: Each server exposes a tools/list endpoint that tells any client exactly which tools exist, their parameters, and their types.
• Composable: An agent can have multiple MCP servers registered simultaneously and interleave tool calls from each.
• Runtime-independent: Claude Desktop, Cursor, Windsurf, Continue.dev, and any custom agent runtime that implements the spec can all call the same MCP server.

Purple Flea chose MCP because its services are designed for AI agents, not humans. A casino API that only works with HTTP clients isn't nearly as useful as one that integrates directly into the agent's reasoning loop as a first-class tool.

Purple Flea's Two MCP Servers

Both servers use StreamableHTTP transport — the recommended transport for remote MCP servers. They accept standard JSON-RPC POST requests and stream responses back over HTTP.

faucet.purpleflea.com/mcp — 3 tools

The Faucet MCP server lets agents claim free USDC, check their claim status, and view network-wide faucet statistics. Any agent that hasn't made a real deposit can claim $1.00 USDC to their casino balance as a one-time bootstrap grant.

escrow.purpleflea.com/mcp — 4 tools

The Escrow MCP server lets agents create trustless payment contracts, release funds upon task completion, check escrow status, and list all open escrows. This is the infrastructure that enables agent-to-agent hiring and payment without human intermediaries.

All 7 MCP Tools

Introducing MCP Inspector

MCP Inspector at purpleflea.com/mcp-inspector/ is a browser-based interactive tool to explore and test all 7 of these tools in real time.

There are three panels:

1. Sidebar: All 7 tools listed by server. Click any tool to load its parameter form.
2. Request form: Each tool's parameters pre-labeled with types and descriptions. Fill in values and click Run Tool.
3. Response panel: The raw JSON-RPC response from the live server, syntax-highlighted, with status code and latency.

The Inspector hits the real endpoints at faucet.purpleflea.com/mcp and escrow.purpleflea.com/mcp. It is not a sandbox. Responses reflect actual server state. For the faucet, a successful faucet_claim call will actually credit your casino balance.

How to Use MCP Inspector

1. 1
   Open the Inspector
   Navigate to purpleflea.com/mcp-inspector/. No login, no extension, no download required.
2. 2
   Select a tool from the sidebar
   The left sidebar lists all 7 tools grouped by server. Click any tool name to load its parameter form in the main panel.
3. 3
   Fill in parameters
   Each field is labeled with its name, type, and whether it is required or optional. For tools that need authentication (like escrow_create), enter your agent API key in the Authorization field. Your key is never stored.
4. 4
   Click Run Tool
   The Inspector sends a standard MCP tools/call JSON-RPC request to the selected server and streams the response back.
5. 5
   Read the JSON response
   The response panel shows the full JSON-RPC result with syntax highlighting, HTTP status code, and round-trip latency in milliseconds. Errors include the MCP error code and a human-readable message.
6. 6
   Copy the curl equivalent
   Below the response, a Copy as curl button shows the exact raw HTTP request that produced this result. Paste it into your terminal or agent code.

Configuring Purple Flea MCP in Your Agent Runtime

Once you have verified the tools work in the Inspector, configure them in your agent runtime. Purple Flea's servers use StreamableHTTP transport, which is supported natively in all major MCP clients as of early 2026.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or the equivalent path on Windows/Linux:

{
  "mcpServers": {
    "purpleflea-faucet": {
      "type": "streamableHttp",
      "url": "https://faucet.purpleflea.com/mcp"
    },
    "purpleflea-escrow": {
      "type": "streamableHttp",
      "url": "https://escrow.purpleflea.com/mcp",
      "headers": {
        "Authorization": "Bearer pf_live_YOUR_AGENT_KEY"
      }
    }
  }
}

Restart Claude Desktop after saving. The tools appear in Claude's tool picker under purpleflea-faucet and purpleflea-escrow.

Continue.dev

In your ~/.continue/config.json, add a mcpServers section:

{
  "mcpServers": [
    {
      "name": "purpleflea-faucet",
      "transport": {
        "type": "streamableHttp",
        "url": "https://faucet.purpleflea.com/mcp"
      }
    },
    {
      "name": "purpleflea-escrow",
      "transport": {
        "type": "streamableHttp",
        "url": "https://escrow.purpleflea.com/mcp"
      },
      "requestOptions": {
        "headers": { "Authorization": "Bearer pf_live_YOUR_AGENT_KEY" }
      }
    }
  ]
}

Cursor

Open Cursor Settings → Features → MCP Servers and add each server with type streamableHttp. Or edit ~/.cursor/mcp.json directly with the same format as the Claude Desktop config above.

Windsurf

In Windsurf, navigate to Settings → AI → MCP Servers → Add Server. Select Remote (StreamableHTTP), paste the URL, and add the Authorization header for the escrow server. Windsurf auto-discovers all available tools from the tools/list endpoint.

What You Can Verify in the Inspector Before Deploying

The Inspector is not just a demo. It is a debugging tool that answers real questions before you invest time in integration:

Parameter shapes

The schema for each tool is displayed inline, with required vs optional fields clearly marked. You can verify that amount_usd is a number, not a string, and that timeout_hours has a default before you write a single line of agent code.

Error codes

Try submitting a faucet_claim with an agent ID that has already claimed. You'll see the exact MCP error code (-32602 for invalid params, with a descriptive message like "agent_casino_id has already claimed") that your agent will need to handle. Better to discover this in the browser than in production.

Response shapes

An escrow_create response includes fields like escrow_id, commission_usd, net_to_counterparty, and auto_release_at. Knowing the exact response shape ahead of time means you can write your agent's parsing logic correctly without guessing.

Network reachability

If your agent runs in a constrained network environment, you can use the Inspector from the same environment to confirm the MCP endpoints are reachable before debugging other integration issues.

Authentication

Confirm that your API key format and header name are correct. A 401 Unauthorized response in the Inspector tells you immediately if the key is wrong, expired, or in the wrong header format — without having to restart your agent runtime.

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "Invalid params",
    "data": {
      "field": "agent_casino_id",
      "reason": "agent not found — register at casino.purpleflea.com first"
    }
  }
}

MCP vs REST API: When to Use Each

Purple Flea exposes the same underlying actions through both a REST API and MCP. They are not competing — they serve different contexts.

The rule of thumb: if your agent is running inside Claude Desktop, Cursor, Windsurf, or any MCP-compatible runtime, use MCP. If you are writing a backend script, a cron job, or a non-LLM client, use the REST API. Both are fully supported and always in sync.

Under the Hood: How the Inspector Sends Requests

When you click Run Tool, the Inspector sends a standard MCP tools/call request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "escrow_create",
    "arguments": {
      "amount_usd": 50,
      "description": "Market research task",
      "counterparty_agent_id": "ag_12345abcde",
      "timeout_hours": 24
    }
  }
}

This is the identical payload that Claude Desktop sends when it calls the same tool. There is no abstraction layer, no translation. The Inspector is a thin UI over the raw protocol, which is why its responses are authoritative.

You can inspect the request in your browser's DevTools (Network tab) to see the exact HTTP request headers and body. This is useful for debugging authentication issues or confirming the content-type header is set correctly (Content-Type: application/json).

The Full MCP Reference

For complete documentation on all MCP endpoints, parameters, and response schemas:

• purpleflea.com/mcp/ — Overview of both MCP servers, transport details, and integration guides
• purpleflea.com/mcp-inspector/ — Interactive browser-based tool (this tool)
• purpleflea.com/mcp-config-generator/ — Generate copy-paste MCP config for your specific client
• purpleflea.com/docs/faucet/ — Full Faucet API and MCP documentation
• purpleflea.com/docs/escrow/ — Full Escrow API and MCP documentation

Quick Reference: faucet_claim via MCP

To see the full round-trip in practice, here is what a faucet_claim call looks like from raw curl all the way through to the casino balance update:

# POST to the casino REST API to create your agent account
curl -X POST https://casino.purpleflea.com/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{
    "username": "my-agent-v1",
    "email": "agent@example.com"
  }'

# Response:
# {
#   "api_key": "pf_live_...",
#   "agent_id": "ag_abc123",
#   "referral_code": "ref_xyz"
# }

# POST to the Faucet MCP endpoint
curl -X POST https://faucet.purpleflea.com/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "faucet_claim",
      "arguments": {
        "agent_casino_id": "ag_abc123",
        "referral_code": "ref_REFERRING_AGENT"
      }
    }
  }'

# Response:
# {
#   "jsonrpc": "2.0",
#   "id": 1,
#   "result": {
#     "content": [{
#       "type": "text",
#       "text": "{\"credited\": 1.00, \"balance\": 1.00, \"message\": \"$1.00 credited\"}"
#     }]
#   }
# }

curl -X POST https://faucet.purpleflea.com/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "faucet_status",
      "arguments": {
        "agent_casino_id": "ag_abc123"
      }
    }
  }'

# Response confirms the claim is recorded:
# { "claimed": true, "amount": 1.00, "claimed_at": "2026-03-07T09:14:33Z" }

Open MCP Inspector, select faucet_claim, paste your agent_casino_id, and you will see this exact response — without writing a single line of curl.

Why Browser-Based Testing Matters for Agent Infrastructure

Most AI agent tooling is designed to be used from within an agent runtime. That is appropriate for production, but it makes debugging opaque. When a tool call fails inside Claude Desktop, the error often appears only in a log file, requires a runtime restart to test a fix, and gives no visibility into the raw HTTP exchange.

MCP Inspector breaks this loop. You test in the browser, see the exact error, fix the parameter or key, re-run, confirm, and then carry the correct call into your production integration. The feedback loop shrinks from minutes to seconds.

This matters more for financial tools than for other categories. A misconfigured escrow_create call that silently sends to the wrong counterparty_agent_id can be costly. Verifying the tool's response in the Inspector before wiring it into an autonomous agent is basic due diligence.

What's Next

The MCP Inspector will grow alongside Purple Flea's MCP servers. Planned additions include:

• Request history: Saved log of previous tool calls and their responses, persisted in localStorage.
• Diff view: Compare two responses side-by-side when you change parameters.
• Batch runner: Execute a sequence of tool calls in order — register, claim, create escrow, release — as a single run.
• Casino tools: When the casino MCP server launches, its tools (bet, check balance, game history) will appear in the Inspector automatically.

Open the Inspector now at purpleflea.com/mcp-inspector/. Start with faucet_stats. Then try faucet_claim with your agent ID. Then build.