mcp.damato.design

This comprehensive guide shows you how to connect to the D’Amato Design MCP server at mcp.damato.design from all popular MCP-compatible AI clients and IDEs.

Quick Reference

Connection URL: https://mcp.damato.design/

Server Card: https://mcp.damato.design/.well-known/mcp/server-card.json

Prerequisites: Node.js 18+ with npm/npx installed (Download Node.js)

Table of Contents

Claude Desktop

Claude Desktop is Anthropic’s official desktop application with native MCP support. It uses mcp-remote to connect to remote HTTP MCP servers.

Prerequisites

Step-by-Step Setup

1. Install Claude Desktop

  1. Visit https://claude.ai/download
  2. Download the installer for your operating system
  3. Run the installer and follow the prompts
  4. Launch Claude Desktop and sign in with your Anthropic account

2. Verify Node.js Installation

Before configuring MCP, verify Node.js is installed:

Terminal window
node --version
# Should show v18.0.0 or higher


npx --version
# Should show a version number

If not installed, download from https://nodejs.org/

3. Locate the Configuration File

The location depends on your operating system:

macOS:

Terminal window
~/Library/Application Support/Claude/claude_desktop_config.json

To open quickly from Terminal:

Terminal window
open ~/Library/Application\ Support/Claude/claude_desktop_config.json

Windows:

%APPDATA%\Claude\claude_desktop_config.json

To open quickly from Run dialog (Win+R):

%APPDATA%\Claude\claude_desktop_config.json

Linux:

Terminal window
~/.config/Claude/claude_desktop_config.json

Note: If the file doesn’t exist, create it with an empty JSON object: {}

4. Edit the Configuration

Open the file in your text editor and add the MCP server configuration.

If the file is empty or new:

{
  "mcpServers": {
    "damato-design": {
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.damato.design/"
      ]
    }
  }
}

If you already have other MCP servers configured:

Add the new server to the existing mcpServers object:

{
  "mcpServers": {
    "existing-server": {
      "command": "npx",
      "args": ["some-mcp-server"]
    },
    "damato-design": {
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.damato.design/"
      ]
    }
  }
}

Save the file.

5. Restart Claude Desktop

  1. Completely quit Claude Desktop (not just close the window)
  2. Launch Claude Desktop again
  3. Wait 10-15 seconds for MCP servers to initialize

6. Verify the Connection

Look for indicators that the MCP server is connected:

  1. Connection Icon: You should see a 🔌 plug icon in the Claude Desktop interface, typically in the bottom left or in the chat input area
  2. Server List: Click the plug icon to see a list of connected servers. “damato-design” should appear in the list
  3. Status: The server should show as “Connected” with a green indicator

7. Test the Connection

Try asking Claude:

What projects has Donnie worked on related to design systems?

Or use the explicit prompt:

/ask-damato Tell me about your design token expertise

Claude should now be able to access resources from the D’Amato Design MCP server.

Troubleshooting Claude Desktop

“Server failed to start” or no plug icon appears:

  1. Check that Node.js is installed: node --version
  2. Verify JSON syntax in config file (use JSONLint)
  3. Check Claude Desktop logs:
  4. Try running manually: npx mcp-remote@latest https://mcp.damato.design/

“Server connected but no resources”:

  1. Wait 30 seconds - initial resource fetch may take time
  2. Check internet connection
  3. Verify the server card is accessible: curl https://mcp.damato.design/.well-known/mcp/server-card.json

Cursor IDE

Cursor is an AI-powered code editor with MCP support. It requires mcp-remote for connecting to remote HTTP MCP servers.

Prerequisites

Step-by-Step Setup

1. Install Cursor

  1. Visit https://cursor.so
  2. Download the installer for your OS
  3. Install and launch Cursor

2. Access MCP Settings

Method 1 - Via UI:

  1. Open Cursor
  2. Click the gear icon (⚙️) or press Cmd+, (Mac) / Ctrl+, (Windows/Linux)
  3. Navigate to Features → MCP
  4. Click “Add New MCP Server” or “Edit MCP Config”

