Global MCP Servers: Cross-Project AI, Instant Scaling

What is Global MCP Servers: Cross-Project AI, Instant Scaling?

Global MCP Servers are a collection of open-source tools enabling Large Language Models (LLMs) like Claude to interact with external services through the Model Context Protocol (MCP). These servers act as bridges between AI systems and platforms such as ComfyUI for image generation, GitHub for repository management, Brave Search for web queries, and Supabase for database operations. The system supports cross-project workflows and dynamic scaling to handle varying workloads efficiently.

How to Use Global MCP Servers: Cross-Project AI, Instant Scaling?

Installation involves cloning the repository and running a setup script that configures servers globally on your system:

git clone https://github.com/ChipsMetaverse/mcp-servers.git
cd mcp-servers
./bin/setup-global-mcp.sh

Optional environment variables or manual edits to ~/.cursor/mcp.json can configure API keys. After setup, restart your LLM interface (e.g., Cursor or Claude Desktop) for the servers to become available. Individual servers can also be launched manually for targeted workflows.

Key Features of Global MCP Servers: Cross-Project AI, Instant Scaling?

• Cross-Service Integration: Unify access to ComfyUI, GitHub, Brave Search, and Supabase via a single protocol.
• Instant Scaling: Deploy servers on-demand without manual configuration overhead.
• Modular Design: Run individual servers or full stacks based on project needs.
• Security-First: API keys are stored securely in configuration files or environment variables.
• Lightweight: Built with Node.js, requiring minimal system resources to operate.

Use Cases of Global MCP Servers: Cross-Project AI, Instant Scaling?

• AI-Powered Image Generation: Automate ComfyUI workflows for creative projects using LLM-driven prompts.
• GitHub Automation: Let LLMs manage repositories, issues, and pull requests without manual intervention.
• Web Research: Query Brave Search APIs to gather real-time data for AI analysis.
• Data Analysis: Execute SQL queries against Supabase databases for AI-driven insights.

FAQ from Global MCP Servers: Cross-Project AI, Instant Scaling?

• Do I need Node.js? Yes, Node.js v16+ is required to run servers. Install via NodeSource or your package manager.
• How do I troubleshoot connectivity issues? Verify API keys, check server requirements (e.g., ComfyUI must run on localhost:8188), and ensure scripts have execute permissions.
• Can I add custom servers? The modular architecture allows extending the system with new MCP server implementations.
• What if my LLM doesn’t recognize servers? Confirm Cursor/LLM integration is enabled and restart your interface after configuration changes.

Global MCP Servers

This repository contains a collection of Model Context Protocol (MCP) servers that can be installed globally on your system. These servers allow LLMs like Claude to interact with various external services.

Included Servers

• ComfyUI - Interact with the ComfyUI stable diffusion interface for image generation
• GitHub - Perform operations on GitHub repositories, issues, and pull requests
• Brave Search - Search the web using the Brave Search API
• Supabase - Run SQL queries against a Supabase database

Installation

To install all MCP servers globally, run:

# Clone this repository
git clone https://github.com/ChipsMetaverse/mcp-servers.git
cd mcp-servers

# Optional: Set environment variables for API keys
export GITHUB_TOKEN="your_github_token"
export BRAVE_SEARCH_API_KEY="your_brave_search_api_key"
export SUPABASE_URL="your_supabase_url"
export SUPABASE_KEY="your_supabase_anon_key"

# Run the setup script
./bin/setup-global-mcp.sh

This will:

1. Create directories for each MCP server in ~/.mcp/
2. Copy server scripts to these directories
3. Configure Cursor to use these servers via ~/.cursor/mcp.json
4. Set up API keys if provided as environment variables

Requirements

• Node.js and npm - Required for running MCP servers
• curl - Used for API checks
• jq - Recommended for JSON manipulation (optional but recommended)

Configuration

API keys and tokens are stored in ~/.cursor/mcp.json. You can edit this file manually if you prefer not to use environment variables. The configuration format is:

{
  "github": {
    "accessToken": "your_github_token",
    "permissions": ["repo", "admin:org", "user", "workflow", "delete_repo"]
  },
  "braveSearch": {
    "apiKey": "your_brave_search_api_key",
    "enabled": true
  },
  "comfyui": {
    "command": "~/.mcp/comfyui/run.sh",
    "args": []
  },
  "github-mcp": {
    "command": "~/.mcp/github/run.sh",
    "args": []
  },
  "brave-search": {
    "command": "~/.mcp/brave-search/run.sh",
    "args": []
  },
  "supabase": {
    "command": "~/.mcp/supabase/run.sh",
    "args": []
  }
}

Running Individual Servers

You can run each server individually:

# ComfyUI MCP Server
~/.mcp/comfyui/run.sh

# GitHub MCP Server
~/.mcp/github/run.sh

# Brave Search MCP Server
~/.mcp/brave-search/run.sh

# Supabase MCP Server
~/.mcp/supabase/run.sh

Using with LLMs

After installation, restart Cursor or Claude Desktop to apply the changes. MCP servers will be automatically available to LLMs that support the MCP protocol.

Troubleshooting

• Missing API Keys : Make sure to set your API keys either through environment variables or by editing ~/.cursor/mcp.json
• Server Connectivity : Each server has specific requirements:
  • ComfyUI: Requires the ComfyUI server to be running on http://localhost:8188
  • Supabase: Requires a running Supabase instance (local or remote)
• Permissions : Ensure the run scripts have execution permissions
• Node.js Version : MCP servers require Node.js v16 or later

License

MIT