Anthropic MCP Standard • 2026 Ready

Model Context Protocol (MCP) Config Generator

Visually configure, customize, and validate Model Context Protocol servers for Claude Desktop, Cursor IDE, Windsurf, and Cline. Choose from 22+ curated servers or add custom tools with real-time JSON preview and 1-click install paths.

100% Client-Side Privacy 22 Curated Servers Built-in CLI Inspector Auto OS Path Resolver
Interactive MCP Config Studio
Client-Side Sandbox
Config File Destination: ~/Library/Application Support/Claude/claude_desktop_config.json
Quick Stacks:

Local Filesystem

Anthropic Official npx

Secure file reading, writing, searching, and directory traversal on your local machine.

@modelcontextprotocol/server-filesystem
Absolute folder paths that the AI model is permitted to read and write.

GitHub

Anthropic Official npx

Search code, manage repositories, read and create pull requests, commits, and issues.

@modelcontextprotocol/server-github
Classic or Fine-grained token with repo, read:org, and user permissions.

Git (Local)

Anthropic Official uvx

Read, inspect, diff, commit, and branch local Git repositories without remote tokens.

mcp-server-git
Path to your local Git directory.

PostgreSQL

Anthropic Official npx

Query PostgreSQL databases, inspect schema definitions, and analyze table constraints.

@modelcontextprotocol/server-postgres
Standard PostgreSQL URI format.

SQLite

Anthropic Official uvx

Fast inspection and querying of local SQLite database files.

mcp-server-sqlite
Absolute path to the .sqlite or .db file on disk.

Brave Search

Anthropic Official npx

Give your AI assistant real-time web search and local queries via Brave Search API.

@modelcontextprotocol/server-brave-search
Free tier available at brave.com/search/api (2,000 queries/month free).

Fetch & Webpage Reader

Anthropic Official uvx

Fetches and converts public URLs and web pages into clean markdown for AI reading.

@modelcontextprotocol/server-fetch

Puppeteer Browser Automation

Anthropic Official npx

Headless Chromium browser automation: navigate web apps, click, take screenshots, and evaluate scripts.

@modelcontextprotocol/server-puppeteer

Playwright Automation

Community npx

Cross-browser interactive web automation, capturing screenshots and browser console logs.

@executeautomation/playwright-mcp-server

Memory & Knowledge Graph

Anthropic Official npx

Persistent memory using a dynamic knowledge graph. Retains concepts and relationships across sessions.

@modelcontextprotocol/server-memory

Sequential Thinking

Anthropic Official npx

Structured reasoning tool that facilitates step-by-step problem-solving, hypotheses testing, and revision.

@modelcontextprotocol/server-sequential-thinking

Docker Management

Community uvx

Manage Docker containers, inspect running services, view container logs, and inspect images.

mcp-server-docker

Sentry Error Tracking

Anthropic Official npx

Retrieve error issues, trace stack traces, and analyze crash telemetry directly inside AI chat.

@modelcontextprotocol/server-sentry
Generate an authentication token from sentry.io/settings/account/api/auth-tokens

Slack Workspace

Anthropic Official npx

Read channel history, search conversations, and send messages across your Slack team.

@modelcontextprotocol/server-slack
Bot token starting with xoxb- from api.slack.com/apps.
Your workspace ID found in Slack browser URL or workspace settings.

Google Drive

Anthropic Official npx

Read, search, and parse files, spreadsheets, and Google Docs stored in your Google Drive.

@modelcontextprotocol/server-google-drive
Google Cloud OAuth client credentials JSON file path.

Google Maps

Anthropic Official npx

Geocoding, navigation route calculation, place details, elevation, and distance matrix.

@modelcontextprotocol/server-google-maps
API key with Maps JavaScript & Geocoding APIs enabled.

GitLab

Anthropic Official npx

Interact with GitLab projects, merge requests, CI/CD pipeline statuses, and repository code.

@modelcontextprotocol/server-gitlab
Token with api scope from gitlab.com/-/user_settings/personal_access_tokens.
Custom self-hosted GitLab instance API URL if applicable.

Redis

Community uvx

Inspect in-memory key-value caches, query Redis keys, strings, hashes, and sets safely.

mcp-server-redis
Standard Redis URI.

MySQL

Community npx

Inspect schemas, table structures, and run SQL SELECT queries against MySQL databases.