Method 2 - Edit Config Directly:

The MCP configuration file location:

macOS/Linux:

Terminal window
~/.cursor/mcp.json

Windows:

%USERPROFILE%\.cursor\mcp.json

3. Add the Server Configuration

If the file is new or empty:

{
  "mcpServers": [
    {
      "name": "damato-design",
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.damato.design/"
      ]
    }
  ]
}

If you have existing servers:

Add the new server to the mcpServers array:

{
  "mcpServers": [
    {
      "name": "existing-server",
      "command": "npx",
      "args": ["some-other-server"]
    },
    {
      "name": "damato-design",
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.damato.design/"
      ]
    }
  ]
}

Note: Cursor uses an array (mcpServers: []) while Claude Desktop uses an object (mcpServers: {}). Don’t mix them up!

4. Restart Cursor

  1. Close all Cursor windows
  2. Quit Cursor completely:
  3. Relaunch Cursor

5. Verify the Connection

  1. Open Cursor’s AI chat panel (usually Cmd+L or Ctrl+L)
  2. Look for an MCP indicator or server list
  3. Check that “damato-design” appears in connected servers

6. Test the Connection

In Cursor’s AI chat, try:

@damato-design What design system projects are available?

Or ask naturally:

Show me Donnie's work on design tokens

Troubleshooting Cursor

Server not appearing:

  1. Verify JSON syntax (arrays vs objects matter in Cursor!)
  2. Check Node.js: node --version
  3. Restart Cursor completely (not just reload window)
  4. Check Cursor logs: Help → Toggle Developer Tools → Console tab

MCP config not found:

Create the directory first:

Terminal window
mkdir -p ~/.cursor
touch ~/.cursor/mcp.json

Cline (VS Code)

Cline is a VS Code extension that provides AI assistance with native HTTP MCP support (no mcp-remote wrapper needed).

Prerequisites

Step-by-Step Setup

1. Install VS Code (if needed)

  1. Visit https://code.visualstudio.com/
  2. Download and install for your OS
  3. Launch VS Code

2. Install Cline Extension

Method 1 - Via VS Code UI:

  1. Open VS Code
  2. Click Extensions icon in sidebar (or press Cmd+Shift+X / Ctrl+Shift+X)
  3. Search for “Cline”
  4. Click Install on the official Cline extension
  5. Wait for installation to complete

Method 2 - Via Command Line:

Terminal window
code --install-extension cline.cline

3. Configure the MCP Server

  1. Open Cline settings:

  2. Scroll to MCP Servers section

  3. Click “Add MCP Server”

  4. Fill in the form:

  5. Click Save or Add

Note: Cline supports HTTP MCP servers directly - you do NOT need to use npx or mcp-remote wrapper!

4. Verify the Connection

  1. Open the Cline panel (click Cline icon in sidebar)
  2. Look for a server status indicator
  3. You should see “damato-design” listed as connected
  4. A green dot or checkmark indicates successful connection

5. Test the Connection

Open a chat with Cline and try:

What design system projects has Donnie worked on?

Or reference the server explicitly:

Using the damato-design MCP server, tell me about design token architecture

Troubleshooting Cline

Server showing as disconnected:

  1. Check the URL is exactly: https://mcp.damato.design/ (with trailing slash)
  2. Test the endpoint directly: curl -X POST https://mcp.damato.design/ -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","method":"initialize"}'
  3. Check VS Code’s Output panel: View → Output → Select “Cline” from dropdown

Extension not loading:

  1. Reload VS Code window: Cmd+R / Ctrl+R or View → Command Palette → “Reload Window”
  2. Check for extension updates
  3. Verify VS Code version is up to date

Windsurf

Windsurf is an AI-powered IDE from Codeium with MCP support via command transports.

Prerequisites

Step-by-Step Setup

