How to Set Up MCP Servers for Claude Desktop

```html

Claude Desktop can read your local files, query your databases, and call your APIs—but only if you tell it how. Model Context Protocol servers are the bridge. You configure them once through a JSON file. After that, you can ask Claude to summarize a directory of research papers, analyze a SQLite database, or pull data from a REST API without leaving the conversation window.

Before You Start

MCP servers are small programs—Node.js or Python—that act as translators between Claude Desktop and your local resources. Claude speaks Model Context Protocol. Your filesystem, your Postgres database, your company's internal API—they don't. The MCP server sits in the middle and handles the translation.

Each server you install handles one type of resource. The filesystem server reads files. The SQLite server runs queries. The GitHub server pulls repository data. You can run several at once. Claude sees them as separate tools it can use during a conversation.

This guide starts with filesystem access because it's the most immediately useful: you can ask Claude to read a folder of PDFs, analyze a project's source code, or summarize meeting notes—all without uploading anything to a web interface. After that works, adding database or API servers follows the same pattern.

What You Need

• Claude Desktop version 0.7.0 or later (check Settings → About)
• Node.js 18+ or Python 3.10+ installed and accessible from command line
• Administrator access to edit system configuration files
• Basic command-line comfort—you'll run install commands and edit JSON
• Optional: database credentials if you plan to enable SQL query access

Step 1: Locate Your Claude Desktop Config Directory

Claude Desktop reads MCP server settings from a configuration file. The location depends on your operating system:

macOS: ~/Library/Application Support/Claude/

Windows: %APPDATA%\Claude\

Linux: ~/.config/Claude/

If the directory doesn't exist, create it. This is where Claude looks for claude_desktop_config.json—the file that defines which MCP servers to launch and what permissions to grant them.

Step 2: Install an MCP Server Package

The official MCP ecosystem includes pre-built servers for common use cases. Start with the filesystem server. Install it globally using npm:

npm install -g @modelcontextprotocol/server-filesystem

Verify installation: mcp-server-filesystem --version should return a version number. The server is now a command-line tool Claude Desktop can launch. It reads only from directories you explicitly configure—it cannot browse your entire system without permission.

Step 3: Create the Configuration File

Inside your Claude config directory, create claude_desktop_config.json. This file tells Claude Desktop which MCP servers to launch and what arguments to pass them.

Here's a minimal configuration that enables filesystem access to a single directory:

{ "mcpServers": { "filesystem": { "command": "mcp-server-filesystem", "args": ["/Users/yourname/Documents"] } } }

Replace /Users/yourname/Documents with the absolute path to the directory you want Claude to access. Use forward slashes even on Windows. Each server entry needs three things: a unique name, the command to launch it, and any arguments it requires.

What most setup guides skip: the name you choose ("filesystem" in this example) is how you'll refer to the server if you ever need to debug it or configure multiple instances. Make it descriptive if you plan to add more servers later.

Step 4: Restart Claude Desktop

Close Claude Desktop completely—quit from the menu bar or system tray, not just the window. MCP servers initialize only at startup. Configuration changes don't take effect until you relaunch.

When Claude Desktop reopens, it reads the config file and attempts to start each defined server in the background. If startup succeeds, you won't see a confirmation message. Claude just gains new capabilities. If startup fails, errors get logged to the developer console.

Step 5: Test the Connection

Open a new conversation and ask Claude to list files in the directory you configured: "What files are in my Documents folder?"

If the MCP server is running correctly, Claude responds with filenames. You can then ask follow-up questions: "Show me the contents of report.txt" or "Summarize all markdown files in this directory."

Claude reads files on-demand through the MCP server. Nothing uploads to Anthropic's servers during this process. The files stay local. The MCP server just gives Claude a way to read them when you ask.

Step 6: Add Additional Servers (Optional)

The configuration file supports multiple servers. To add database access or API integrations, install the corresponding package and add another entry to mcpServers.

Example with filesystem and SQLite access:

{ "mcpServers": { "filesystem": { "command": "mcp-server-filesystem", "args": ["/Users/yourname/Documents"] }, "sqlite": { "command": "mcp-server-sqlite", "args": ["/Users/yourname/data/app.db"] } } }

After editing the config file, restart Claude Desktop again. You can now ask Claude to query the database directly: "How many records are in the users table?" It will execute SQL queries through the SQLite MCP server and return results in the conversation.

Common Problems

Claude doesn't see the configured directory: Check that the path uses absolute notation—starts with / or C:\—and exists on your filesystem. Relative paths like ./Documents will fail. Verify JSON syntax. Missing commas or quotes break the entire config file.

Server fails to start silently: Open Claude Desktop's developer console—on macOS: Claude → View → Toggle Developer Tools—and check the Console tab for error messages. Common causes: the server command isn't in your system PATH, or permission issues reading the config directory.

"Command not found" errors: The MCP server package isn't installed globally or isn't accessible from command line. Re-run the npm install with -g, or specify the full path to the server executable in the command field: /usr/local/bin/mcp-server-filesystem.

Best Practices

• Grant filesystem access only to directories containing project files or documents you actively work with—not your entire home folder or system root
• Use separate MCP server instances for different projects by creating multiple config entries with descriptive names like "project-a-files" and "project-b-files"
• For database servers, create read-only database users with limited permissions rather than using admin credentials in the config file
• Version-control your claude_desktop_config.json in your dotfiles repository so you can replicate setups across machines
• Monitor the developer console during initial setup—early error messages save debugging time later

When Not to Use This

MCP servers are local-only. They can't access remote filesystems, cloud storage, or networked databases unless you mount those resources locally first. If you need Claude to interact with Google Drive files or AWS S3 buckets, you'll need to sync them to your machine or use API-based MCP servers that authenticate to those services.

MCP servers also run with the same permissions as Claude Desktop—they inherit your user account's file access. Don't configure them on shared computers or systems where you don't control all user accounts. For teams collaborating on AI-assisted workflows, consider centralized API integrations instead of individual MCP setups.

FAQ

Can I use the Claude code MCP server for development projects?

The filesystem MCP server handles code reading and analysis—there isn't a separate "code" server in the official MCP repository. Point the filesystem server at your project directory, and Claude can read source files, suggest refactors, or explain functions. For executing code, you would need a custom MCP server that implements a code execution environment with appropriate sandboxing.

How do I integrate Claude API with Google Sheets using MCP?

Claude Desktop's MCP implementation is separate from the Claude API—MCP servers extend the desktop application, not API integrations. To connect Claude API to Google Sheets, you would build a custom application that calls the Claude API and uses the Google Sheets API to read/write data. Some workflow automation tools like n8n support both APIs and can act as a bridge without custom code.

Can I use Claude artifacts to build a dashboard with MCP data?

Claude Desktop can read data through MCP servers and generate HTML/JavaScript artifacts that visualize it. Ask Claude to "Create a dashboard showing the file count by type in my Documents folder"—it will query the filesystem server, process the results, and generate an interactive artifact. The artifact runs in your browser and doesn't require ongoing MCP access after generation.

What happens if I configure multiple filesystem servers pointing at overlapping directories?

Each server operates independently—Claude sees them as separate data sources with different names. If you configure both "docs-folder" pointing at /Documents and "work-folder" pointing at /Documents/Work, Claude can access the Work subdirectory through either server. This redundancy doesn't cause errors but wastes system resources. Use non-overlapping paths unless you need isolated permission scopes.

```