Tutorials9 min read

How to Set Up MCP Servers with Claude Desktop: Complete Guide 2026

Step-by-step guide to connecting MCP servers to Claude Desktop. Learn how to configure filesystem, GitHub, database, and web search servers to supercharge your Claude workflow.

By MyMCPTools Team·

Claude Desktop is one of the most popular MCP-enabled AI clients, and for good reason — it supports a rich ecosystem of MCP servers that give Claude direct access to your files, databases, APIs, and tools. This guide walks you through everything you need to know to get MCP servers running with Claude Desktop in 2026.

Prerequisites

Before you start, make sure you have:

  • Claude Desktop installed (Mac or Windows) — download at claude.ai/download
  • Node.js v18+ installed (for npm-based MCP servers)
  • Python 3.10+ installed (for Python-based MCP servers)
  • A text editor for editing JSON config files

Where Is the Claude Desktop Config File?

Claude Desktop stores MCP server configuration in a JSON file. The location depends on your operating system:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

If the file doesn't exist yet, create it. If it does exist, you'll add your MCP servers to the mcpServers object.

The Configuration Format

Every MCP server is defined with a command and optional arguments and environment variables:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-name"],
      "env": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

After editing the config file, restart Claude Desktop for the changes to take effect.

Step 1: Add the Filesystem MCP Server (Start Here)

The filesystem server is the most universally useful MCP server — it gives Claude read and write access to files and directories on your machine.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Documents",
        "/Users/yourname/Projects"
      ]
    }
  }
}

Replace the paths with the directories you want Claude to access. You can specify multiple directories. Note: Claude can only access the directories you explicitly list — this is a security feature, not a limitation.

Test it: After restarting Claude Desktop, ask "Can you list the files in my Documents folder?" You should see Claude accessing your files directly.

Step 2: Add the GitHub MCP Server

The GitHub MCP server lets Claude browse repositories, manage issues, review pull requests, and search code — all without leaving the conversation.

First, create a GitHub Personal Access Token at github.com/settings/tokens with repo scope. Then add:

"github": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-github"],
  "env": {
    "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
  }
}

Test it: Ask Claude "What are the open issues in my [repo-name] repository?"

Step 3: Add the Brave Search MCP Server

Give Claude the ability to search the web for current information, documentation, and research.

Get a free Brave Search API key at api.search.brave.com, then add:

"brave-search": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-brave-search"],
  "env": {
    "BRAVE_API_KEY": "BSAyour_api_key_here"
  }
}

Test it: Ask Claude "Search for the latest news about Model Context Protocol."

Step 4: Add a Database Server (PostgreSQL or SQLite)

If you work with databases, these servers let Claude query your data directly.

For SQLite:

"sqlite": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "/path/to/your/database.db"]
}

For PostgreSQL:

"postgresql": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres"],
  "env": {
    "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/dbname"
  }
}

Test it: Ask Claude "What tables are in my database?" or "Show me the last 10 rows of the users table."

Your Complete Config Example

Here's a complete claude_desktop_config.json with all four servers configured:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/Documents"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": { "BRAVE_API_KEY": "BSA..." }
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "/path/to/db.sqlite"]
    }
  }
}

Troubleshooting Common Issues

Claude doesn't see my MCP servers

  • Restart Claude Desktop completely (quit, not just close the window)
  • Check the JSON config is valid (use a JSON linter)
  • Make sure Node.js is in your PATH

MCP server connection errors

  • Check the Claude Desktop logs at ~/Library/Logs/Claude/mcp*.log (macOS)
  • Run the install command manually in terminal to check for errors
  • Verify your API keys are correct

npx is slow on first run

npx downloads packages on first run. This is normal — subsequent runs are cached and fast. Use npm install -g to pre-install servers if you prefer.

What to Add Next

Once your basics are working, consider adding:

  • Memory MCP — persistent memory across conversations
  • Puppeteer MCP — browser automation and web scraping
  • Slack or Notion MCP — team collaboration tool access
  • AWS or Docker MCP — infrastructure management

Browse the full catalog at MyMCPTools.com to find servers for your specific stack.

Related guides:

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

📁

Filesystem

Secure file operations with configurable access controls. Read, write, and manage files safely.

Local
💻

GitHub MCP Server