1. Install Windsurf

  1. Visit https://codeium.com/windsurf
  2. Download the installer for your operating system
  3. Run the installer
  4. Launch Windsurf

2. Open MCP Settings

  1. Click the Settings/Preferences icon (gear icon ⚙️)
  2. Navigate to AI → MCP Servers
  3. Or search settings for “MCP”

3. Add MCP Server

  1. Click “Add Server” or ”+” button

  2. Fill in the configuration:

    Name:

    damato-design

    Command:

    npx

    Arguments (one per line or comma-separated):

    mcp-remote@latest
    https://mcp.damato.design/

  3. Click Save or Apply

4. Restart Windsurf

  1. Close all Windsurf windows
  2. Quit the application completely
  3. Relaunch Windsurf
  4. Wait 15-20 seconds for MCP initialization

5. Verify Connection

  1. Open Windsurf’s AI chat panel
  2. Look for an MCP server indicator or settings
  3. Verify “damato-design” appears in the list of active servers
  4. Status should show “Connected” or similar

6. Test the Connection

Ask the AI assistant:

What are Donnie's recent projects in design systems?

Or use explicit prompting:

/ask-damato What's your experience with design tokens?

Troubleshooting Windsurf

Server not connecting:

  1. Verify Node.js: node --version and npx --version
  2. Test mcp-remote manually: npx mcp-remote@latest https://mcp.damato.design/
  3. Check Windsurf logs: Help → Show Logs
  4. Ensure arguments are entered separately (not as one string)

“Command not found” error:

Make sure npx is in your system PATH. Restart terminal/IDE after installing Node.js.

Zed Editor

Zed is a high-performance code editor with built-in MCP support through its assistant panel.

Prerequisites

Step-by-Step Setup

1. Install Zed

  1. Visit https://zed.dev/
  2. Download for your OS (macOS, Linux)
  3. Install and launch Zed

2. Locate Settings File

Zed stores settings in JSON format:

macOS:

Terminal window
~/.config/zed/settings.json

Linux:

Terminal window
~/.config/zed/settings.json

Open from Zed:

3. Add MCP Configuration

Edit ~/.config/zed/settings.json:

If file is new or has no assistant config:

{
  "assistant": {
    "mcp_servers": {
      "damato-design": {
        "command": "npx",
        "args": [
          "mcp-remote@latest",
          "https://mcp.damato.design/"
        ]
      }
    }
  }
}

If you have existing assistant config:

Add to the mcp_servers object:

{
  "assistant": {
    "mcp_servers": {
      "existing-server": {
        "command": "some-command",
        "args": ["..."]
      },
      "damato-design": {
        "command": "npx",
        "args": [
          "mcp-remote@latest",
          "https://mcp.damato.design/"
        ]
      }
    }
  },
  "other_settings": "..."
}

Save the file.

4. Restart Zed

  1. Quit Zed: Cmd+Q (Mac) or close all windows
  2. Relaunch Zed
  3. Wait a few seconds for initialization

5. Open Assistant Panel

  1. Press Cmd+? or Ctrl+? to open the assistant
  2. Or: View → Assistant Panel
  3. Look for MCP server status in the panel

6. Test the Connection

In the assistant panel, try:

What design system work has Donnie done?

Troubleshooting Zed

Settings not saving:

  1. Check JSON syntax with a validator
  2. Ensure file has proper permissions: chmod 644 ~/.config/zed/settings.json
  3. Look for error messages in Zed’s log: View → Developer → Open Log File

Assistant not showing MCP resources:

  1. Verify Node.js is accessible: which npx
  2. Try absolute path to npx: "command": "/usr/local/bin/npx"
  3. Check the assistant panel for error indicators

Continue (VS Code)

Continue is an open-source AI coding assistant for VS Code with MCP support.

Prerequisites

Step-by-Step Setup

1. Install VS Code

If not already installed:

  1. Download from https://code.visualstudio.com/
  2. Install for your OS

