How to Find, Install, and Manage MCP Servers with GitHub's Registry

TL;DR

• GitHub's MCP Registry centralizes discovery and installation of 44+ MCP servers with one-click VS Code integration
• Publishing your own server takes five steps: install CLI, init config, prove ownership, authenticate, and publish
• Enterprise teams can enforce allow lists to control which MCP servers developers can install
• Self-publication opens to the community in the next few months, making this the canonical MCP source

The Big Picture

Finding MCP servers used to feel like shopping in a store where nothing was organized. Servers scattered across GitHub repos, outdated documentation, no clear way to know which ones actually worked with your setup.

The GitHub MCP Registry fixes this. It's a single source for discovering, installing, and managing Model Context Protocol servers—the connective tissue between your AI systems and the tools they need to be useful.

MCP servers are how you give AI agents access to real capabilities. Want browser automation? Install Playwright. Need GitHub API access? There's a server with 100+ tools. Knowledge management through Notion? That's a server too.

The registry currently hosts 44 servers from partners like Microsoft, HashiCorp, Notion, Unity, Firecrawl, and Stripe. You can browse by tags, popularity, or GitHub stars. Installation is one-click in VS Code. And if you've built your own server, publishing it takes about five minutes.

More importantly, the registry enables governance. Enterprise teams can enforce allow lists so developers only install vetted servers. This matters when those servers touch sensitive data or production systems.

Here's how to use it, publish to it, and lock it down for your team.

How It Works

Installing an MCP Server

The registry makes installation a one-click experience in VS Code or VS Code Insiders. No manual config file editing. No hunting for the right npm package or Docker image.

Here's the flow for installing Playwright:

• Navigate to the Playwright MCP server in the GitHub MCP Registry
• Click "Install in VS Code"
• VS Code launches with a pre-filled configuration
• Accept or adjust optional parameters like storage paths
• Done

Remote MCP servers like GitHub's use OAuth during install. You authenticate once and the server handles tokens and secrets automatically. No manual credential management.

This is a massive improvement over the old workflow: clone a repo, read the README, figure out the config format, manually edit your MCP settings file, restart your IDE, debug why it didn't work.

Publishing Your Own Server

Publishing to the registry requires proving you own the package you're distributing. This prevents namespace squatting and ensures developers can trust what they're installing.

The process has five steps:

1. Install the MCP Publisher CLI

On macOS, Linux, or WSL, use Homebrew:

brew install mcp-publisher

Or download the prebuilt binary:

curl -L "https://github.com/modelcontextprotocol/registry/releases/download/latest/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher && sudo mv mcp-publisher /usr/local/bin/

2. Initialize your server.json file

Navigate to your server's source directory and run:

cd /path/to/your/mcp-server
mcp-publisher init

This creates a server.json file with metadata about your server. You'll specify the name, description, version, and package details.

3. Prove you own the package

The registry needs proof you control the package you're publishing. The method depends on your package type:

• NPM: Add an "mcpName" field to your package.json
• PyPI/NuGet: Add mcp-name: io.github.username/server-name to your README
• Docker: Add a label to your Dockerfile: LABEL io.modelcontextprotocol.server.name="io.github.username/server-name"

4. Authenticate

For GitHub-based namespaces (io.github.*), run:

mcp-publisher login github