mysql-mcp-server
MySQL URI string.

Tavily AI Search

Community npx

Real-time search engine tailored specifically for LLMs and autonomous research agents.

tavily-mcp
Get your API key at tavily.com.

Obsidian Markdown Vault

Community npx

Search, retrieve, and append notes to your local Obsidian markdown vault.

mcp-obsidian
Absolute path to your Obsidian markdown folder.

Reference Everything Server

Anthropic Official npx

Official reference MCP server providing mock tools, sample prompts, and dynamic resources for testing.

@modelcontextprotocol/server-everything
+ Add Custom MCP Server (Node, Python uvx, Docker)
claude_desktop_config.json 
{
    "mcpServers": {
        "filesystem": {
            "command": "npx",
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "~/Desktop"
            ]
        },
        "sequential-thinking": {
            "command": "npx",
            "args": [
                "-y",
                "@modelcontextprotocol/server-sequential-thinking"
            ]
        }
    }
}
Test in Terminal with MCP Inspector
npx @modelcontextprotocol/inspector npx -y @modelcontextprotocol/server-filesystem ~/Desktop

Zero Telemetry & Security Guarantee

Your credentials and paths remain entirely in your browser memory. Aiversely does not capture, store, or transmit your tokens. Generated files are written directly to your clipboard or local disk.

How to Install MCP Servers in 3 Simple Steps

Whether you are using Claude Desktop, Cursor IDE, or Windsurf, connecting external data to your AI model takes less than 2 minutes.

1

Select Your Tools

Choose from our catalog of verified MCP servers (Filesystem, GitHub, Postgres, Brave Search, etc.) and enter your local directory paths or API tokens.

2

Copy or Download Config

Click Copy JSON or Download to save the formatted configuration file directly to your computer.

3

Place in Config Path & Restart

Paste the configuration into your client's designated config path and restart the application. Your AI assistant will automatically discover the new tools.

Voice & AI Assistant Direct Answers (AEO / GEO)

Concise, spoken-length answers optimized for Google Voice Search, Siri, Perplexity, Gemini, and ChatGPT AI Overviews.

Hey Google, what is an MCP server?

An MCP server is a lightweight local or remote application that exposes tools, database connections, and file access to AI models like Claude Desktop and Cursor using Anthropic's open JSON-RPC 2.0 protocol.

Siri, where is the Claude Desktop config file on Mac?

On macOS, Claude Desktop stores its configuration at ~/Library/Application Support/Claude/claude_desktop_config.json. You can open it in Terminal using: open -e ~/Library/Application\ Support/Claude/claude_desktop_config.json.

How do I fix "spawn npx ENOENT" in Claude Desktop?

Replace "command": "npx" in your JSON config with the absolute path to your Node binary, such as /usr/local/bin/npx or /opt/homebrew/bin/npx on Mac, because desktop GUI apps do not inherit terminal shell PATH variables.

Can Cursor IDE use Claude Desktop MCP servers?

Yes. Cursor IDE fully supports the Model Context Protocol. You can add the exact same mcpServers JSON configuration to ~/.cursor/mcp.json globally or .cursor/mcp.json inside any project workspace.

Is it safe to connect my database to an MCP server?

Yes, when following least-privilege security. Always connect using a dedicated read-only database user with SELECT permissions only, and connect to local staging or development databases rather than production clusters.

What is the difference between stdio and SSE in MCP?

Stdio runs the server as a local background child process on your computer, while SSE connects over HTTP to remote or containerized servers hosted in cloud environments or Docker networks.

Top MCP Servers Comparison Matrix (2026 Developer Standards)

Evaluate runtime requirements, transport protocol, security boundary model, and typical execution latency across popular MCP servers.

MCP Server Category Runtime Transport Primary Capability Enterprise Security Boundary
@modelcontextprotocol/server-filesystem Core npx (Node.js) stdio File read, write, directory traversal Strict directory whitelist (blocks ../ traversal)
@modelcontextprotocol/server-github Developer npx (Node.js) stdio Repo search, pull requests, commit diffs GitHub PAT with granular repository scoping
@modelcontextprotocol/server-postgres Database npx (Node.js) stdio Schema introspection, SQL SELECT queries Read-only database role (GRANT SELECT only)
@modelcontextprotocol/server-brave-search Web & Search npx (Node.js) stdio Real-time web search without cookie tracking Stateless API queries, zero client profiling
@modelcontextprotocol/server-puppeteer Automation npx (Node.js) stdio Headless Chromium DOM scraping & screenshots Isolated browser sandbox, ephemeral memory
mcp-server-git Core uvx (Python) stdio Inspect commits, diffs, branches locally No external credentials required, local git scope
@modelcontextprotocol/server-sequential-thinking Core npx (Node.js) stdio Multi-step reasoning, hypothesis evaluation 100% in-process algorithmic logic, zero I/O access
mcp-server-docker DevOps uvx (Python) stdio Inspect containers, tail logs, service health Docker daemon socket permissions (/var/run/docker.sock)

