Up to Date for 2026JSON-RPC 2.0Zero Syntax Errors

MCP Config & JSON Builder

Create error-free Model Context Protocol configurations from ready-made templates for Claude Desktop, Cursor IDE, Windsurf and Cline. Give your AI assistant database, file system, GitHub and live web search capabilities in one click.

One-Click Selection

11+ popular MCP templates

Live Validation

Valid JSON output as you go

Copy File Paths

macOS, Windows, Linux

Custom Server Support

npx, uvx, Docker, Python

Model Context Protocol (MCP) Standard

Choose the Target Client & IDE

Pick the environment your AI assistant runs in. The config file and the paths where it must be saved adjust automatically.

Claude Desktop config locations (claude_desktop_config.json)

Click to copy the path

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Windows

%APPDATA%\Claude\claude_desktop_config.json

Linux

~/.config/Claude/claude_desktop_config.json

MCP Server Pool

3 Active

11 server templates available

PostgreSQL ServernpxDatabase

Read schemas, run read-only queries and explore table relationships.

Command arguments (args):

Local File System (Filesystem)npxFile System

Lets the AI read and write files in the project folders you allow.

Command arguments (args):

GitHub IntegrationnpxDevOps & Git

Inspect and update repository contents, issues and pull requests directly.

Command arguments (args):

Environment variables & API keys (env):

GITHUB_PERSONAL_ACCESS_TOKEN:

Brave Search Web SearchnpxWeb & Search

Gives the AI up-to-date web search and news search.

SQLite DatabaseuvxDatabase

Query and analyze lightweight local SQLite files directly.

Puppeteer Browser AutomationnpxWeb & Search

Visit websites, run JavaScript and take screenshots.

Web Fetch & HTML ConverteruvxWeb & Search

Read web pages as clean text / markdown and pass them to the agent.

Local Git RepositoryuvxDevOps & Git

Inspect commit history, git log, diffs and branch status directly.

Memory (Knowledge Graph)npxProductivity & Reasoning

Store persistent memory and entity relationships across sessions.

Sequential Thinking (Chain of Thought)npxProductivity & Reasoning

Dynamic step-by-step reasoning for complex architecture analysis and problem solving.

Sentry Error TrackinguvxDevOps & Git

Query production runtime error logs, trace details and stack traces.

claude_desktop_config.jsonValid JSON

30 lines • 0.6 KB • 3 active servers

{
  "mcpServers": {
    "postgresql_server": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://user:password@localhost:5432/mydb"
      ]
    },
    "local_file_system__filesystem_": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop/project"
      ]
    },
    "github_integration": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PAT_TOKEN}"
      }
    }
  }
}

Claude Desktop setup instructions:

Copy the JSON above or download it directly as .json.
Save the file to the location for your operating system shown above (claude_desktop_config.json).
Quit Claude Desktop completely (Cmd+Q / Alt+F4) and start it again. You will see the hammer (tools) icon on the input screen.

A Guide to the Model Context Protocol (MCP), AI Agent Architecture and Integration

The biggest limitation in today's AI (LLM) ecosystem is that models sit in a closed box and cannot safely reach local data, file systems, databases or live APIs. The Model Context Protocol (MCP) is a universal protocol, announced by Anthropic as an open-source industry standard, that builds a secure two-way bridge between AI assistants and external developer tools. MCP Config & JSON Builder produces error-free, cross-platform (macOS, Windows, Linux), production-ready Model Context Protocol configurations for Claude Desktop, Cursor IDE, Windsurf and Cline.

1. What Is the Model Context Protocol (MCP) and Why Did It Become a Standard?

In the traditional setup, every AI tool (ChatGPT, Claude, IDE extensions) needed its own integration API to connect to sources such as a database or GitHub. That led to "N x M" complexity, duplicated code and serious security gaps.

The Model Context Protocol (MCP) brings a universal standard, much like HTTP/REST on the web or the Language Server Protocol (LSP) in developer tools. An MCP server written once runs as is in every MCP-compatible client, including Claude Desktop, Cursor IDE, Windsurf and Cline, without any code changes.

2. The Three Core Layers of MCP: Host, Protocol and Server

MCP is an open client-server model built on JSON-RPC 2.0 messaging:

1. Host / Client: The developer interface, such as Claude Desktop, Cursor IDE or Windsurf. It takes the user's query, orchestrates the LLM and decides which MCP server to call.
2. Protocol layer (Model Context Protocol): Carries Tools (function calls), Resources (file/data sources) and Prompts (ready-made templates) between the client and local services in a type-safe, permission-controlled way.
3. MCP Server: A lightweight CLI or background process running on the developer's machine. It starts on Node.js (npx), Python (uvx) or Docker and talks directly to a local PostgreSQL, Git or the file system.

