Claude Code Club

MCP Config Generator

Generate a valid .mcp.json for the servers you want.

  • $39 Free
  • 60 sec
  • No signup
1

Pick the MCP servers you want

2

Fill in args and env placeholders

3

Copy the .mcp.json into your project

You get: A valid .mcp.json wired for the servers you selected.

Server config

Env vars (kept out of args)

.mcp.json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/dir"
      ]
    }
  }
}

Or one command

claude mcp add filesystem -s project -- npx -y @modelcontextprotocol/server-filesystem /path/to/dir

Project scope writes a shared .mcp.json in your repo. Never commit real secrets - reference them with env vars and keep values out of version control.

What an MCP config actually is

The Model Context Protocol (MCP) is how Claude Code talks to outside tools - a filesystem server, a database, a browser, an API. Every MCP server you want Claude Code to use has to be declared somewhere: either in a .mcp.json file or added through the claude mcp add command. This generator produces both from the same inputs so you can paste whichever your workflow prefers.

Most first-time MCP failures are not exotic - they are a comma in the wrong place, a missing type field on a remote server, or a secret pasted into args where it does not belong. Building the config by hand and copying it whole removes the entire class of JSON typos that make a server silently fail to load.

The three transports, and when to use each

  • stdio - a local process Claude Code launches itself (via a command like npx or a local binary). This is the most common transport for tools that run on your machine, like the filesystem or git servers.
  • SSE (Server-Sent Events) - a remote server you connect to over HTTP with a streaming channel. Use it for hosted MCP servers that expose an SSE endpoint.
  • HTTP - a remote server reached over standard HTTP. Use it for hosted servers that expose the streamable HTTP transport.

stdio uses command + args, remote uses url + type

The single most common shape mistake: a remote server needs a type field ('sse' or 'http') and a url. A stdio server needs command and args and does not use a url at all. Mixing the two is why a config 'looks right' but never connects.

Scopes: local, project, and user

  • local - the server is available only in the current project and only to you. Good for experiments and anything with a personal token.
  • project - the server is written to a .mcp.json committed in the repo, so every teammate who opens the project gets the same servers. Great for shared team tooling, but never put raw secrets here.
  • user - the server is available across all of your projects. Good for general-purpose tools you always want, like a browser or search server.

Handling secrets the right way

A funded API key committed to a shared .mcp.json is a real security incident, not a hypothetical. For stdio servers, pass secrets through the env block and reference environment variables rather than hardcoding values. For remote servers, prefer short-lived tokens and treat the auth header as sensitive. If you are using project scope, assume anything in the file will be read by everyone with repo access.

How to verify it worked

  1. Paste the .mcp.json into your project root (or run the CLI command).
  2. Restart Claude Code or reload the session so it re-reads the config.
  3. Run 'claude mcp list' to confirm the server is registered.
  4. Ask Claude Code what tools it has - a healthy server exposes its tools by name.
  5. If it does not appear, check the path in your args and confirm the command runs standalone in your terminal.

Common gotchas this generator prevents

  • Trailing commas and unquoted keys - JSON is strict, and a single trailing comma stops the whole file from parsing.
  • Relative paths that resolve differently than you expect - prefer absolute paths in filesystem-style args.
  • Forgetting the type field on remote servers, which makes Claude Code treat them incorrectly.
  • Putting secrets in args (visible in process lists and configs) instead of the env block.

Frequently asked questions

  • Where does the .mcp.json file go?

    For project scope it lives at the root of your repository so it is shared with the team. For local or user scope, Claude Code stores the configuration itself - you typically add those with the CLI rather than committing a file.

  • Should I use the JSON or the CLI command?

    They do the same thing. The CLI (claude mcp add) is fastest for a single server; the .mcp.json is better when you want the config version-controlled and shared. This tool emits both so you can pick.

  • Why does my remote server need a type field?

    Remote transports (SSE and HTTP) are distinguished by the type field plus a url. Without it, Claude Code cannot tell how to connect. Local stdio servers use command and args instead and do not need a url.

  • Is it safe to commit .mcp.json to git?

    The file itself is fine to commit for shared team servers. Real secrets are not - reference them through environment variables and keep the actual values out of the repo.

  • How do I pass an API key to a local server?

    Use the env block for stdio servers (or the -e flag on the CLI). That keeps the key out of the args list and lets you source the value from your environment rather than hardcoding it.

  • Does this send my config anywhere?

    No. This tool runs entirely in your browser. Nothing you type is uploaded, logged, or sent to any server - the config is generated locally and only copied when you click copy.

Liked this tool? The club is the next step.

Join Claude Code Club for $9/month. 650+ lessons, weekly updates, and the workflows behind every tool on this site.

  • No experience needed
  • Cancel anytime
  • Updated weekly
Join the club All tools