{{ resultsReady ? 'Configuration ready' : 'Check configuration' }}
{{ resultsReady ? server_name : 'Needs attention' }}

{{ summaryLine }}

Transport{{ transport }} Values{{ include_secrets ? 'Included' : 'Masked' }}
Share links carry only client, name, transport and OS. Connection details stay in this tab.
Optional strict JSON for the selected client. Other servers and settings are preserved; comments are unsupported. Imported content never enters the share link.
Off keeps same-name servers protected. On replaces only the selected server entry.
{{ replace ? 'On' : 'Off' }}
Off masks env, headers, credential keys and URL query values. On includes them in preview, copy and downloads.
{{ include_secrets ? 'On' : 'Off' }} 
{{ values.config_text }}
{{ values.setup_text }}
ClientConfig locationRoot keySelected transportCopy
{{ row.client }}{{ row.path }}{{ row.root }}{{ row.support }}

Chart unavailable. Client compatibility still lists the selected transport.

Tags: Devtools

Similar tools

A Model Context Protocol (MCP) server can let an AI assistant search project files, retrieve documentation or work with an issue tracker. MCP defines how the application discovers and requests these capabilities. The server is a program that may provide tools for actions, resources containing useful context, or reusable prompts. It can run on the same computer as the application or on a separate service.

The AI application is the host. Its MCP client handles communication with each server, while the server connects those requests to the underlying files or service. Adding a server therefore gives the application a way to request particular capabilities. It does not automatically give it unrestricted access to every file or account.

The transport determines how that communication happens. The server's connection instructions establish which transport to use.

Local process through stdio
The application starts a program and exchanges messages through its standard input and output streams. Configuration needs an executable, its arguments and sometimes environment variables. This suits a server that runs alongside the client, such as a filesystem integration.
Streamable HTTP
The application contacts an already running MCP service at a URL. This suits a hosted integration or a separately managed service, including one running locally. Credentials or a sign-in flow may be required.
Legacy SSE
The older HTTP transport uses Server-Sent Events (SSE) and remains relevant to older servers. Streamable HTTP replaced this transport and is the preferred choice when the server supports it. Streamable HTTP can itself use SSE response streams, so the deprecated feature is the older transport design, not all use of SSE.

A local filesystem server needs a real runtime and appropriate folder access. A remote documentation service needs a reachable MCP address and any required authorization. An ordinary website or general-purpose API does not become an MCP service merely because its URL appears in a configuration. Likewise, selecting a different transport does not change what a server actually supports.

Client configuration is separate from the protocol. Many clients store named settings as JavaScript Object Notation (JSON), a structured text format. Each application chooses where it stores server definitions, which keys it reads and whether settings apply to one project or a wider user profile. An example copied from another client can be valid JSON yet have the wrong structure or destination. A project configuration may also be shared with collaborators, so credentials need particular care.

Adding a server usually means adding one named entry alongside existing entries. Replacing the whole configuration file can remove other integrations, while reusing an existing server name can replace its definition. Keeping a backup and checking the intended name and scope prevents these mistakes.

Access credentials and server trust remain separate decisions. Environment variables and request headers can carry secrets, but storing a token in either place does not encrypt it. A local server can also contact external services. The server publisher, permitted folders, account permissions and client approval settings determine what access is appropriate; a well-formed configuration alone cannot establish that a connection is safe or operational.

How to Use This Tool:

Start with the server publisher's launch instructions or MCP endpoint and the application that will use it. The initial configuration is a Claude Code filesystem example for macOS; its sample folder must be replaced.

  1. Choose Client and Operating system, then enter a distinctive Server name. The selected client determines the JSON structure and setup destination.
  2. Select the Transport supported by the server.
    For a remote Claude Desktop server, use its custom connector interface. Selecting a remote transport with Claude Desktop stops JSON generation and explains this route.
  3. Enter the connection details. For stdio, put one executable in Command, one literal argument per line in Arguments, and optional NAME=value lines in Environment variables. For HTTP or legacy SSE, supply the real Server URL and optional Header: value lines in Request headers.
  4. Paste the current file into Merge into existing configuration under Advanced when adding to an existing setup. Use strict JSON for the selected client and leave Replace an existing server off unless replacement is intentional.
  5. Review Configuration file and the warnings in Setup instructions. Results update as you edit. If the summary says Check configuration, correct the reported input before output becomes available again.
  6. Copy or download the configuration after deciding how to supply private values. With Include private values off, restore masked values locally before using the file. Turning it on includes the entered values in the displayed and exported configuration.
  7. Save the reviewed configuration at the destination in Setup instructions, keeping a backup of any existing file. Follow the client-specific verification instruction to inspect the named server and complete any required sign-in.