The Definitive Guide to Model Context Protocol (MCP) in 2026

For years, integrating Large Language Models (LLMs) into real-world software engineering workflows felt like conversing with a brilliant savant trapped inside a sealed room. Developers had to manually copy-paste source code files into chat windows, transcribe terminal stack traces back and forth, screenshot broken web layouts, and hand-craft custom API bridges just to supply an AI assistant with the context required to solve a problem.

In 2026, the Model Context Protocol (MCP) has permanently rewritten this paradigm. Originally introduced as an open standard by Anthropic and rapidly adopted across the developer ecosystem—including Claude Desktop, Cursor IDE, Windsurf (Codeium), Cline, Zed, and Continue.dev—MCP has emerged as the universal "USB-C port" of artificial intelligence. Instead of building fragile, proprietary tool-calling connectors for every distinct model provider, engineers now connect standardized MCP servers that grant AI models safe, bi-directional access to local disk folders, remote codebases, PostgreSQL databases, Docker containers, and live headless browsers.

1. Architecture & Protocol Mechanics: How MCP Works Under the Hood

To understand why MCP is dominating AI tooling in 2026, it is helpful to contrast it with legacy LLM function calling. Traditional function calling (such as OpenAI Tools or Gemini Function Declarations) required application developers to write proprietary JSON schemas for every endpoint, manage state synchronization manually, and build custom authentication middleware.

MCP eliminates this fragmentation by implementing a standardized JSON-RPC 2.0 state machine. The architecture is defined by four core participants:

  • The MCP Host (Client Application): The user-facing software hosting the AI interaction—such as Claude Desktop, Cursor IDE, or Windsurf. The host is responsible for security policy enforcement, user confirmation dialogs, and rendering tool outputs.
  • The MCP Client: A protocol-compliant connector within the host application that manages a 1:1 stateful session with an external MCP server.
  • Transport Layer: MCP standardizes communication across two primary channels:
    • stdio (Standard Input / Standard Output): The host launches the server as a local child process (via npx, uvx, or docker) and exchanges JSON-RPC messages through standard I/O pipes. This is the fastest, lowest-latency transport for desktop workstations.
    • SSE (Server-Sent Events) over HTTP: The host connects to a persistent HTTP endpoint. This is ideal for remote microservices, enterprise cloud servers, and shared team tools.
  • The MCP Server: The background process that exposes real-world capabilities. A server exposes three distinct protocol primitives:
    • Resources: Passive, readable data sources (such as file contents, database schemas, or API documentation) that can be attached to conversations as context.
    • Tools: Executable functions (such as running a SQL query, creating a GitHub pull request, or executing a terminal command) that the AI model can invoke with user consent.
    • Prompts: Pre-packaged prompt workflows and specialized instructions designed by server authors to guide the model through complex tasks.
The Human-in-the-Loop Security Model
Unlike unsupervised autonomous agent frameworks that execute shell commands blindly, the Model Context Protocol enforces client-level confirmation dialogs. Whenever an AI assistant attempts to invoke an MCP tool (e.g., executing a database query or reading a directory), the host UI prompts the developer with the exact parameters before running the action.

2. Essential MCP Servers for Modern Developers in 2026