2. Install Continue Extension

  1. Open VS Code
  2. Go to Extensions (Cmd+Shift+X / Ctrl+Shift+X)
  3. Search for “Continue”
  4. Click Install on the Continue extension
  5. Wait for installation to complete

3. Locate Continue Config File

Continue stores its config separately from VS Code:

macOS/Linux:

Terminal window
~/.continue/config.json

Windows:

%USERPROFILE%\.continue\config.json

Create if missing:

Terminal window
mkdir -p ~/.continue
touch ~/.continue/config.json

4. Edit Configuration

Open ~/.continue/config.json in your editor:

If file is empty or new:

{
  "mcpServers": [
    {
      "name": "damato-design",
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.damato.design/"
      ]
    }
  ]
}

If you have existing configuration:

Add to the mcpServers array:

{
  "mcpServers": [
    {
      "name": "existing-server",
      "command": "npx",
      "args": ["some-server"]
    },
    {
      "name": "damato-design",
      "command": "npx",
      "args": [
        "mcp-remote@latest",
        "https://mcp.damato.design/"
      ]
    }
  ],
  "models": [...],
  "other_config": "..."
}

Save the file.

5. Restart VS Code

  1. Close all VS Code windows
  2. Quit VS Code completely
  3. Reopen VS Code
  4. Wait for Continue to initialize (10-15 seconds)

6. Verify Connection

  1. Open Continue sidebar (click Continue icon)
  2. Look for MCP server status
  3. Check that “damato-design” appears in available servers

7. Test the Connection

In Continue chat:

What are Donnie's projects related to design systems?

Troubleshooting Continue

Config file not found:

Create the directory and file manually:

Terminal window
mkdir -p ~/.continue
echo '{"mcpServers":[]}' > ~/.continue/config.json

Server not loading:

  1. Check Continue output: View → Output → Select “Continue” from dropdown
  2. Verify Node.js: node --version
  3. Test manually: npx mcp-remote@latest https://mcp.damato.design/
  4. Reload VS Code window: Cmd+R / Ctrl+R

MCP Inspector

The MCP Inspector is an official debugging tool for testing and introspecting MCP servers.

What is it?

A web-based interface for:

Usage

Start the Inspector

Terminal window
npx @modelcontextprotocol/inspector \
  npx mcp-remote@latest https://mcp.damato.design/

Access the Interface

Open your browser to:

http://localhost:6274

What You’ll See

  1. Server Info: Connection status, protocol version, capabilities
  2. Resources Tab: Browse all available resources
  3. Tools Tab: List of tools, try calling them
  4. Prompts Tab: Available prompts and their arguments

Testing Resources

  1. Go to Resources tab
  2. Click List Resources
  3. You should see resources like:
  4. Click a resource to read its content

Testing Tools

  1. Go to Tools tab
  2. Try the list_resources tool
  3. Or try get_resource with a URI like donnie://expertise/design

Testing Prompts

  1. Go to Prompts tab
  2. You should see ask_damato prompt
  3. Fill in the question argument
  4. Click Get Prompt to see the formatted prompt

Common Inspector Use Cases

Verify server is accessible:

Terminal window
npx @modelcontextprotocol/inspector npx mcp-remote@latest https://mcp.damato.design/

If it connects, your server is working!

Debug resource issues: Use the inspector to see exactly what resources are returned and test reading them.

Test before configuring clients: Verify everything works in the inspector before adding to Claude/Cursor/etc.

Custom Integrations

Using the MCP SDK (Node.js)

For building your own MCP client applications:

Installation

Terminal window
npm install @modelcontextprotocol/sdk

Basic Client Example

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';


// Create client
const client = new Client({
  name: "my-custom-client",
  version: "1.0.0"
});


// Create transport using mcp-remote
const transport = new StdioClientTransport({
  command: "npx",
  args: ["mcp-remote@latest", "https://mcp.damato.design/"]
});


// Connect
await client.connect(transport);


// List available resources
const resources = await client.listResources();
console.log("Available resources:", resources);