Interpreting Results:

Configuration ready means the supplied inputs passed the generator's checks. It can still accompany warnings about sample paths, masked values, unencrypted HTTP or legacy SSE. The summary shows the first warning; Setup instructions includes the full set.

The compatibility table and transport chart describe configuration routes for the four included clients. Config supported means that the selected transport has a supported configuration form. Connector UI required means Claude Desktop uses a different setup route for remote servers. These indicators are neither live connection tests nor ratings of server quality.

Successful use still depends on the installed client version, an executable that starts correctly or a reachable MCP endpoint, and valid authorization. After installation, inspect the server's connection status and try an appropriate permitted operation. Generation does not install a runtime, run a server, authenticate an account or test network reachability.

Technical Details:

A server definition describes either a process to launch or a service to contact. Its surrounding JSON object tells the client where to find named servers. The executable and connection details can be similar across applications even when that surrounding structure differs.

Transformation Core

Local definitions contain command and an args array, plus env when environment variables are supplied. Remote definitions contain url, plus headers when supplied. The client and transport determine the remaining differences.

Client Server root Local stdio Remote HTTP or legacy SSE
Claude Code mcpServers "type": "stdio" "type": "http" or "type": "sse"
Claude Desktop mcpServers No type field Custom connector setup; no remote JSON entry generated
Cursor mcpServers "type": "stdio" No type field; both choices use a URL-based entry
VS Code native format servers "type": "stdio" "type": "http" or "type": "sse"

For Cursor, equal URLs and headers produce equal JSON for the two remote transport choices. The choice does not insert an explicit type field or convert the server. VS Code output specifically targets its native format; other formats and client-specific features are outside the generated entry.

Literal arguments and connection fields

Each nonblank argument line becomes one array element, in its original order. Spaces within a line remain part of that argument, including leading or trailing spaces. Quotes are retained as literal characters rather than removed as shell quoting. Blank and whitespace-only lines are discarded, so this input cannot express an empty argument. Shell expansion is not performed during generation.

Environment-variable lines split at the first equals sign. Names are trimmed and must start with an ASCII letter or underscore, followed by letters, digits or underscores. Values retain their whitespace and any later equals signs. Repeated names with the same capitalization are rejected. Header lines split at the first colon, trim the name and value, and require valid HTTP header names. Header duplicates are rejected regardless of capitalization.

A remote address must be an absolute HTTP or HTTPS URL without an embedded username or password. This checks URL structure, not the identity or behavior of the service. HTTP is accepted with an encryption warning; HTTPS is preferable when credentials or private data are involved. OAuth authorization, when required by the server, happens in the client.

Changing the operating system does not rewrite executable paths or arguments. On Windows, npx may require cmd as the command with /c and npx as the first two arguments.

Merging an existing configuration

A merge adds or replaces one named server inside the selected client's server object. It follows these rules before producing formatted JSON.

  1. Parse the import as a strict JSON object. Comments, trailing commas, an array at the top level, non-finite numbers and excessive nesting are rejected.
  2. Use the selected client's server root. If that root exists, it must contain an object. If it is absent, it can be added to an otherwise suitable object; a recognized different-client server root without the expected root is rejected.
  3. Keep other server entries and unrelated settings. A same-name entry blocks generation unless replacement is explicitly enabled. Replacement substitutes the whole selected entry, including removal of any old fields absent from the new definition.
  4. Apply the chosen masking policy to the complete merged document, then serialize it with two-space indentation. Original spacing is not preserved, and masking can alter values in imported entries as well as in the new entry.

Imported server definitions are not converted or checked to confirm that each definition works with the selected client. Two clients sharing mcpServers does not make every entry interchangeable.

Input boundaries

