# Clone the repository
git clone https://github.com/YuzeHao2023/Awesome-MCP-Servers.git
cd Awesome-MCP-Servers

# View the full Excel list of 6000+ servers
# Open Full-List-of-MCP-Servers.xlsx

# Install mcp-get (CLI tool for installing MCP servers)
npm install -g @michaellatman/mcp-get

# Install mcp-cli (inspector for MCP servers)
npm install -g @wong2/mcp-cli

# Install yamcp (workspace manager)
npm install -g yamcp

# Filesystem server from modelcontextprotocol
npx @modelcontextprotocol/server-filesystem <allowed-directory>

# Official PostgreSQL MCP server
npx @modelcontextprotocol/server-postgres postgresql://user:password@localhost/dbname

# Install GitHub MCP server
npm install @github/github-mcp-server

# Configure in Claude Desktop (claude_desktop_config.json)
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@github/github-mcp-server"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

npx @modelcontextprotocol/server-gdrive

npm install @e2b/mcp-server

# Configure
{
  "mcpServers": {
    "e2b": {
      "command": "npx",
      "args": ["-y", "@e2b/mcp-server"],
      "env": {
        "E2B_API_KEY": "${E2B_API_KEY}"
      }
    }
  }
}

npm install @cloudflare/mcp-server-cloudflare

# Configure
{
  "mcpServers": {
    "cloudflare": {
      "command": "npx",
      "args": ["-y", "@cloudflare/mcp-server-cloudflare"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "${CLOUDFLARE_API_TOKEN}"
      }
    }
  }
}

# Persistent memory across conversations
npx @modelcontextprotocol/server-memory

# Extended reasoning capabilities
npx @modelcontextprotocol/server-sequentialthinking

# Search for servers
mcp-get search database

# Install a server
mcp-get install @modelcontextprotocol/server-postgres

# List installed servers
mcp-get list

# Remove a server
mcp-get remove @modelcontextprotocol/server-postgres

# Inspect a running MCP server
mcp-cli inspect http://localhost:3000

# List available tools from a server
mcp-cli tools @modelcontextprotocol/server-filesystem /path/to/dir

# Test a server
mcp-cli test @modelcontextprotocol/server-sqlite database.db

# Initialize a workspace
yamcp init

# Add a server to workspace
yamcp add filesystem --path /allowed/directory

# Start all workspace servers
yamcp start

# Stop all servers
yamcp stop

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@github/github-mcp-server"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

# .env file (never commit this)
DATABASE_URL=postgresql://user:pass@localhost/db
GITHUB_TOKEN=ghp_xxxxxxxxxxxxx
OPENAI_API_KEY=sk-xxxxxxxxxxxxx
CLOUDFLARE_API_TOKEN=xxxxxxxxxxxxx

# Load in shell
export $(cat .env | xargs)

# 1. Use official implementations when available (⭐ marked)
# 2. Review code before installation
git clone <mcp-server-repo>
# Review the code thoroughly

# 3. Run in isolated containers (Docker example)
docker run --rm -it \
  -v /allowed/path:/data:ro \
  --network=none \
  mcp-server-image

# 4. Limit permissions
chmod 500 /path/to/mcp-server  # Read + execute only
chown root:mcp /path/to/mcp-server

# 5. Monitor activity
# Enable logging in server config
{
  "mcpServers": {
    "myserver": {
      "command": "npx",
      "args": ["-y", "mcp-server", "--log-level", "debug"],
      "logFile": "/var/log/mcp/myserver.log"
    }
  }
}

# Search the Excel file or README for "database"
# Official options:
- PostgreSQL: @modelcontextprotocol/server-postgres
- SQLite: @modelcontextprotocol/server-sqlite
- MongoDB: @kiliczsh/mcp-mongo-server
- Redis: redis/mcp-redis (⭐)
- BigQuery: @LucasHild/mcp-server-bigquery

# Reference implementation
npx @modelcontextprotocol/server-filesystem /path/to/allowed/directory

# Fast implementation
npm install fast-filesystem-mcp

# With search capabilities
npm install mcp-everything-search

# AWS
# Check awslabs repositories under modelcontextprotocol

# Cloudflare (⭐)
npm install @cloudflare/mcp-server-cloudflare

# Azure
# Check Azure repositories for official MCP servers

# Brave Search (⭐)
npm install @modelcontextprotocol/server-brave-search

# AgentQL
npm install @tinyfish-io/agentql-mcp

# Fetch (reference)
npx @modelcontextprotocol/server-fetch

# 1. Find the server in the repository
# Browse categories in README or search Full-List-of-MCP-Servers.xlsx

# 2. Review the server (security check)
git clone <server-repo-url>
cd <server-repo>
cat README.md  # Check documentation
cat package.json  # Check dependencies

# 3. Install via mcp-get or npm
mcp-get install <server-package>
# OR
npm install <server-package>

# 4. Configure in Claude Desktop
# Edit claude_desktop_config.json
{
  "mcpServers": {
    "newserver": {
      "command": "npx",
      "args": ["-y", "<server-package>", "<args>"],
      "env": {
        "API_KEY": "${API_KEY}"
      }
    }
  }
}

# 5. Restart Claude Desktop
# Server should now be available

# Use mcp-cli to test
mcp-cli test <server-package> <args>

# Example: Test filesystem server
mcp-cli test @modelcontextprotocol/server-filesystem /tmp

# Check available tools
mcp-cli tools <server-package> <args>

# Inspect server metadata
mcp-cli inspect <server-package>

# Development config (dev_claude_config.json)
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/dev"]
    },
    "postgres": {
      "env": {
        "DATABASE_URL": "postgresql://localhost/dev_db"
      }
    }
  }
}

# Production config (prod_claude_config.json)
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/var/www"]
    },
    "postgres": {
      "env": {
        "DATABASE_URL": "${PROD_DATABASE_URL}"
      }
    }
  }
}

# Swap configs as needed
ln -sf ~/dev_claude_config.json ~/Library/Application\ Support/Claude/claude_desktop_config.json

# 1. Check config syntax
cat ~/Library/Application\ Support/Claude/claude_desktop_config.json | jq .

# 2. Verify server installation
npx <server-package> --help

# 3. Check server logs
# Add logging to config:
{
  "mcpServers": {
    "myserver": {
      "command": "npx",
      "args": ["-y", "server", "--verbose"]
    }
  }
}

# 4. Restart Claude Desktop completely
killall "Claude"
open -a "Claude"

# 1. Test server standalone
npx <server-package> <args>

# 2. Check permissions
ls -la $(which <server-binary>)

# 3. Verify environment variables are set
echo $GITHUB_TOKEN  # Should show token

# 4. Check for conflicting servers
# Remove other servers temporarily from config

# 5. Update server to latest version
npm update <server-package>

# 1. Search README by category
# Browse https://github.com/YuzeHao2023/Awesome-MCP-Servers

# 2. Search Excel file
# Open Full-List-of-MCP-Servers.xlsx
# Use Excel search/filter features

# 3. Use GitHub search
# Search within repository for keywords

# 4. Check official implementations first
# Look for ⭐ markers in README

# 5. Review community discussions
# Check Issues and Discussions tabs on GitHub

# 1. Limit server scope
# Example: Restrict filesystem access
{
  "filesystem": {
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/specific/path"]
  }
}

# 2. Use caching where available
# Check server documentation for cache options

# 3. Monitor resource usage
top -p $(pgrep -f mcp-server)

# 4. Consider lighter alternatives
# Check category for alternative implementations

# 1. Fork the repository
gh repo fork YuzeHao2023/Awesome-MCP-Servers

# 2. Add your server to appropriate category in README.md
# Format: - Name — URL

# 3. Create pull request
git checkout -b add-my-server
git add README.md
git commit -m "Add my-server to Category"
git push origin add-my-server
gh pr create