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

> Source: <https://dev.to/mcptc/how-to-use-mcptc-as-the-mcp-registry-in-vs-code-3aal>
> Published: 2026-10-07 23:15:46+00:00

**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.

VS Code can install MCP servers from a gallery. The [VS Code MCP docs](https://code.visualstudio.com/docs/copilot/customization/mcp-servers) 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](https://docs.github.com/en/copilot/how-tos/copilot-in-your-ide/customize-copilot/extend-copilot-with-tools-and-context/change-mcp-registry): "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](https://mcp.tc/docs/api#registry) 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.

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](https://mcp.tc/docs/api#custom-registry) keep a short version of these steps. Three details from VS Code's source are worth knowing before you go looking for the setting.

`https://mcp.tc`, not `https://mcp.tc/v0.1`. VS Code's `GET {url}/v0.1/servers?limit=1`, and then appends `/v0.1/servers` itself.`included: false` and `scope: ConfigurationScope.APPLICATION` in `skipUnregistered: true`), 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 

```
"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 ([mcpServersView.ts](https://github.com/microsoft/vscode/blob/31293417a6222caa5fab6b24ed358d6196be9f79/src/vs/workbench/contrib/mcp/browser/mcpServersView.ts)). VS Code watches the setting and reloads the gallery when it changes.

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's [install code](https://github.com/microsoft/vscode/blob/31293417a6222caa5fab6b24ed358d6196be9f79/src/vs/platform/mcp/common/mcpManagementService.ts) 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](https://mcp.tc/i/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](https://mcp.tc/i/deepwiki) at `https://mcp.deepwiki.com/mcp`, works as soon as it is installed.

A registry entry needs a remote URL or a package before VS Code can install it. VS Code's [gallery service](https://github.com/microsoft/vscode/blob/31293417a6222caa5fab6b24ed358d6196be9f79/src/vs/platform/mcp/common/mcpGalleryService.ts) 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](https://mcp.tc/i/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.

**VS Code policy.** Organizations that manage VS Code with policies can set the gallery for everyone. The same setting carries the policy name `McpGalleryServiceUrl`, with `minimumVersion: '1.101'`, so VS Code 1.101 or later. The [enterprise policies page](https://code.visualstudio.com/docs/enterprise/policies) 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 (the field `mcpRegistryUrl`), 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](https://docs.github.com/en/copilot/how-tos/administer-copilot/manage-mcp-usage/restrict-based-on-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](https://docs.github.com/en/copilot/how-tos/administer-copilot/manage-mcp-usage/configure-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](https://docs.github.com/en/copilot/reference/enterprise-administrators/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.

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](https://mcp.tc/docs/connect).

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.

No. The registry API is public, read-only and needs no key. VS Code's gallery requests are plain GET requests with no sign-in, and mcp.tc sets no cookies on those answers.

No. The entry VS Code installs holds the vendor's endpoint or package, and VS Code writes that into your configuration. After installation the server and your client talk directly. mcp.tc only answers the gallery's registry requests: lists, searches and lookups of a server's entry.

Either its entry has neither a package nor a remote, which VS Code hides (18 of 672 on 8 October 2026), or you are in a profile other than your default one, where the setting is ignored unless it is listed in `workbench.settings.applyToAllProfiles`. In both cases the server's page on mcp.tc has setup steps for VS Code and other clients.

A listing means mcp.tc read the server's public information and approved the entry. It is not a security review. Read a server's tools and its source before you give it access, as the [safety guide](https://mcp.tc/blog/is-this-mcp-server-safe) on this blog describes, and check its History tab for recent tool changes.

Yes. Enter `https://mcp.tc` as the MCP Registry URL in Copilot's policies and choose Registry only. Developers can then run the servers mcp.tc lists, matched by name, with the limits GitHub describes for name matching. For a list of your own, GitHub's docs explain how to host a registry or use `managed-settings.json`.