The open-source MCP ecosystem has matured rapidly, with over 300+ community and official servers available. For maximum engineering productivity, the following servers represent the baseline modern developer stack:

  • Local Filesystem (@modelcontextprotocol/server-filesystem): Provides scoped, sandboxed file system access. By explicitly specifying allowed directories (e.g. ~/Desktop, ~/Projects/app), Claude or Cursor can read package manifests, update source code, search directory trees, and review documentation without risking unauthorized disk access.
  • GitHub (@modelcontextprotocol/server-github): Allows AI models to search repositories, inspect open pull requests, review branch diffs, and create issue tickets directly from chat. Perfect for automated code reviews and multi-repo triage.
  • PostgreSQL (@modelcontextprotocol/server-postgres): Delivers live database introspection. Your AI assistant inspects table columns, foreign keys, indexes, and row constraints to generate accurate SQL migrations or explain complex queries with EXPLAIN ANALYZE.
  • SQLite (mcp-server-sqlite): Zero-configuration relational database analysis for local mobile, embedded, and desktop application data. Allows instant inspection of .sqlite and .db files without requiring active database container daemons.
  • Brave Search (@modelcontextprotocol/server-brave-search): Grants AI models access to real-time, privacy-preserving web search. Solves model knowledge cutoff issues and prevents hallucinations when writing code with bleeding-edge 2026 frameworks.
  • Puppeteer (@modelcontextprotocol/server-puppeteer): Spins up a headless Chromium browser instance capable of rendering client-side JavaScript, scraping dynamic single-page web applications, and capturing high-resolution DOM screenshots for visual bug debugging.
  • Docker (mcp-server-docker): Provides direct management of local Docker containers, images, and volumes. Enables AI assistants to inspect container exit codes, tail application service logs, monitor CPU/memory utilization, and restart failing microservices autonomously.
  • Slack Workspace (@modelcontextprotocol/server-slack): Bridges engineering reasoning with team communication channels. Allows AI agents to read customer incident reports, summarize discussion threads, and draft release announcements directly into team channels.
  • Sequential Thinking (@modelcontextprotocol/server-sequential-thinking): An algorithmic reasoning tool that prompts the model through structured, multi-step problem solving, hypothesis generation, and self-correction before generating final code.
Enterprise Proxy & Firewall Setup (Local Search & Corporate Networks)
In restricted enterprise environments with custom proxy gateways, MCP servers running via npx or uvx must inherit proxy variables. Add "HTTP_PROXY", "HTTPS_PROXY", and "NODE_EXTRA_CA_CERTS" into the server's "env" block to route requests through corporate security inspection appliances seamlessly.

3. Multi-Client Configuration Locations & Conventions

One of the greatest developer advantages of the Model Context Protocol is config portability. A single configuration object can be copied between different AI editors with minimal adjustments. Here are the exact file paths where configurations are stored across platforms:

  • Claude Desktop:
    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Windows: %APPDATA%\Claude\claude_desktop_config.json
    • Linux: ~/.config/Claude/claude_desktop_config.json
  • Cursor IDE:
    • Global: ~/.cursor/mcp.json (or %USERPROFILE%\.cursor\mcp.json on Windows)
    • Project Workspace: .cursor/mcp.json (stored in your repository root for team sharing)
  • Windsurf (Codeium):
    • Global: ~/.codeium/windsurf/mcp_config.json (or %USERPROFILE%\.codeium\windsurf\mcp_config.json)
  • Cline / Roo Code (VS Code Extension):
    • macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
    • Windows: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
  • Zed Editor:
    • Global: ~/.config/zed/settings.json (nested under the "context_servers" key)

4. Troubleshooting Critical MCP Failures

While MCP is engineered for reliability, desktop GUI environments frequently encounter edge-case configuration hurdles. Here are the five most common failure modes and their exact remediations:

Issue 1: "spawn npx ENOENT" Error on macOS and Windows
Root Cause: Desktop applications launched from Finder, Spotlight, or the Windows Start Menu run in a non-interactive GUI environment that does not execute .zshrc, .bash_profile, or NVM/Homebrew path initializers. As a result, the application cannot find the npx or node binary.
Fix: Run which npx (or where npx on Windows) in your terminal. Copy the absolute path (e.g. /opt/homebrew/bin/npx or /usr/local/bin/npx) and paste it into the "command" field of your MCP config file.
Issue 2: JSON Syntax Errors & Trailing Commas
Root Cause: Standard JSON specifications forbid trailing commas after the final key-value pair or array element. A single trailing comma causes Claude Desktop to fail silently or display a red config error on launch.
Fix: Use this visual MCP Config Generator to export validated, linted JSON, or validate your configuration with jq . claude_desktop_config.json before saving.
Issue 3: Python uvx Isolation & Package Caching
Root Cause: Servers running via Python (such as mcp-server-git) require the uv package manager. If uv is not installed or on PATH, the server will not launch.
Fix: Install uv via curl -LsSf https://astral.sh/uv/install.sh | sh (or brew install uv) to ensure uvx is globally accessible.
Issue 4: Docker Daemon Permission Denied
Root Cause: The Docker MCP server communicates with /var/run/docker.sock. If Docker Desktop is not actively running or your user account lacks read/write socket permissions, container inspection will fail.
Fix: Ensure Docker Desktop is running before launching your AI client, and verify socket permissions with docker ps.
Issue 5: API Key Exposure and Version Control Leaks
Root Cause: Storing project-level .cursor/mcp.json files containing raw secret tokens (GitHub PAT, Brave API keys, Slack tokens) inside Git repositories exposes credentials to unauthorized collaborators or public crawlers.
Fix: Add .cursor/mcp.json and all secret files to your repository's .gitignore, or supply sensitive keys through system environment variables.

