How to Set Up Claude MCP Servers: Complete Configuration Guide (2026)

What MCP Is and How It Works

MCP uses a client-server architecture. Claude Desktop is the client (the "MCP Host"). Each MCP server is a separate process running on your machine that exposes a defined set of resources and tools over a local stdio or HTTP transport.

When you add an MCP server to Claude Desktop, Claude gains the ability to call that server's tools. For example, with the filesystem server connected, you can say "read my project's README" and Claude will call the `read_file` tool, receive the content, and respond with it without you manually pasting the file.

The protocol is model-agnostic by design. Servers built for Claude work with any LLM that implements the MCP client spec. As of March 2026, Claude 4, GPT-5.2 (via community adapters), and Gemini 3.1 Pro all have MCP client implementations.

Configuration File Location

MCP servers are configured in a JSON file. Claude Desktop reads this file on startup.

If the file does not exist, create it. Claude Desktop creates an empty config on first launch that you can edit.

Configure the Filesystem MCP Server

The filesystem server is the most broadly useful MCP server. It lets Claude read files, write files, list directories, and search for files within paths you explicitly allow. All access is restricted to the directories you specify, Claude cannot access paths outside your approved list.

Install and Configure

The filesystem server ships as an npx package. No separate installation is required, npx downloads and runs it on demand. Add it to your config file:

{
  "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. Add as many paths as needed, each additional path is another argument.

On Windows, use Windows-style paths with escaped backslashes:

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

Restart Claude Desktop

After saving the config file, quit and reopen Claude Desktop. Click the hammer icon (tools menu) in the chat input to confirm the filesystem server is listed. You should see tools including `read_file`, `write_file`, `list_directory`, `search_files`, and `get_file_info`.

Test the Connection

In a new Claude conversation, type:

List the files in my Documents folder

Claude will call the `list_directory` tool and return the directory contents. If you see a permission error, verify the path in your config matches the exact path on your system (case-sensitive on macOS).

Add Web Search with Brave Search MCP

The Brave Search MCP server gives Claude real-time web search capability. It calls the Brave Search API and returns structured results including title, URL, and snippet for each result.

Get a Brave Search API Key

1. Go to the Brave Search API developer portal 2. Create an account and select the free tier (2,000 queries/month, no credit card required) 3. Copy your API key from the dashboard

Add to Config

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/Documents"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key_here"
      }
    }
  }
}

Verify the Server

Restart Claude Desktop and open the tools menu. You should see the `brave_web_search` tool listed. Test it:

Search the web for the latest Claude model release news

Claude will call `brave_web_search`, receive results, and synthesise an answer from the search snippets. Unlike asking Claude without tools, this returns information from after its training cutoff.

Connect PostgreSQL and GitHub MCP Servers

These two servers cover the most common developer integrations: database access and repository management.

PostgreSQL MCP Server

The PostgreSQL server gives Claude read-only access to your database. It exposes the schema as resources and supports SQL query execution as a tool.

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

Replace the connection string with your database credentials. The server defaults to read-only mode, it cannot execute INSERT, UPDATE, DELETE, or DDL statements. This is intentional and cannot be changed in the official server.

Available tools: `query` (execute a SELECT statement), and resources exposing the database schema.

Test it: "Describe the structure of my database", Claude will call the schema resource and return table names, column definitions, and relationships.

GitHub MCP Server

The GitHub server lets Claude read repositories, files, issues, pull requests, and commits. With a write-scope token, it can also create files, branches, and pull requests.

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

Generate a token at GitHub Settings > Developer Settings > Personal Access Tokens > Fine-grained tokens. For read-only use, grant: Contents (read), Issues (read), Pull requests (read), Metadata (read).

Available tools: `get_file_contents`, `list_issues`, `get_pull_request`, `search_repositories`, `create_or_update_file`, `create_pull_request`.

Test it: "Show me the open issues in my repo owner/repo-name", Claude will call `list_issues` and return a formatted list.

Full Config with All Four Servers

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

Build a Simple Custom MCP Server in Python

The official MCP Python SDK (`mcp`) lets you build a custom server that exposes any tool or resource you need. This example builds a server that fetches live cryptocurrency prices from the CoinGecko public API.

Install the SDK

pip install mcp

Write the Server

Create a file `crypto_server.py`:

import asyncio
import httpx
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

app = Server("crypto-prices")

@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="get_crypto_price",
            description="Get the current USD price of a cryptocurrency by its CoinGecko ID (e.g. bitcoin, ethereum, solana)",
            inputSchema={
                "type": "object",
                "properties": {
                    "coin_id": {
                        "type": "string",
                        "description": "CoinGecko coin ID (lowercase, e.g. 'bitcoin')"
                    }
                },
                "required": ["coin_id"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "get_crypto_price":
        coin_id = arguments["coin_id"]
        async with httpx.AsyncClient() as client:
            r = await client.get(
                f"https://api.coingecko.com/api/v3/simple/price",
                params={"ids": coin_id, "vs_currencies": "usd"},
                timeout=10
            )
            data = r.json()
            if coin_id in data:
                price = data[coin_id]["usd"]
                return [TextContent(type="text", text=f"{coin_id}: ${price:,.2f} USD")]
            return [TextContent(type="text", text=f"Coin '{coin_id}' not found")]

async def main():
    async with stdio_server() as (read, write):
        await app.run(read, write, app.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

Register in Claude Desktop Config

{
  "mcpServers": {
    "crypto-prices": {
      "command": "python",
      "args": ["/absolute/path/to/crypto_server.py"]
    }
  }
}

Use the absolute path to the file. On Windows, use double backslashes: `C:\\Users\\yourname\\crypto_server.py`.

Test the Custom Server

Restart Claude Desktop and ask:

What is the current price of Bitcoin?

Claude will call `get_crypto_price` with `coin_id: "bitcoin"`, receive the live price from CoinGecko, and report it.

This pattern extends to any HTTP API, file format, or local service. The tool `description` field is what Claude reads to decide when to call the tool, write it clearly and specifically.

Using MCP Servers with the Claude API

Claude Desktop is the primary interface for MCP, but you can also use MCP servers programmatically via the Claude API. As of the Anthropic SDK v0.25+, the API supports connecting to MCP servers in Python and TypeScript applications.

Python SDK MCP Connection

import anthropic

client = anthropic.Anthropic()

# Connect to an MCP server and list its tools
with client.beta.messages.mcp_servers(
    servers=[
        {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp/data"]
        }
    ]
) as session:
    tools = session.list_tools()
    print(f"Available tools: {[t.name for t in tools]}")

    # Run a message with MCP tool access
    response = client.beta.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        messages=[{"role": "user", "content": "List the files in the data directory"}],
        mcp_servers=session.get_server_configs()
    )
    print(response.content[0].text)

When to Use API vs Claude Desktop

For building AI agents that use MCP tools in automated workflows, the Claude API with programmatic MCP connections is the correct approach. Claude Desktop is for interactive, human-in-the-loop use. The build AI agent with n8n guide shows an alternative approach using n8n's visual agent builder for automated MCP-like tool use without writing API code.

Troubleshooting

Frequently Asked Questions

{
  "mcpServers": {
    "remote-files": {
      "type": "sse",
      "url": "https://your-server.com/mcp/filesystem"
    }
  }
}

{
  "args": ["-y", "@modelcontextprotocol/server-filesystem@latest", "/your/path"]
}