Integrations9 min read

MCP Integration Guide: Claude Desktop

Step-by-step guide to setting up MCP servers in Claude Desktop. Configure filesystem, database, web search, and custom MCP servers to give Claude live access to your tools and data.

By MyMCPTools Team·

Claude Desktop is Anthropic's native application for macOS and Windows, and it's the easiest way to get started with MCP servers. Unlike browser-based AI, Claude Desktop runs locally and can connect to MCP servers running on your machine — giving you direct, low-latency access to your files, databases, and local tools.

This guide covers everything from installing your first MCP server through advanced multi-server configurations.

Prerequisites

  • Claude Desktop installed (download from claude.ai/desktop)
  • Node.js 18+ installed (for most MCP servers) — verify with node --version
  • Python 3.10+ for Python-based MCP servers (optional)

Understanding the Configuration File

Claude Desktop reads MCP server configurations from 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 this file doesn't exist yet, create it. The basic structure is:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-name"],
      "env": {
        "OPTIONAL_ENV_VAR": "value"
      }
    }
  }
}

After any change to this file, restart Claude Desktop for the changes to take effect.

Adding Your First MCP Server: Filesystem

The filesystem MCP server is the ideal starting point — it gives Claude direct access to read and write files on your machine, with configurable directory restrictions.

Installation

Edit your claude_desktop_config.json to add:

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

The paths after the server name are the directories Claude is allowed to access. You can list multiple paths — Claude will only be able to read and write within those boundaries.

Verify It's Working

  1. Restart Claude Desktop
  2. Open a new conversation
  3. Ask Claude: "What files are in my Documents folder?"
  4. You should see Claude call a filesystem tool and return actual file listings

If you see a tool icon appear in the conversation, MCP is working.

Adding GitHub MCP Server

Give Claude access to your repositories — browse code, create issues, review PRs:

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

Generate a GitHub personal access token at github.com/settings/tokens — for read-only repo access, the repo scope is sufficient. For issue and PR creation, you'll also need write:issues.

What you can do once connected:

  • "Summarize the open PRs in my-repo that have been waiting for review over a week"
  • "Find all TODO comments in the src/ directory of my project"
  • "Create an issue for the authentication bug we discussed"
  • "What changed in the last 10 commits to main?"

Adding PostgreSQL MCP Server

Connect Claude to a local or remote PostgreSQL database:

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

By default, this server is read-only — Claude can query your database but cannot modify it. This is the safe default for most workflows.

What you can do:

  • "Show me the schema for the users table"
  • "How many new signups happened this week vs last week?"
  • "Write a query to find all orders that shipped more than 5 days after being placed"
  • "What are the top 10 most common error messages in the logs table?"

Adding Brave Search MCP Server

Give Claude the ability to search the web for current information:

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

Get a free Brave Search API key at brave.com/search/api — the free tier covers 2,000 queries/month, which is plenty for personal use.

Adding Memory MCP Server

The Memory MCP server gives Claude a persistent knowledge graph that persists across conversations — Claude can remember facts, relationships, and context between sessions:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Once active, you can tell Claude to remember things: "Remember that our database server is at 10.0.0.1" or "Note that the API requires auth tokens to be Base64-encoded." Claude will store these as entities in the knowledge graph and retrieve them in future conversations.

A Complete Multi-Server Configuration

Here's a full configuration for a developer's Claude Desktop setup:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Projects",
        "/Users/yourname/Documents"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
      }
    },
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_development"
      ]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_your_key"
      }
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Troubleshooting

MCP server not appearing in Claude

  • Check that you restarted Claude Desktop after editing the config file
  • Validate your JSON syntax — a single missing comma breaks the entire config
  • Verify Node.js is in your PATH: open Terminal and run which node

Server starts but tools don't work

  • Check that required environment variables are set correctly
  • For filesystem server, verify the paths you specified actually exist
  • For GitHub, verify your token has the necessary scopes

Viewing MCP logs

Claude Desktop writes MCP server logs to:

  • macOS: ~/Library/Logs/Claude/mcp*.log
  • Windows: %APPDATA%\Claude\logs\mcp*.log

Open these in Console.app (macOS) or a text editor to see detailed error output from your MCP servers.

Next Steps

Once you have the basics running, explore the full MCP server directory for servers that match your specific workflow. Popular additions for Claude Desktop users include Notion for knowledge management, Slack for team communication access, and Fetch for scraping web pages into context.

For editor-based workflows, see our guides on Cursor and VS Code MCP integration — the configuration patterns are similar but with editor-specific nuances.

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 MCP Server

sandboxed read, write, edit, move and search access to an explicit whitelist of local directories, and it is the reference implementation most other filesystem MCP servers are modelled on. Shipped by Anthropic in the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it is a Node.js server published to npm as @modelcontextprotocol/server-filesystem. The part worth understanding before you install is the access-control model, because there are now two ways to grant directories and they do not compose. Method one is command-line arguments: `npx -y @modelcontextprotocol/server-filesystem /path/one /path/two`. Method two, and the one the maintainers recommend, is MCP Roots — a client that supports the roots protocol sends its roots at initialization, and those roots COMPLETELY REPLACE any directories passed on the command line, then get replaced again on every `notifications/roots/list_changed`. That means allowed directories can change at runtime without restarting the server, but it also means a roots-capable client silently overrides your CLI arguments. If the server starts with no arguments and the client either does not support roots or sends an empty list, initialization throws an error. The tool surface is broad: `read_text_file` (with mutually exclusive `head`/`tail` line windows), `read_media_file` returning base64 image/audio content blocks, `read_multiple_files` which keeps going when individual reads fail, `write_file`, `edit_file`, `create_directory`, `list_directory`, `list_directory_with_sizes`, `move_file`, `search_files`, `directory_tree`, `get_file_info` and `list_allowed_directories`. `edit_file` is the one to learn — it does line-based and multi-line pattern matching with indentation detection and preservation, returns a git-style diff with context, and supports `dryRun: true` so you can preview a change before applying it; the maintainers recommend always running a dry run first. Every operation is refused outside the allowed set, and `list_allowed_directories` is the fastest way to confirm what the server actually believes it can touch.

Local
💻

GitHub MCP Server

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

Auth required📘
🗄️

PostgreSQL MCP Server

The PostgreSQL MCP server was the Model Context Protocol reference server for Postgres, and it is retired: the source now sits in modelcontextprotocol/servers-archived — a repository GitHub reports as archived, described as "Reference MCP servers that are no longer maintained" — and the npm package @modelcontextprotocol/server-postgres carries a deprecation notice reading "Package no longer supported." It still installs and still runs, which is why most third-party setup articles have not caught up. What it provides is deliberately small: a single tool, query, which executes read-only SQL inside a READ ONLY transaction, plus per-table schema information exposed as MCP resources at postgres://<host>/<table>/schema, with column names and data types discovered from database metadata. There is no index advice, no health check, no separate schema-listing tool, and no write mode. Install is npx @modelcontextprotocol/server-postgres with a postgres:// connection string as the argument. For active work against Postgres, the maintained alternative is Postgres MCP Pro (crystaldba/postgres-mcp), which exposes nine tools including index tuning against hypothetical indexes and a database health check, and has an explicit restricted access mode; if your database is hosted on Supabase or Neon, their platform servers add branching and logs that a raw Postgres connection cannot see. Reach for this archived server only when you want the smallest possible surface — one process, one read-only query tool, nothing else.

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
🌐

Fetch

Web content fetching and conversion for efficient LLM usage. Extract readable content from any URL.

Local
🧠

Memory

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

Local

📚 More from the Blog