3. Claude Desktop vs. Cursor IDE vs. Windsurf vs. Cline: Configuration Differences

All clients use the standard "mcpServers" JSON schema, but their file locations and sharing approaches differ:

Claude Desktop (Global System Configuration)

Stored in the operating system's application directory: ~/Library/Application Support/Claude/claude_desktop_config.json on macOS and %APPDATA%\Claude\claude_desktop_config.json on Windows. The servers defined there are active in every Claude session you open.

Cursor IDE (Per Project & Team-Oriented)

Can be stored in the project root as .cursor/mcp.json. That way the file can be committed to the Git repository and shared with teammates, so everyone works with the same database and analysis tools.

Windsurf (Cascade Agent Default Setting)

In the Codeium Windsurf editor it lives at ~/.codeium/windsurf/mcp_config.json. It gives the Cascade autonomous coding assistant direct terminal and external API capabilities.

Cline / Roo Code (VS Code Agent Extensions)

Stored in cline_mcp_settings.json in VS Code's globalStorage directory. You can watch each MCP server's live connection status from the extension panel.

4. Popular MCP Servers and Real-World Use Cases

The templates in this builder cover the capabilities developers need most often:

🐘 PostgreSQL & SQLite: Lets the model read the database schema, write complex SQL queries and produce data analyses.
📂 Local File System (Filesystem): Lets the AI read files, create new files and scan project code, but only inside the folders you allow.
🐙 GitHub & Git: Brings commit logs, diff summaries, issues and pull request status into the agent's context to prepare automated code reviews and PR descriptions.
🦁 Brave Search & Web Fetch: Gives models without internet access the ability to run live web searches and read technical docs as clean text.
🧠 Memory (Knowledge Graph): Remembers the project's architecture rules, database decisions and key variables across sessions, even after chat windows close.
⚡ Sequential Thinking & Sentry: Breaks complex algorithmic problems into step-by-step chains of thought; the Sentry integration inspects live production errors and stack traces.

5. Comparison: Traditional Agent Integrations vs. the Model Context Protocol (MCP)

Metric / Criterion	Traditional custom integrations	Model Context Protocol (MCP)
Ecosystem compatibility	A separate API per platform (silo)	One standard for every client (universal)
Maintenance and development cost	High (N x M integration effort)	Minimal (write once, run anywhere)
Client portability	Locked in (vendor lock-in)	Fully portable (Claude, Cursor, Windsurf, Cline)
Security and permission management	Complex, hard to audit	Least privilege and sandboxing
Startup & cold-start speed	Heavy server processes	Lightweight CLI processes (uvx / npx start instantly)

6. DevSecOps & Security: The Principle of Least Privilege

Security comes first when you let AI models run commands or access databases on your local machine:

Read-only database users: Instead of the production database user, define roles that only have SELECT permissions.
Restricted directories: Give the Filesystem server only the relevant project folder (/Users/username/Desktop/project) as an argument, not the whole disk root.
Environment variables: Define API keys under the "env" block instead of plain text, or feed them from environment variables (${API_KEY}).

7. Quick Setup, uvx vs. npx and Fixing Windows PATH Issues

The Python uvx advantage: uv and uvx, written in Rust by the Astral team, spin up virtual environments in milliseconds. Using uvx for Python-based servers (sqlite, git, sentry) removes startup delay.

The Windows PATH issue: On Windows, Claude Desktop sometimes cannot find the npx command directly. In that case, set "command": "cmd.exe" in the JSON with ["/c", "npx", ...] in args, or point to the full binary path, and the problem is solved in seconds.

8. Using It with Other Developer Tools

To strengthen your AI-focused development workflow, take a look at these companion tools as well:

.cursorrules Generator Dockerfile & Compose Builder API Mock Studio AI Git Commit Generator AI Function Calling Builder

I cover choosing a gateway for production in my MCP gateway comparison and the standard itself in my WebMCP post (both in Turkish).

Blog · Topics · FAQ

Frequently Asked Questions (FAQ)

The Model Context Protocol (MCP) is an open-source standard from Anthropic that lets AI clients such as Claude Desktop, Cursor and Windsurf connect securely to local files, databases or external APIs.

In Cursor projects, place the config file at .cursor/mcp.json in the project root. That way the whole team can use the same tools.

On macOS it is at ~/Library/Application Support/Claude/claude_desktop_config.json, and on Windows at %APPDATA%\Claude\claude_desktop_config.json.

Node-based servers run with npx, while lightweight Python-based servers start in an isolated environment within milliseconds using the uvx command from the Astral UV package manager.

Yes. With the "Custom Server" button in this tool you can add your own local scripts or community packages (npx, uvx, docker, python) to the JSON output in one click.