5. The Future of MCP in 2026 and Beyond

The Model Context Protocol represents the definitive maturation of generative AI from conversational novelty to true engineering utility. With major IDEs converging on the protocol, developers now have the ability to assemble composable, modular toolchains that adapt to any underlying language model—whether using Claude 3.5 Sonnet, GPT-4o, DeepSeek V3, or locally hosted open-weight models via Ollama and LM Studio.

Looking ahead through 2026, the convergence of MCP with autonomous agent orchestration frameworks (such as CrewAI, AutoGen, and LangGraph) allows multi-agent swarms to delegate specialized operational tasks—one agent triaging GitHub pull requests, another running headless Puppeteer regression tests, and a third generating PostgreSQL schema migrations—all coordinated through standardized MCP JSON-RPC message passing.

Use the visual generator above to assemble, customize, and validate your development stack in seconds, and explore our LLM API Token Calculator to estimate monthly inference and tool execution costs accurately.

Model Context Protocol (MCP) Frequently Asked Questions

What is the Model Context Protocol (MCP)?
The Model Context Protocol (MCP) is an open-standard communication protocol developed by Anthropic (using JSON-RPC 2.0) that connects AI assistants—including Claude Desktop, Cursor, Windsurf, and Cline—to external systems such as local filesystems, GitHub, PostgreSQL databases, Docker containers, and live web browsers.
Where is claude_desktop_config.json located on my computer?
On macOS, it is at ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows, it is at %APPDATA%\Claude\claude_desktop_config.json. On Linux, it is at ~/.config/Claude/claude_desktop_config.json.
How do I add MCP servers to Cursor IDE or Windsurf?
Cursor reads MCP configuration from ~/.cursor/mcp.json (globally) or .cursor/mcp.json (per-project workspace). Windsurf reads from ~/.codeium/windsurf/mcp_config.json. Both follow the exact same mcpServers JSON schema as Claude Desktop.
How do I fix the "spawn npx ENOENT" error in Claude Desktop?
The "spawn npx ENOENT" error occurs because GUI desktop applications do not automatically inherit your terminal shell's $PATH environment. To resolve this, replace "command": "npx" with the absolute binary path to Node/npx on your system (e.g. /usr/local/bin/npx or /opt/homebrew/bin/npx on macOS, or C:\Program Files\nodejs\npx.cmd on Windows).
Can I run MCP servers using Python instead of Node.js?
Yes. Anthropic supports both TypeScript/Node and Python MCP servers. Many community servers (such as mcp-server-git, mcp-server-sqlite, and mcp-server-docker) execute via Python using uvx (part of the ultra-fast uv toolchain).
What is the difference between stdio and SSE transport in MCP?
Stdio (standard input/output) transport launches the MCP server as a local background subprocess on your workstation. SSE (Server-Sent Events) over HTTP connects your AI assistant to remote or containerized MCP servers running over local or cloud networks.
Are my API keys and local file paths safe when using this generator?
Yes, 100%. All configuration generation, token storage, and JSON formatting happens entirely client-side inside your browser. No API keys, database connection strings, or local paths are ever transmitted to or stored on Aiversely servers.
How do I test an MCP server before adding it to my desktop config?
You can test any MCP server using the official MCP Inspector by running: npx @modelcontextprotocol/inspector <command> <args>. This launches an interactive web UI at localhost:5173 where you can test prompts, resources, and tool executions.
Join WhatsApp Channel

My AI Toolkit

0 items saved in this browser