The GitHub MCP server is GitHub's official Model Context Protocol integration, giving AI assistants like Claude and Cursor direct, authenticated access to the GitHub platform and its full developer surface. With this MCP server, you can ask your AI to read and write repository files, create and merge branches, open and review pull requests, comment on and close issues, trigger GitHub Actions workflows, search across code repositories with GitHub's code search, and inspect commit history — all through natural-language prompts in your AI interface. Developers use it to supercharge code review workflows, automate issue triage, generate PR descriptions from diffs, bulk-update repository settings, and wire AI agents into CI/CD pipelines. The GitHub MCP server connects via a GITHUB_PERSONAL_ACCESS_TOKEN environment variable with scopes for the operations you need, keeping authentication clean and auditable. Install with Docker: `docker run -e GITHUB_PERSONAL_ACCESS_TOKEN=<token> ghcr.io/github/github-mcp-server` — or configure it as a remote MCP server in Claude Desktop, Cursor, VS Code, Windsurf, and Cline. With over 8,000 GitHub stars, it is the most widely deployed official code-platform MCP server and the reference implementation for AI-native GitHub automation.

Auth required
🗄️

PostgreSQL MCP Server

The PostgreSQL MCP server is an official Model Context Protocol server maintained by Anthropic that gives AI assistants read-only access to PostgreSQL databases. By connecting Claude Desktop, Cursor, or VS Code to a running Postgres instance, developers can ask natural-language questions about their data schema, run exploratory SQL queries, inspect table structures, list available schemas, and analyze query results — all without leaving their AI chat interface. The server operates in read-only mode by design, preventing any accidental data mutations, making it safe to connect against production databases for reporting, debugging, and data exploration workflows. Core tools include executing SELECT queries, listing tables and schemas, describing column types and constraints, and inspecting indexes. Setup requires a running PostgreSQL instance and a standard connection string in postgres:// format. Install via npx using the @modelcontextprotocol/server-postgres package, passing your database URI as an argument. Teams use it to power data analysis conversations, generate schema documentation automatically, debug production data anomalies by asking Claude to inspect table contents, and build ad-hoc reports through natural-language SQL generation. Works with any PostgreSQL 12+ instance including Amazon RDS, Supabase, Neon, and self-hosted deployments.

Local
🗄️

SQLite MCP Server

The SQLite MCP server is an official Anthropic reference implementation that gives AI assistants direct, conversational access to SQLite databases — the world's most widely deployed database engine. Through natural language, you can ask Claude or Cursor to run SELECT queries, insert and update rows, inspect table schemas, create new tables, and generate business intelligence reports without writing a single SQL statement manually. Common use cases include exploring local data files, prototyping application schemas, auditing CSV imports, running ad-hoc analytics on app databases, and letting AI agents manage lightweight structured storage during agentic workflows. The server exposes tools for query execution, schema introspection, and memo-style business insights that synthesize query results into readable summaries. It requires a path to an existing .db file as a startup argument. Install with: npx @modelcontextprotocol/server-sqlite /path/to/your-database.db. Works with Claude Desktop, Cursor, VS Code, and all MCP-compatible clients. For developers who want AI to reason directly over structured data stored locally, the SQLite MCP server is the fastest path from question to answer without leaving your AI chat interface.

Local
🔍

Brave Search MCP Server

The Brave Search MCP Server is the official server from Brave that gives AI assistants privacy-first web search through the independent Brave Search API — no tracking, no profiling, and results drawn from Brave's own web index rather than Google or Bing. It exposes five distinct tools that map directly to the Brave Search API endpoints: brave_web_search for general queries with pagination, freshness filters, and safe-search controls; brave_local_search for businesses, restaurants, and points of interest with automatic location filtering; brave_news_search for recent articles and current events; brave_image_search for image discovery; and brave_video_search for finding videos across the web. Authentication uses a single BRAVE_API_KEY (free tier available at brave.com/search/api) or a mounted BRAVE_API_KEY_FILE for Docker-secret setups. Install in Claude Desktop, Cursor, Windsurf, or VS Code with one npx command and choose stdio or streamable-HTTP transport. Because Brave operates its own crawler and index, the Brave Search MCP server is a strong choice for developers who want an alternative to Google-dependent search tools, need reproducible non-personalized results, or care about data privacy in agent workflows — Claude can pull fresh web context, verify facts, and research topics without leaking queries to ad-tech pipelines.

Local
🌍

Puppeteer

Browser automation and web scraping with Puppeteer.

Local
🧠

Memory

Knowledge graph-based persistent memory system. Store and retrieve contextual information.

Local

📚 More from the Blog