// Read a specific resource
const resource = await client.readResource({
  uri: "donnie://expertise/design"
});
console.log("Resource content:", resource.contents[0].text);


// Call a tool
const result = await client.callTool({
  name: "get_llms_txt",
  arguments: {
    subdomain: "donnie"
  }
});
console.log("Tool result:", result);

Direct HTTP / JSON-RPC

For languages without an MCP SDK, use direct HTTP requests:

Initialize Connection

Terminal window
curl -X POST https://mcp.damato.design/ \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2024-11-05",
      "capabilities": {},
      "clientInfo": {
        "name": "my-client",
        "version": "1.0.0"
      }
    }
  }'

List Resources

Terminal window
curl -X POST https://mcp.damato.design/ \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "resources/list"
  }'

Read a Resource

Terminal window
curl -X POST https://mcp.damato.design/ \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "resources/read",
    "params": {
      "uri": "donnie://expertise/design"
    }
  }'

List Tools

Terminal window
curl -X POST https://mcp.damato.design/ \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 4,
    "method": "tools/list"
  }'

Call a Tool

Terminal window
curl -X POST https://mcp.damato.design/ \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 5,
    "method": "tools/call",
    "params": {
      "name": "get_llms_txt",
      "arguments": {
        "subdomain": "donnie"
      }
    }
  }'

Using the Server

Available Resources

Resources follow the URI pattern: {subdomain}://{category}/{slug}

Examples:

Categories by subdomain:

donnie:

blog:

system:

Viewing All Resources

Terminal window
curl -X POST https://mcp.damato.design/ \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"resources/list"}' | jq '.result.resources'

Or check the server card:

Terminal window
curl https://mcp.damato.design/.well-known/mcp/server-card.json | jq

Using the /ask-damato Prompt

When you have multiple MCP servers connected, the /ask-damato prompt helps you explicitly query this server.

In Claude Desktop or compatible clients:

/ask-damato What are your latest projects?
/ask-damato Tell me about your design token expertise
/ask-damato What media appearances have you done recently?

This ensures the AI searches through D’Amato Design resources specifically.

Available Tools

get_resource

Get a specific resource by URI.

Parameters:

Example:

{
  "name": "get_resource",
  "arguments": {
    "uri": "donnie://projects/compass"
  }
}

list_resources

List all available resources from all subdomains.

Parameters: None

Example:

{
  "name": "list_resources",
  "arguments": {}
}

get_llms_txt

Get the raw llms.txt file for a subdomain.

Parameters:

Example:

{
  "name": "get_llms_txt",
  "arguments": {
    "subdomain": "donnie"
  }
}

Troubleshooting

General Issues

”Cannot connect to MCP server”

Check Prerequisites:

Terminal window
# Verify Node.js is installed
node --version  # Should be v18.0.0 or higher


# Verify npx works
npx --version


# Test mcp-remote directly
npx mcp-remote@latest https://mcp.damato.design/

If Node.js is not installed:

  1. Download from https://nodejs.org/
  2. Install the LTS version
  3. Restart your terminal/IDE
  4. Verify: node --version

If npx is not found:

”No resources available”

Causes:

  1. Initial fetch delay: Resources are fetched from source domains on first request
  2. Network issues: Source domains may be temporarily unavailable
  3. Cache warming: First connection may take 10-30 seconds

Solutions:

  1. Wait 30 seconds and try again
  2. Check internet connection
  3. Verify source domains are accessible:
    Terminal window
    curl https://donnie.damato.design/llms.txt
  4. Check server card:
    Terminal window
    curl https://mcp.damato.design/.well-known/mcp/server-card.json

“Resource read failed”

Check the resource exists:

Terminal window
curl -X POST https://mcp.damato.design/ \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"resources/list"}'

Verify URI format:

Try MCP Inspector:

Terminal window
npx @modelcontextprotocol/inspector npx mcp-remote@latest https://mcp.damato.design/

