See what an MCPserver's tools actually expect, in seconds.
Paste a tools/list JSON response and get a clean, readable card per tool: name, description, parameters, and which ones are required. No Node.js, no terminal, nothing leaves your browser.
How the MCP Server Inspector works
- 1
Paste your tools/list JSON
Paste the raw JSON response your MCP server returns for a tools/list request, or click "Load example" to see a sample. The Inspector also accepts a bare array of tool objects.
- 2
The JSON is parsed and validated
JSON.parse runs first. If it fails, you get the parser's exact error. If it succeeds but doesn't look like an MCP response (no tools array, or an empty one), you get a plain-language explanation of what shape was expected.
- 3
Each tool's input schema is walked
For every tool, the Inspector reads its inputSchema, lists each property, marks it required or optional based on the schema's required array, and resolves its type, including nested object and array shapes.
- 4
Tools render as readable cards
Each tool becomes a card with its name, description, and a parameter table showing type, required/optional status, description, enum values, and defaults, exactly what you'd need to call it correctly.
- 5
Filter and copy what you need
With larger servers (20+ tools), type in the filter box to narrow by name or description. Each card has a "Copy JSON" button that copies just that tool's definition for sharing in a PR, doc, or chat.
What each part of a tool card means
Every card breaks a tool down into the pieces you need to call it correctly, or to review whether its schema is well-formed before shipping it.
The tool's identifier (what a client calls) and its human-readable description (what an LLM reads to decide when to use it). A missing or vague description is a common reason a model picks the wrong tool.
"name": "create_issue"
"description": "Create a new issue in a GitHub repository"Fields listed in the schema's required array. A call missing one of these will be rejected by the server before it runs. These are the fields you must always supply.
"required": ["owner", "repo", "title"]
→ owner, repo, and title are mandatory;
everything else in properties is optionalThe JSON Schema type of each parameter (string, number, boolean, array<string>, object, …). When a parameter is itself an object or an array of objects, the Inspector shows its inner fields indented underneath it.
"labels": {
"type": "array",
"items": { "type": "string" }
}
→ rendered as: array<string>When a parameter restricts its value to a fixed set (enum) or has a default, the Inspector lists the allowed values and the default so you know exactly what to pass, and what happens if you omit it.
"state": {
"type": "string",
"enum": ["open", "closed"],
"default": "open"
}The tools/list JSON format
The Inspector expects the shape an MCP server returns from a tools/list request: a top-level tools array, where each entry has a name, description, and JSON-Schema-based inputSchema.
// Standard JSON-RPC tools/list result
{
"tools": [
{ "name": "...", "description": "...", "inputSchema": { ... } }
]
}
// Wrapped in a JSON-RPC envelope (also accepted)
{
"result": {
"tools": [ { "name": "...", "inputSchema": { ... } } ]
}
}
// A bare array of tool objects (also accepted)
[
{ "name": "...", "description": "...", "inputSchema": { ... } }
]Within each inputSchema, the Inspector reads standard JSON Schema keywords: type, properties, required, description, enum, default, and items(for arrays). It does not validate against the full JSON Schema spec, it renders what's there.
When to use the MCP Server Inspector
| Situation |
|---|
| Validating your own server before shipping |
| Evaluating a third-party MCP server |
| Onboarding a teammate to a server's tools |
| Debugging a tool call that keeps failing |
| Reviewing an MCP server config in a PR |
Frequently Asked Questions
What is the MCP Server Inspector?
It's a free, browser-based tool that takes the raw JSON an MCP server returns from a tools/list call and renders it as a readable set of cards: one per tool, showing its name, description, input parameters, and which of those parameters are required.
There's nothing to install and nothing to run. You paste JSON, you get a readable breakdown. It's built specifically for the Model Context Protocol's tool schema format, not as a generic JSON viewer.
What is an MCP server, and what does tools/list return?
The Model Context Protocol (MCP) is an open standard for connecting AI applications, like Claude or an IDE assistant, to external tools and data sources. An MCP server exposes a set of "tools" that a client can call.
When a client connects to an MCP server, it sends a tools/list request and gets back a JSON response listing every tool the server exposes, each with a name, a description, and an inputSchema (a JSON Schema object describing what arguments the tool accepts).
{
"tools": [
{
"name": "search_files",
"description": "Search for files matching a pattern",
"inputSchema": {
"type": "object",
"properties": {
"pattern": { "type": "string", "description": "Glob pattern to match" },
"maxResults": { "type": "number", "default": 50 }
},
"required": ["pattern"]
}
}
]
}Does the Inspector send my JSON anywhere?
No. Everything happens in your browser with vanilla JavaScript: JSON.parse, schema walking, and DOM rendering. There's no backend, no API call, and nothing is logged or stored.
This matters because MCP server configs sometimes appear in PRs, internal docs, or Slack threads alongside other context you wouldn't want leaving your machine. The Inspector never makes that a concern: it works the same with the network disabled once the page has loaded.
How do I get the tools/list JSON from my MCP server?
If you're building the server, most MCP SDKs (TypeScript, Python) expose a way to call your own list_tools handler directly and print the result as JSON. For example, in the TypeScript SDK:
const response = await server.request(
{ method: "tools/list" },
ListToolsResultSchema
);
console.log(JSON.stringify(response, null, 2));If you're connecting to a third-party server, the official @modelcontextprotocol/inspector CLI can connect to it and show you the raw tools/list response, which you can then copy out and paste here for a faster, shareable visual breakdown.
How is this different from Anthropic's official MCP Inspector?
| Official MCP Inspector (CLI) | DevEncyclopedia's MCP Server Inspector | |
|---|---|---|
| Setup | Clone/run via npx, Node.js required | None, paste JSON in browser |
| Connects to a live server | Yes | No, paste-only |
| Best for | Deep, interactive debugging of a running server | Quickly reading and sharing a tool schema |
| Sharable output | No | Yes, paste JSON in a doc, PR, or chat alongside a screenshot |
| Account or install required | Local environment setup | No |
They solve different problems. The official Inspector is the right tool when you need to actually call a running server's tools and watch live request/response traffic. This Inspector is the right tool when you already have the JSON and just want to read it, or want to share a clean view of it with a teammate who isn't running anything locally.
What happens if my JSON is malformed or not an MCP response?
The Inspector tries JSON.parse first. If that fails, it shows you the parser's error message (for example, an unexpected token at a specific position) so you can find the typo.
If the JSON parses but doesn't look like an MCP tools/list response (no tools array, or it's empty), you'll get a plain-language message explaining what shape it expected instead of a blank screen or a stack trace.
Can it handle tools with nested object or array parameters?
Yes. When a parameter's schema is itself an object with properties, or an array of objects, the Inspector walks one level into that nested schema and renders the inner fields indented underneath the parent parameter, so you can see the full shape without expanding anything.