These are generator limits, not universal MCP limits. Each text limit applies separately to the named field and counts UTF-16 code units. Most common characters count as one; many emoji count as two.

Input Maximum length Additional rule
Server name 64 characters Only ASCII letters, digits, hyphens and underscores; at least one character
Command 1,000 characters Nonempty after trimming; no line breaks
Arguments, environment variables or request headers 10,000 characters each Blank lines are ignored; empty optional fields are allowed
Server URL 2,000 characters Required for a remote transport; HTTP or HTTPS only
Existing configuration 50,000 characters Optional strict JSON object with at most 30 nested levels

Configuration locations and scope

The destination determines where a server is available. These are the locations supplied for the supported configuration routes.

Client or platform Destination
Claude Code .mcp.json in the project root
Cursor .cursor/mcp.json in the project root
VS Code native format .vscode/mcp.json in the workspace root
Claude Desktop on macOS ~/Library/Application Support/Claude/claude_desktop_config.json
Claude Desktop on Windows %APPDATA%\Claude\claude_desktop_config.json
Claude Desktop on Linux Open Settings, then Developer and Edit Config; no fixed path is supplied

For Claude Code, retain the leading dot in .mcp.json. If a browser downloads it as mcp.json, rename it before placing it in the project root.

Optional registration commands appear only for Claude Code or VS Code on macOS or Linux when no configuration has been imported. Claude Code's command uses project scope. VS Code's code --add-mcp command writes user-profile configuration, which has a different scope from the workspace file above. No Windows registration command is generated. Client versions and organizational settings can change which configurations are accepted or enabled.

Privacy Notes:

Configuration generation happens in the browser without uploading the entered commands, connection details or imported configuration. The generator keeps these details in the current tab rather than saving them in browser storage. Running the resulting configuration later is a separate action governed by the chosen client's and server's behavior.

  • With Include private values off, every environment-variable and header value is replaced by REPLACE_WITH_LOCAL_VALUE. This includes non-secret values such as a folder variable or a content-type header, and applies to imported servers too.
  • Fields whose names contain credential terms such as token, password, secret, common spellings of apiKey, or authorization are also masked regardless of whether the original value is sensitive. Server names are kept. Recognized URL fields containing a parseable URL have all query values masked and any embedded credentials or fragment removed.
  • Masking is not a complete secret scan. Command and argument strings, URL paths and private information in other unrecognized fields can remain visible. Review the whole result before sharing it.
  • REPLACE_WITH_LOCAL_VALUE is literal replacement text, not an encrypted credential or a client-managed secret reference. Restore required values in your local file, or deliberately enable Include private values. Enabling it exposes those values in previews, copies, downloads and any generated registration command.
  • Share links retain only the client, server name, transport and operating system. They omit connection details, imported configuration, replacement permission and the private-value setting. Reopening a link restores those four choices with sample connection details rather than a complete working setup. A revealing server name can still disclose information through the link.

Worked Examples:

A local argument containing spaces

For a Cursor stdio server named docs-service, enter node as the command and two argument lines, /srv/mcp.js followed by folder with spaces. With no import or environment variables, the generated mcpServers object contains one docs-service entry with "type": "stdio", "command": "node" and "args": ["/srv/mcp.js", "folder with spaces"].

The two lines become two array elements; the second remains one argument. This assumes that the named script exists and accepts that argument. Adding shell quotes around the second line would put quote characters into the argument rather than protect its spaces.

Adding a remote server while retaining two local servers

Suppose a native VS Code configuration already contains servers named docs and files, and files has "env": {"ROOT": "/srv/shared"}. Import that configuration and add remote-docs with Streamable HTTP, an illustrative HTTPS address on example.com with path /mcp, query region=local and fragment #private and Authorization: Bearer example-token.

With private values masked, the result has three server entries. The new entry has "type": "http", the query becomes region=REPLACE_WITH_LOCAL_VALUE and the fragment is removed, and the authorization header becomes "Authorization": "REPLACE_WITH_LOCAL_VALUE". The existing ROOT value is masked too, even though it is a folder path. Restore the region, the complete authorization header value and the folder variable locally before use.

If the new server is instead named docs, the collision blocks generation. Choosing a new name retains both local servers; explicitly enabling replacement replaces the old docs definition and leaves two entries.

References: