How to Use mcp.tc as the MCP Registry in VS Code

TL;DR. To use mcp.tc as the MCP registry in VS Code, add "chat.mcp.gallery.serviceUrl": "https://mcp.tc" to the user settings.json of your default profile. Type @mcp in the Extensions view and the MCP server gallery lists mcp.tc's servers. Installing one writes the server's own URL or package into your configuration, so your client talks to the server directly. Teams can set the same URL with the McpGalleryServiceUrl policy, or as the MCP Registry URL in GitHub Copilot's policies, which reach VS Code and other Copilot clients. To go back, delete the line.

What the MCP server gallery in VS Code reads#

VS Code can install MCP servers from a gallery. The VS Code MCP docs describe it like this: open the Extensions view, "enter @mcp in the search field", and VS Code "shows the list of available MCP servers in the gallery". You install a server in your user profile with Install, or in the current workspace with Install in Workspace, which "updates the .vscode/mcp.json file".

The gallery is a client for a registry API. Microsoft's build of VS Code names that API in its product.json: in VS Code 1.141.0 the gallery's serviceUrl is https://api.mcp.github.com, the GitHub MCP Registry. GitHub describes the same default for Copilot in other IDEs on its page about changing the MCP registry in your IDE: "By default, Copilot uses the GitHub MCP Registry, but you can configure your own MCP registry to customize the list of servers available in your environment."

Any service that answers the registry's read endpoints can stand in. mcp.tc serves a read-only copy of that API at https://mcp.tc/v0.1/, built from the listings it has approved. On 8 October 2026 that was 672 servers. Almost all of them carry the vendor's own endpoint or install package; the exceptions are covered below.

Add one line to settings.json#

Open the Command Palette, run Preferences: Open User Settings (JSON) while your default profile is active, and add:

{
  "chat.mcp.gallery.serviceUrl": "https://mcp.tc"
}

mcp.tc's API docs keep a short version of these steps. Three details from VS Code's source code are worth knowing before you go looking for the setting.

• Use the base URL. Enter https://mcp.tc, not https://mcp.tc/v0.1. VS Code drops a trailing slash, checks which API version the service answers with a GET {url}/v0.1/servers?limit=1, and then appends /v0.1/servers itself.
• It is not in the Settings editor. VS Code registers the setting as hidden from the Settings editor and applying to the whole application. Searching for it in the Settings UI finds nothing, so edit the JSON file.
• Other profiles ignore it by default. In a profile with settings of its own, VS Code reads application settings from the default profile's file but skips keys hidden from the Settings editor, and the profile's own settings.json doesn't take application settings at all. Two exceptions: a profile that uses the default profile's settings behaves like the default profile, and a key named in workbench.settings.applyToAllProfiles is applied everywhere. So to use mcp.tc in every profile, add this to the default profile's settings.json as well:

"workbench.settings.applyToAllProfiles": ["chat.mcp.gallery.serviceUrl"]

On VS Code Stable you don't need to switch anything else on. The Extensions view shows the gallery list when this URL is set, even if chat.mcp.gallery.enabled is not. VS Code watches the setting and reloads the gallery when it changes.

What you see after the change#

Type @mcp in the Extensions view, or @mcp followed by a name. VS Code asks for /v0.1/servers?limit=…&version=latest and adds &search= with your words. mcp.tc matches every word against a server's name, title, link name and vendor, and returns the listings it has approved. You can send the same request yourself:

curl -s 'https://mcp.tc/v0.1/servers?search=notion&limit=5'

Here is the answer from 8 October 2026, with $schema, icons, websiteUrl and some _meta fields left out:

{
  "servers": [
    {
      "server": {
        "name": "com.notion/mcp",
        "description": "Search, read, create and update pages and databases in your Notion workspace from an MCP client.",
        "title": "Notion",
        "version": "1.0.1",
        "remotes": [
          {
            "type": "streamable-http",
            "url": "https://mcp.notion.com/mcp"
          }
        ]
      },
      "_meta": {
        "tc.mcp/listing": {
          "slug": "notion",
          "verified": true,
          "auth": "oauth"
        }
      }
    }
  ],
  "metadata": {
    "count": 1
  }
}

remotes holds Notion's own endpoint, https://mcp.notion.com/mcp. When you press Install, VS Code writes remotes[0].url into your configuration as a remote server, or, for a local server, the command for its npm, PyPI, OCI or NuGet package. From then on the server's MCP traffic goes straight to the server. mcp.tc only gets the gallery's registry requests: lists, searches (with the words you typed) and lookups of one server's entry by name, which VS Code also makes for servers you installed from the gallery.

