# Adicionando servidores MCP para GitHub Copilot CLI

Estenda os recursos de Copilot conectando servidores MCP (Protocolo de Contexto do Modelo) para fornecer ferramentas e contexto adicionais.

O MCP (Protocolo de Contexto de Modelo) é um padrão aberto que define como os aplicativos compartilham contexto com os LLMs (modelos de linguagem grande). Você pode conectar servidores MCP a GitHub Copilot CLI para fornecer Copilot acesso a ferramentas externas, fontes de dados e serviços. Para obter uma visão geral do MCP, consulte [Sobre o Protocolo de Contexto de Modelo (MCP)](/pt/copilot/concepts/context/mcp).

## Adicionando um servidor MCP

> \[!NOTE]
> O GitHub servidor MCP é integrado Copilot CLI e já está disponível sem nenhuma configuração adicional. As etapas abaixo são para adicionar outros servidores MCP.

Se sua organização ou empresa tiver configurado uma URL do Registro e uma política de lista de permissões, essas configurações se aplicarão a Copilot CLI. A URL do Registro configurada será exibida como uma fonte de descoberta e somente os servidores permitidos pela política de lista de permissões podem ser executados.

Você pode adicionar servidores MCP das seguintes maneiras:

* [Usando o `/mcp add` comando](#using-the-mcp-add-command)
* [Usando o subcomando `copilot mcp add`](#using-the-copilot-mcp-add-subcommand)
* [Editando o arquivo de configuração](#editing-the-configuration-file)
* [Adicionando servidores MCP por repositório](#adding-per-repository-mcp-servers)
* [Buscando e instalando no registro (experimental)](#searching-and-installing-from-the-registry)

Para obter instruções de instalação, ferramentas disponíveis e URLs para servidores MCP específicos, consulte o [GitHub Registro MCP](https://github.com/mcp).

### Usando o comando `/mcp add`

1. No modo interativo, digite `/mcp add`. Um formulário de configuração é exibido. Use <kbd>Tab</kbd> para navegar entre campos.

2. Ao lado **do Nome do Servidor, insira** um nome exclusivo para o servidor MCP. Esse é o nome que você usará para se referir ao servidor.

3. Ao lado **do Tipo de Servidor**, selecione um tipo pressionando o número correspondente. Estão disponíveis os seguintes tipos:

   * **Local** ou **STDIO**: inicia um processo local e se comunica por entrada/saída padrão (`stdin`/`stdout`). Ambas as opções funcionam da mesma maneira.
     **STDIO** é o nome de tipo de protocolo MCP padrão, portanto, escolha-o se você quiser que sua configuração seja compatível com VS Code, o Copilot cloud agente outros clientes MCP.
   * **HTTP** ou **SSE**: conecta-se a um servidor MCP remoto.
     **HTTP** usa o transporte HTTP streamable.               A **SSE** usa o HTTP legado com o transporte de eventos enviados pelo servidor, que é preterido na especificação do MCP, mas ainda é suportado para compatibilidade retroativa. <!-- markdownlint-disable-line GHD046 -->

4. Os campos restantes dependem do tipo de servidor selecionado:

   * Se você escolheu **Local** ou **STDIO**:

     * Próximo a **Comando**, insira o comando para iniciar o servidor, incluindo quaisquer argumentos. Por exemplo, `npx @playwright/mcp@latest`. Isso corresponde tanto às propriedades `command` quanto `args` no arquivo de configuração JSON.
     * Ao lado **de Variáveis de Ambiente**, opcionalmente especifique variáveis de ambiente de que o servidor precisa, como chaves de API ou tokens, como pares chave-valor JSON. Por exemplo, `{"API_KEY": "YOUR-API-KEY"}`. A `PATH` variável é herdada automaticamente do seu ambiente. Todas as outras variáveis de ambiente devem ser configuradas aqui.

   * Se você escolheu **HTTP** ou **SSE**:

     * Ao lado de **URL**, cole a URL do servidor remoto. Por exemplo, `https://mcp.context7.com/mcp`.
     * Ao lado de **cabeçalhos HTTP**, especifique opcionalmente cabeçalhos HTTP no formato JSON. Por exemplo, `{"CONTEXT7_API_KEY": "YOUR-API-KEY"}`.

5. Ao lado **das Ferramentas, especifique** quais ferramentas do servidor devem estar disponíveis. Insira `*` para incluir todas as ferramentas ou forneça uma lista separada por vírgulas de nomes de ferramentas (sem aspas necessárias). O padrão é `*`.

6. Pressione <kbd>Ctrl</kbd>+<kbd>S</kbd> para salvar a configuração. O servidor MCP é adicionado e está disponível imediatamente sem reiniciar a CLI.

### Usando o subcomando `copilot mcp add`

Você pode adicionar servidores MCP do terminal usando o `copilot mcp add` subcomando, sem entrar no modo interativo. O servidor é adicionado à configuração do usuário em `~/.copilot/mcp-config.json`.

Para servidores locais (stdio), forneça o comando após `--`:

```shell copy
copilot mcp add SERVER-NAME -- COMMAND [ARGS...]
```

Para servidores remotos (HTTP/SSE), especifique o transporte e forneça a URL:

```shell copy
copilot mcp add --transport http SERVER-NAME URL
```

Você também pode passar opções adicionais:

* `--env KEY=VALUE`: defina variáveis de ambiente para o servidor. Repita para várias variáveis.
* `--header "HEADER: VALUE"`: defina cabeçalhos HTTP para servidores remotos. Repita para múltiplos cabeçalhos.
* `--transport TRANSPORT`: defina o tipo de transporte (`stdio`ou`http``sse`). O padrão é `stdio`.
* `--tools TOOLS`: especifique quais ferramentas habilitar. Use `*` para todas as ferramentas (padrão), uma lista separada por vírgulas ou `""` para nenhuma.
* `--timeout MS`: defina um tempo limite em milissegundos.

#### Exemplos

Adicione um servidor stdio local:

```shell copy
copilot mcp add context7 -- npx -y @upstash/context7-mcp
```

Adicione um servidor local com variáveis de ambiente:

```shell copy
copilot mcp add github -e GITHUB_PERSONAL_ACCESS_TOKEN=YOUR_GITHUB_PAT -- docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server
```

Adicione um servidor HTTP remoto:

```shell copy
copilot mcp add --transport http notion \
  https://mcp.notion.com/mcp
```

Adicione um servidor remoto com um cabeçalho de autorização:

```shell copy
copilot mcp add --transport http \
  --header "Authorization: Bearer YOUR-TOKEN" \
  stripe https://mcp.stripe.com
```

### Editando o arquivo de configuração

Você também pode adicionar servidores MCP editando o arquivo de configuração em `~/.copilot/mcp-config.json`. Isso é útil se você quiser compartilhar configurações ou adicionar vários servidores ao mesmo tempo.

O exemplo a seguir mostra um arquivo de configuração com um servidor local e um servidor HTTP remoto:

```json copy
{
  "mcpServers": {
    "playwright": {
      "type": "local",
      "command": "npx",
      "args": ["@playwright/mcp@latest"],
      "env": {},
      "tools": ["*"]
    },
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/mcp",
      "headers": {
        "CONTEXT7_API_KEY": "YOUR-API-KEY"
      },
      "tools": ["*"]
    }
  }
}
```

Para obter mais informações sobre a configuração do servidor MCP, consulte [Configurar servidores MCP para seu repositório](/pt/copilot/how-tos/copilot-on-github/customize-copilot/configure-mcp-servers#writing-a-json-configuration-for-mcp-servers).

### Adicionando servidores MCP por repositório

Você pode configurar servidores MCP para um projeto específico adicionando um arquivo JSON ao repositório. Isso é útil quando você deseja que os servidores estejam disponíveis somente ao trabalhar nesse projeto ou quando você quiser compartilhar uma configuração do MCP com colaboradores, comprometendo-a com o repositório.

Copilot CLI procura a configuração no nível do projeto nos seguintes locais:

| Caminho                                                                                              | Uso recomendado                                                               |
| ---------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| `.mcp.json` (em qualquer diretório, a partir do seu diretório de trabalho até a raiz do repositório) | Configuração local ou por checkout; geralmente localizada na raiz do projeto. |
| `.github/mcp.json`                                                                                   | Configuração compartilhada enviada ao repositório                             |

Quando você começa Copilot CLI dentro de um repositório Git, a CLI caminha do diretório de trabalho atual até a raiz do repositório, carregando arquivos de configuração MCP ao longo do caminho. Se ambos `.mcp.json` e `.github/mcp.json` existirem no mesmo diretório, `.mcp.json` terá precedência. Quando os nomes de servidor entram em conflito, as definições em arquivos mais próximos do diretório de trabalho têm precedência. As definições no nível do projeto também têm precedência sobre aquelas em `~/.copilot/mcp-config.json`. Para obter mais informações sobre a relação de confiança relativa, consulte [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#mcp-server-trust-levels).

Arquivos no nível do projeto podem usar o objeto de nível superior `mcpServers`, mostrado em `~/.copilot/mcp-config.json`, ou o formato simples de nível superior, em que cada chave é o nome de um servidor MCP. Por exemplo, essa configuração usa o `mcpServers` objeto:

```json copy
{
  "mcpServers": {
    "playwright": {
      "type": "local",
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}
```

O mesmo servidor também pode ser configurado com o formato de nível superior nu:

```json copy
{
  "playwright": {
    "type": "local",
    "command": "npx",
    "args": ["@playwright/mcp@latest"]
  }
}
```

> \[!NOTE]
> Os servidores MCP no nível do projeto são carregados somente depois que você confirma que confia na pasta na primeira execução. Eles são ignorados sem aviso em diretórios não confiáveis. Para obter mais informações sobre a confiabilidade da pasta, consulte [Sobre GitHub Copilot CLI](/pt/copilot/concepts/agents/copilot-cli/about-copilot-cli#trusted-directories).

No modo de prompt (`copilot -p`), os servidores MCP no nível do projeto serão carregados automaticamente se o diretório atual já for confiável. Se o diretório não for confiável, os servidores MCP no nível do projeto serão ignorados por padrão. Para carregá-los mesmo assim, defina a variável de ambiente `GITHUB_COPILOT_PROMPT_MODE_WORKSPACE_MCP` como `true`, já que o modo de prompt não pode exibir um prompt de confiança interativo. Para obter mais informações, consulte [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#environment-variables).

O arquivo `.vscode/mcp.json` para VS Code não é lido por Copilot CLI. Ele usa a chave de nível superior `servers` sem suporte. Para migrar um existente `.vscode/mcp.json` para um formato que a CLI aceita, consulte [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#migrating-from-vscodemcpjson).

### Pesquisando e instalando no registro

> \[!NOTE]
> No momento, o `/mcp search` comando é um recurso experimental. Para usá-lo, comece Copilot CLI com a opção `‑‑experimental` de linha de comando ou insira `/experimental on` durante uma sessão.

Você pode descobrir e instalar servidores MCP diretamente do [GitHub Registro MCP](https://github.com/mcp) usando o `/mcp search` comando no modo interativo. Isso permite que você navegue pelos servidores disponíveis, exiba seus detalhes e instale-os sem preencher manualmente o formulário de configuração.

Se sua organização tiver configurado uma URL personalizada do Registro MCP, `/mcp search` conecte-se a esse registro em vez do registro padrão GitHub .

1. No modo interativo, insira `/mcp search` para procurar os principais servidores por estrelas ou `/mcp search QUERY` procurar um servidor específico. Por exemplo:

   ```text
   /mcp search context7
   ```

2. Uma lista navegável por teclado de servidores correspondentes é exibida. Use as teclas de direção para procurar os resultados.

3. Selecione um servidor para abrir seu formulário de configuração. O formulário é preenchido previamente com a configuração do servidor do registro. Preencha todos os campos necessários, como chaves de API ou tokens.

4. Pressione <kbd>Ctrl</kbd>+<kbd>S</kbd> para salvar. O servidor é adicionado ao seu `mcp-config.json` e iniciado imediatamente.

## Gerenciando servidores MCP

Você pode gerenciar seus servidores MCP configurados usando os `/mcp` comandos no modo interativo ou os `copilot mcp` subcomandos do terminal.

### Usar comandos `/mcp` no modo interativo

* **Listar servidores MCP configurados:** Use o comando `/mcp show`. Isso exibe todos os servidores MCP configurados e seu status atual.

* **Exibir detalhes sobre um servidor específico:** Use o comando `/mcp show SERVER-NAME`. Isso exibe o status do servidor especificado e a lista de ferramentas que ele fornece.

* **Edite a configuração de um servidor:** Use o comando `/mcp edit SERVER-NAME`.

* **Excluir um servidor:** Use o comando `/mcp delete SERVER-NAME`.

* **Desabilitar um servidor:** Use o comando `/mcp disable SERVER-NAME`. Um servidor desabilitado permanece configurado, mas não é usado por Copilot para a sessão atual.

* **Habilite um servidor desabilitado anteriormente:** Use o comando `/mcp enable SERVER-NAME`.

### Usando os subcomandos `copilot mcp` no terminal

Você também pode gerenciar servidores MCP do terminal sem entrar no modo interativo.

* **Listar todos os servidores configurados:**

  ```shell copy
  copilot mcp list
  ```

  Lista servidores de todas as fontes de configuração (usuário, workspace e plug-in). Adicionar `--json` para saída JSON.

* **Exibir detalhes do servidor:**

  ```shell copy
  copilot mcp get SERVER-NAME
  ```

  Mostra o tipo, o status e as ferramentas disponíveis de um servidor. Adicionar `--json` para saída JSON.

* **Remova um servidor:**

  ```shell copy
  copilot mcp remove SERVER-NAME
  ```

  Remove o servidor da configuração do usuário.

## Usando servidores MCP

Depois de adicionar um servidor MCP, Copilot pode usar automaticamente as ferramentas fornecidas quando forem relevantes para o seu prompt. Você também pode referenciar diretamente um servidor MCP e ferramentas específicas em um prompt para garantir que eles sejam usados.

## Leitura adicional

* [Sobre o Protocolo de Contexto de Modelo (MCP)](/pt/copilot/concepts/context/mcp)
* [Estendendo o GitHub Copilot Chat com servidores MCP (Protocolo de Contexto do Modelo)](/pt/copilot/how-tos/provide-context/use-mcp-in-your-ide/extend-copilot-chat-with-mcp)
* [Configurar servidores MCP para seu repositório](/pt/copilot/how-tos/copilot-on-github/customize-copilot/configure-mcp-servers)