Client-Specific Issues

Claude Desktop

Server doesn’t appear in list:

  1. Check JSON syntax: https://jsonlint.com/
  2. Ensure file is saved
  3. Completely quit (Cmd+Q/Alt+F4) and restart
  4. Check logs:

“Failed to start MCP server”:

  1. Test manually: npx mcp-remote@latest https://mcp.damato.design/
  2. If that fails, check Node.js installation
  3. Try clearing npm cache: npm cache clean --force

Cursor

MCP servers not loading:

  1. Verify config file exists: cat ~/.cursor/mcp.json
  2. Check it’s an array not an object
  3. Restart Cursor (quit completely)
  4. Check Developer Console: Help → Toggle Developer Tools

“Command not found: npx”:

VS Code Extensions (Cline, Continue)

Extension not loading:

  1. Check extension is enabled: Extensions panel
  2. Reload window: Cmd+R / Ctrl+R
  3. Check for conflicting extensions
  4. View extension output: View → Output → Select extension

Config file issues:

  1. Create directory if missing:
    Terminal window
    mkdir -p ~/.continue  # or ~/.cline
  2. Check file permissions
  3. Validate JSON syntax

Zed

Settings not taking effect:

  1. Ensure you’re editing the right file: ~/.config/zed/settings.json
  2. Check JSON syntax
  3. Look for error messages: View → Developer → Open Log File
  4. Try absolute path to npx

Network & Firewall Issues

Corporate Firewall: If behind a corporate firewall, the MCP server may be blocked:

  1. Ask IT to whitelist: mcp.damato.design
  2. Test connection: curl https://mcp.damato.design/.well-known/mcp/server-card.json
  3. Check proxy settings in your client
  4. Try using a VPN if permitted

Proxy Configuration: If you’re behind a proxy, npx may need proxy settings:

Terminal window
# Set npm proxy (affects npx)
npm config set proxy http://proxy.company.com:8080
npm config set https-proxy http://proxy.company.com:8080


# Or use environment variables
export HTTP_PROXY=http://proxy.company.com:8080
export HTTPS_PROXY=http://proxy.company.com:8080

SSL Certificate Issues: Some corporate networks intercept HTTPS traffic:

Terminal window
# If you see SSL errors, you may need to configure npm
npm config set strict-ssl false  # Use with caution!


# Better: Add your corporate CA certificate
npm config set cafile /path/to/ca-cert.pem

Connection Timeout: If connections are timing out:

  1. Check your internet connection
  2. Verify DNS resolution: nslookup mcp.damato.design
  3. Try a different network
  4. Check if your antivirus is blocking connections

Getting Help

Still having issues?

  1. Test the server directly:

    Terminal window
    curl https://mcp.damato.design/.well-known/mcp/server-card.json

    If this fails, the issue is network-related.

  2. Use MCP Inspector:

    Terminal window
    npx @modelcontextprotocol/inspector npx mcp-remote@latest https://mcp.damato.design/

    This helps isolate whether the issue is with the server or your client.

  3. Check client logs:

  4. Verify Node.js version:

    Terminal window
    node --version  # Should be v18.0.0 or higher

  5. Try with a fresh config:

Common Error Messages Decoded:

ErrorMeaningSolution
ECONNREFUSEDCan’t connect to serverCheck network, firewall, URL
ENOTFOUNDDNS resolution failedCheck internet, DNS settings
ETIMEDOUTConnection timeoutCheck firewall, proxy settings
Command not found: npxNode.js not installedInstall Node.js from nodejs.org
Invalid JSONConfig syntax errorValidate JSON at jsonlint.com
Server failed to startnpx/mcp-remote issueTest manually: npx mcp-remote@latest https://mcp.damato.design/

Learn More

Documentation

About This Server

This MCP server provides access to:

Resources are dynamically fetched from multiple subdomains and cached for performance.

Last Updated: December 2024
Server Version: 1.0.0
Protocol Version: 2024-11-05