The same holds for servers that need a sign-in. Notion uses OAuth, and that sign-in happens between your client and Notion; mcp.tc never sees a token. A server with no sign-in, such as DeepWiki at https://mcp.deepwiki.com/mcp, works as soon as it is installed.

Servers the gallery leaves out#

A registry entry needs a remote URL or a package before VS Code can install it. VS Code drops entries that have neither, and they never appear in the list.

On mcp.tc this happens when a listing's install command can't be written in the registry format, for example a command that runs extra shell steps or starts a program whose name differs from its package. mcp.tc then publishes the entry without a package rather than one that starts the wrong program. On 8 October 2026, 18 of the 672 entries had neither a package nor a remote. MCP Memory Service is one of them: it doesn't show in VS Code's gallery, and its page on mcp.tc still has the setup steps.

Set it for a team: policies and Registry only#

VS Code policy. Organizations that manage VS Code with policies can set the gallery for everyone. The same setting carries the policy name McpGalleryServiceUrl, available from VS Code 1.101. The enterprise policies page lists it as "Configure the MCP Gallery service URL to connect to". VS Code also fills this policy from the Copilot policy data of the GitHub account you are signed in with so the GitHub policy described below reaches VS Code the same way. A policy value "overrides the VS Code setting value configured at any level", as the policies page puts it.

Limit what can run. chat.mcp.access (policy ChatMCP) takes none, registry or all, and GitHub's Registry only choice arrives as registry. With "chat.mcp.access": "registry", VS Code allows "access to MCP servers listed in the registry that VS Code is connected to", in the words of the setting's description for that value. With mcp.tc as the registry, that means servers mcp.tc lists.

GitHub Copilot policy. Organization and enterprise owners on Copilot Business or Copilot Enterprise can restrict MCP server access to a custom registry. Enter https://mcp.tc in the MCP Registry URL field, without a path: in a note on Azure API Center URLs, GitHub's docs explain that a suffix such as /v0.1/servers "will cause the registry to error out, because GitHub Copilot appends the MCP v0.1 path automatically". Then choose Allow all (no restrictions) or Registry only ("Only servers from the registry may run") under Restrict MCP access to registry servers.

GitHub's page on configuring an MCP registry lists these surfaces as supporting the v0.1 registry: VS Code Insiders, VS Code, Visual Studio, Eclipse, JetBrains IDEs, Xcode and Copilot CLI. The same page asks for CORS headers on every /v0.1/servers endpoint (Access-Control-Allow-Origin: * among them). mcp.tc sends Access-Control-Allow-Origin: * on every answer and allows GET, HEAD and OPTIONS with the Authorization and Content-Type headers.

Read GitHub's limits before you rely on Registry only. The MCP private registry enforcement page says "Enforcement is based only on server name/ID matching, which can be bypassed by editing configuration files", and that for local servers the registry's ID "must exactly match the installed server ID". Every page in this section also calls the custom registry a public preview that "is not the recommended method for restricting access to MCP servers"; GitHub recommends an allowlist in the enterprise's managed-settings.json instead. A registry URL is a good way to choose what developers browse. For enforcement, follow GitHub's advice.

On mcp.tc, an entry's name is the server's official registry name when it has one (com.notion/mcp), otherwise tc.mcp/ plus its slug (tc.mcp/deepwiki). Those are the names that Registry only compares.

Other clients that accept a custom registry URL#

GitHub also documents a personal MCP Registry URL field in Copilot for three more IDEs, each in public preview on a pre-release build of the Copilot plugin: JetBrains IDEs (the settings icon in the MCP Registry window), Xcode (Tools tab, Edit URL) and Eclipse (Configure Registry URL in the MCP Registry window). Those pages don't say whether the field takes the base URL or the full /v0.1 path. We haven't tested mcp.tc in those three, so we list them as documented, not as checked.

We know of no other editor that takes a custom registry URL. Clients without one can still install any server from its listing on mcp.tc, using the setup guides.

Switch back to the default gallery#

Delete the chat.mcp.gallery.serviceUrl line from your user settings.json and save. VS Code reloads the gallery from its built-in registry. Servers you installed from mcp.tc's list stay installed: their configuration lives in your mcp.json, and it points at the servers themselves. If you also set "chat.mcp.access": "registry", remove that too, or servers missing from the default registry stop being allowed to run.

If a policy sets the URL, the policy wins over the line in your settings, and only whoever manages the policy can change it.