SkillHub
Back to Home
MCP Start Guide

MCP Start Guide

Everything you need to connect Claude to external systems using the Model Context Protocol — from installing community servers to building your own.

What Are MCP Servers?

MCP (Model Context Protocol) servers are lightweight programs that expose external capabilities to Claude through a standardized protocol. They act as a bridge between Claude and the outside world — giving it the ability to read files, query databases, call APIs, search the web, and interact with any external system in real time.

What MCP servers can provide

Tools

Callable functions that Claude can invoke — running shell commands, writing files, sending API requests, or querying a database.

Resources

File-like data that Claude can read — documents, database records, API responses, or any structured content exposed as a URI.

Prompts

Reusable prompt templates that users can invoke through slash commands in Claude Desktop and other MCP clients.

MCP vs Skills: Skills provide procedural knowledge and workflows that live in your project. MCP servers connect Claude to live external systems in real time. Use Skills for repeatable reasoning patterns; use MCP for live data and actions.

How MCP Works

MCP uses a client-server model over a local connection. The MCP client (built into Claude Desktop or Claude Code) connects to one or more MCP servers you configure. Each server runs as a separate process on your machine.

1
Claude sends a request

When a task requires external data or an action, Claude calls a tool exposed by a connected MCP server.

2
The MCP server processes it

The server executes the requested operation — querying a database, calling an API, reading a file — and returns structured results.

3
Claude uses the result

The response is added to Claude's context. Claude reasons over the live data and continues the conversation.

Installation: Claude Desktop

Claude Desktop reads MCP server configuration from a JSON file on your machine. Edit the file, add your servers, and restart Claude Desktop.

Config file location

macOS
~/Library/Application Support/Claude/claude_desktop_config.json
Windows
%APPDATA%\Claude\claude_desktop_config.json
claude_desktop_config.json
{
  "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_your_token_here"
      }
    }
  }
}

Each key under mcpServers is a display name for the server (you choose it).

command is the executable to run (e.g. npx, python, node, or a path to a binary).

Restart Claude Desktop after editing the config file for changes to take effect.

Installation: Claude Code

Claude Code supports MCP servers via the claude mcp command or a project-level config file.

Add a server via CLI
# Add an npm-based MCP server
claude mcp add filesystem npx @modelcontextprotocol/server-filesystem /path/to/dir

# Add with environment variables
claude mcp add github \
  -e GITHUB_PERSONAL_ACCESS_TOKEN=ghp_token \
  npx @modelcontextprotocol/server-github

# List configured servers
claude mcp list

# Remove a server
claude mcp remove filesystem
.mcp.json (project-level config)
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    }
  }
}

Tip: Commit .mcp.json to your repository so the whole team shares the same MCP server configuration automatically.

Build Your Own MCP Server

The official SDKs make it straightforward to expose any function, data source, or API as an MCP server. Both TypeScript and Python are supported.

Minimal TypeScript MCP server
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-server", version: "1.0.0" });

// Register a tool
server.tool(
  "get_weather",
  "Get current weather for a city",
  { city: z.string().describe("City name") },
  async ({ city }) => {
    // Your logic here
    const data = await fetchWeather(city);
    return { content: [{ type: "text", text: JSON.stringify(data) }] };
  }
);

// Start listening on stdio
const transport = new StdioServerTransport();
await server.connect(transport);
Minimal Python MCP server
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    data = fetch_weather(city)  # your logic here
    return str(data)

if __name__ == "__main__":
    mcp.run()

1. Install the SDK

npm i @modelcontextprotocol/sdk or pip install mcp

2. Expose your logic

Register tools with clear names and descriptions so Claude knows when to call them.

3. Add to config

Point Claude Desktop or Claude Code at your server binary via the config file or claude mcp add.

Resources

Ready to explore MCP servers?

Browse our curated collection of MCP servers across every category — or submit one you built.

Browse MCP ServersSubmit Yours