This opens a browser for OAuth login. For custom domains like com.yourcompany/*, you'll need to follow DNS verification steps in the official docs.

5. Publish

mcp-publisher publish

If successful, your server appears in the registry. Verify with:

curl "https://registry.modelcontextprotocol.io/v0/servers?search=io.github.yourname/your-server"

Once you've completed these steps, email partnerships@github.com to request inclusion in the curated registry.

You can also list remote endpoints in your server.json for cloud or HTTP-based deployments. This lets you offer both local packages and hosted endpoints in the same server listing.

Automating Publication with GitHub Actions

You can automate publishing so every tagged release goes to both your package registry and the MCP registry. This workflow handles npm publishing and MCP registration in one step:

name: Publish to MCP Registry
on:
  push:
    tags: ["v*"]

jobs:
  publish:
    runs-on: ubuntu-latest
    permissions:
      id-token: write  # For OIDC
      contents: read

    steps:
      - uses: actions/checkout@v5

      - name: Setup Node.js
        uses: actions/setup-node@v5
        with:
          node-version: "lts/*"
      - name: Install dependencies
        run: npm ci
      - name: Build and test
        run: |
          npm run build --if-present
          npm run test --if-present
      - name: Publish to npm
        run: npm publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

      - name: Download MCP Publisher
        run: |
          curl -L "https://github.com/modelcontextprotocol/registry/releases/download/latest/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
      - name: Publish to MCP Registry
        run: |
          ./mcp-publisher login github-oidc
          ./mcp-publisher publish

Trigger it by pushing a version tag:

git tag v1.0.0
git push origin v1.0.0

When you publish, your server shows up in the open source registry and downstream registries like GitHub's automatically pick up updates. No manual notifications required.

Enterprise Governance

If you're managing MCP usage across a large organization, you need control over which servers developers can install. GitHub now supports registry allow lists so admins can enforce approved servers.

The setup:

• Stand up or connect an internal registry that follows the MCP API spec
• Add vetted MCP servers (internal and external) to your registry
• Point GitHub Enterprise settings to that registry endpoint
• MCP-aware surfaces like VS Code enforce the allow list automatically

Your internal registry returns a list of approved servers. When developers try to install an MCP server in VS Code, GitHub checks your registry endpoint and only allows installations from your approved list.

This governance model means you can vet partnerships, run security scans, and maintain compliance while giving developers access to the tools they need.

What This Changes For Developers

Before the registry, discovering MCP servers meant searching GitHub, reading scattered documentation, and hoping the server you found actually worked with your setup. Installation required manual config file editing. Updates meant checking repos individually.

The registry centralizes all of this. You browse servers in one place, install with one click, and updates propagate automatically.

For server authors, the registry solves distribution. You publish once and developers can discover your server through a canonical source. No more maintaining your own documentation site or fielding installation questions in GitHub issues.

For enterprise teams, the allow list feature makes MCP adoption viable in regulated industries. You can give developers access to AI-assisted workflows without losing control over which external tools touch your systems.

The registry also enables quality signals. GitHub stars, org verification, and download counts help you assess whether a server is worth installing. If a server has thousands of stars and comes from a verified org like Microsoft or HashiCorp, that's a strong signal.

GitHub's offline evaluation framework for testing MCP server quality adds another layer of trust. Servers in the registry can be tested for reliability, performance, and correctness before you install them.

Try It Yourself

Start by exploring the GitHub MCP Registry. Browse by tags or sort by GitHub stars to find servers relevant to your workflow.

Install a server in VS Code to see the one-click experience. Playwright is a good starting point if you work with web automation. The GitHub MCP server is essential if you're building workflows around GitHub APIs.

If you've built your own MCP server, follow the five-step publishing process above. Host your code in a public GitHub repository to show verified ownership. Add tags in your server.json so developers can discover your server by category.

For enterprise teams, start planning your allow list strategy. Identify which MCP servers your developers need, vet them through your security pipeline, and set up an internal registry endpoint.

Test your MCP server locally before publishing using the MCP Inspector. This helps you catch issues early without polluting the registry.

The Bottom Line

Use the GitHub MCP Registry if you're building AI-assisted workflows and need a reliable way to discover and install MCP servers. The one-click installation and automatic updates save hours of config file debugging.

Publish your own server if you've built tools that other developers could use. The registry gives you distribution without maintaining your own documentation site. Self-publication opens to the community in the next few months, so get your server ready now.

Skip the registry if you're in a highly regulated industry and can't use external tools without vetting. Wait for the enterprise allow list features to mature. GitHub says those are coming soon, but they're not fully baked yet.

The real opportunity here is ecosystem consolidation. MCP servers were scattered across GitHub repos with no canonical source. The registry fixes that. As more servers get published and more IDEs integrate with the registry, this becomes the single source of truth for MCP tooling.

That matters because AI-assisted development isn't about coding faster. It's about orchestrating tools that amplify your impact. The GitHub MCP Registry is where that orchestration begins.

Source: GitHub Blog