MCP Server Config Builder (claude_desktop_config.json) | RECATOOLS

How to Use the MCP Server Config Builder

Name the server

Pick a short, lowercase key for the server — this is the name it appears under inside mcpServers. Something like filesystem, github or postgres works well; it only needs to be unique within your config.

Set the command and arguments

Enter the executable that launches the server in Command (commonly npx, uvx, node or python), then add each argument on its own line — the package name, flags and any paths the server needs.

Add any environment variables

If the server needs secrets or settings, add them as KEY=value, one per line. These become the server's env block. Leave it blank if the server has none — the field is omitted automatically.

Copy or download into your config

Choose the full file or just the server entry, then copy the JSON or download config.json and merge it into your real claude_desktop_config.json. Everything builds in your browser — nothing is sent anywhere.

What the Model Context Protocol Config Actually Does

MCP connects your AI client to local tools and data

The Model Context Protocol (MCP) is an open standard that lets an AI client — Claude Desktop, an IDE assistant, or any MCP-aware app — talk to external servers that expose tools, files, and data. Instead of every integration being hard-coded into the app, MCP gives them a common language: the client launches a server, asks what it can do, and then calls those capabilities on your behalf. A filesystem server lets the assistant read and write files in a folder you choose; a database server lets it query your tables; a Git server lets it inspect a repository. The protocol is the plumbing; the servers are the muscles.

For desktop clients, the place all of this is wired up is a single JSON file. In Claude Desktop it is claude_desktop_config.json, and the most important key inside it is mcpServers. Each entry under that key is one server, identified by a name you choose, and described by up to three things: a command (the executable that starts it), an array of args (the arguments passed to that command), and an env object (environment variables, typically secrets and settings). When the client starts up, it reads this file, launches each configured server as a child process, and keeps a connection open for the duration of your session.

"A single misplaced comma or unquoted path is the difference between a working integration and a client that silently refuses to start. MCP config is just JSON — but it has to be valid JSON."

Why stdio servers, command, args and env are the whole story

The most common kind of MCP server is a stdio server: a local program that the client starts and then talks to over standard input and output. That is exactly why the config needs a command and args — they are literally the shell invocation the client will run, just expressed as structured JSON rather than a single string. Writing "command": "npx" with "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path"] is the JSON equivalent of typing npx -y @modelcontextprotocol/server-filesystem /path in a terminal. Splitting the arguments into an array avoids quoting headaches and makes paths with spaces safe.

The env object is where credentials live. Many servers need an API token, a connection string, or a setting like a log level; rather than baking those into the args where they would be awkward to manage, MCP passes them as environment variables scoped to that one server process. A GitHub server might take a personal access token; a database server takes a connection URL. Because these are real secrets, you keep this file out of version control and treat it like any other credentials file. This builder produces the exact shape Claude Desktop expects, with args and env omitted automatically when you leave them blank, so you can hand-author a clean entry, validate its structure, and paste it straight into your config without fighting brackets, commas, or quotes — and because it runs entirely in your browser, no tokens you type ever leave your machine.

10 Facts About MCP Servers

01

MCP (Model Context Protocol) is an open standard for connecting AI clients to external tools and data.

02

In Claude Desktop, servers are configured in claude_desktop_config.json under the mcpServers key.

03

Each server entry has a command, an optional args array, and an optional env object.

04

The most common server type is a stdio server — a local program the client launches and talks to over standard input/output.

05

command plus args is just a shell invocation expressed as JSON — npx -y server /path becomes structured fields.

06

Splitting arguments into an array avoids quoting problems and keeps paths with spaces safe.

07

Secrets like API tokens go in the env object, scoped to that one server process.

08

Many servers ship via npx or uvx, so no global install is needed — the client downloads and runs them on demand.

09

The config is plain JSON: a stray comma or unquoted path will stop the whole client from loading servers.

10

This builder runs entirely in your browser — any tokens you enter are never uploaded.

Frequently Asked Questions

It's a JSON entry that tells an MCP-aware AI client how to launch an external server. Each entry names the server and gives a command, optional arguments, and optional environment variables. In Claude Desktop these live in claude_desktop_config.json under the mcpServers key.
On macOS it lives in your Library Application Support folder for Claude; on Windows it's under your AppData Roaming Claude folder. The fastest way to find it is to open Claude Desktop's settings, go to the Developer section, and use the option to edit the config — it opens the exact file.
The full file wraps your server inside the mcpServers object — use it when you're creating the config from scratch. Just the entry gives you only the server's key and value, which is what you paste in when you already have a config and are adding one more server alongside others.
Put one argument per line, exactly as you'd type each token on the command line. For example npx -y @modelcontextprotocol/server-filesystem /path becomes three lines: -y, the package name, and the path. The builder turns them into a JSON args array for you.
Enter them as KEY=value, one per line. The first equals sign splits the key from the value, so values containing = are preserved. They become the server's env object, which the client passes to the server process as environment variables.
No. Only the command is required. If you leave arguments or environment variables blank, those keys are omitted from the JSON entirely, which keeps the config clean and matches what the client expects.
The builder runs entirely in your browser — nothing you type is sent to any server or third party, and nothing is stored. That said, treat the resulting file like any credentials file: keep it out of version control and don't share it, because it may contain real secrets in the env block.
It's the common kind of MCP server: a local program the client starts and then communicates with over standard input and output. That's exactly why the config needs a command and args — they tell the client which program to launch and how.
The server entry shape — command, args, env — is shared across most MCP clients, so the inner object is widely reusable. The wrapping key can differ between apps, so when targeting a different client, paste the entry and place it under that client's expected key. For Claude Desktop, the full file is ready to use as-is.
The two usual causes are invalid JSON (a trailing comma or a missing quote stops every server from loading) and a command the system can't find. Building the entry here guarantees valid JSON; after pasting it in, restart the client fully and make sure the command — such as npx or uvx — is installed and on your PATH.

Related News

You may be interested in these recent stories from our newsroom.

No related news yet for this tool. Our editorial team publishes new pieces every week.

Browse all news →

MCP Server Config Builder