MCP Server Sandbox
This sandbox spins up a small local MCP (Model Context Protocol) server and lets you call its exposed tools directly, so you can see request and response payloads in real time and understand how MCP tool calls actually work before wiring the protocol into your own AI application.
How MCP Communication Flows
Next.js Client (React)
Sends a standard POST request with the text body to our API route: `/api/mcp-client`.
Next.js API Handler (Stdio Client)
Spawns a Node.js child process: `node mcp-demo/dist/server.js` and opens stdout/stdin pipelines.
JSON-RPC StdIn Write
Writes a standard JSON-RPC command string to the child process standard input stream: `{"method":"tools/call","params":{"name":"calculate_text_stats",...}}` followed by `\n`.
MCP Server (Studio Transport Server)
Listens on stdin, executes the tool logic locally, and writes the output back to `stdout` as a JSON line.
JSON-RPC StdOut Read & Return
Next.js API catches the line from stdout, terminates the child process using `child.kill()`, and responds back to the client.
Learning Module
The MCP server project configuration is saved inside the workspace sub-directory at:mcp-demo/
- src/server.ts
The TypeScript server implementing the official `@modelcontextprotocol/sdk` wrapper.
- README.md
Contains complete instructions on how to configure this server with external desktop clients like Claude Desktop.
Open `src/server.ts`. You can add new tools to the `ListToolsRequestSchema` response, and implement their execution rules in the `CallToolRequestSchema` handler block.
How it works
- 1
ToolKloud spawns a lightweight local MCP server exposing a few example tools.
- 2
Browse the available tools and their input schemas.
- 3
Call a tool with sample input and see the live response.
- 4
Inspect the raw request/response payloads to understand the protocol.
What people use it for
- Seeing what a Model Context Protocol tool call and response actually look like.
- Understanding tool schemas before implementing your own MCP server.
- Demonstrating MCP mechanics in a talk, workshop or documentation page.
- Checking your mental model of the protocol against a working implementation.
Supported formats & options
| Protocol | Model Context Protocol tool listing and tool invocation |
|---|---|
| Demo tools | A small set of example text-statistics tools |
| Processing | Server-assisted — calls execute against a demo server on our infrastructure |
Key advantages & benefits
Hands-on, not just documentation
See real MCP requests and responses instead of only reading protocol specs.
No setup required
The server spins up automatically — no need to install Node packages or configure a client yourself first.
Inspect raw payloads
View the actual JSON exchanged between client and server to understand the protocol's shape.
Safe sandbox environment
Experiment freely with example tools without affecting any production system.
Limits & things to know
- This is a learning sandbox, not a general-purpose MCP host. You cannot connect it to your own server or register custom tools.
- Requests are executed on our server rather than in your browser, so input you send here leaves your device.
- The sandbox is stateless and resets between sessions; nothing you do persists.
- The example tools are deliberately trivial, chosen to make request and response shapes legible rather than to be useful in themselves.
Troubleshooting
A call returns an error
Check the argument names against the tool's advertised schema — MCP tool calls are validated against it, and a mismatched key is the usual cause.
Results differ between sessions
The sandbox resets, so nothing carries over. Treat each session as a fresh server.
Privacy & data handling
Unlike the browser-based tools here, this sandbox executes requests on our server. Input you send is processed there and is not stored after the session, but it does leave your device — keep real credentials and confidential data out of it.
MCP Client — Test Model Context Protocol Servers in Your Browser
Connect to a Model Context Protocol server, inspect the tools, resources and prompts it exposes, and call them with real arguments. A free browser-based MCP client for developers building or debugging an MCP integration, with no local runtime to configure first.
- Inspect tools, resources and prompts — see everything a server advertises, including each tool's full JSON Schema, so you can confirm the contract before writing client code.
- Call tools with live arguments — invoke a tool with real input and read the raw response — the fastest way to find out whether a bug is yours or the server's.
- Debug an MCP server as you build it — verify that schemas, descriptions and error responses look the way an AI model will actually receive them.
- No local setup required — test a server without first wiring it into a desktop AI client and restarting it after every change.
- Understand the protocol by using it — MCP is the emerging standard for connecting AI assistants to external tools and data — seeing the exchange makes the spec concrete.
Free with no account. Format the JSON responses you get back with the JSON Formatter while you debug.
Frequently asked questions
What is the Model Context Protocol?
MCP is an open standard for connecting AI applications to external tools and data sources through a consistent client-server interface, developed by Anthropic and adopted broadly across the AI tooling ecosystem.
Do I need to know Node.js to use this sandbox?
No — the server is spawned automatically behind the scenes, so you can explore tool calls and responses without writing any server code yourself.
Can I add my own custom tools to test?
This sandbox ships with a small set of example text-stats tools designed for learning; it's meant as a demo environment rather than a general-purpose MCP server host.
Is this useful if I'm building my own MCP integration?
Yes — seeing real tool schemas and request/response payloads is a good way to understand the protocol's structure before implementing your own client or server.
Does anything I do here persist afterward?
No — the spawned server and its state are temporary and reset each session, so nothing you test here has lasting effects.