Servidores, registros e listas de permissão do protocolo MCP

  • 5 minutos

Os agentes se tornam mais úteis quando podem ir além do repositório e interagir com outras ferramentas, sistemas e serviços. O Protocolo de Contexto de Modelo, ou MCP, possibilita isso dando aos agentes uma maneira consistente de descobrir e usar recursos externos.

Em ambientes de GitHub, o MCP não se trata apenas de se conectar a ferramentas. Trata-se também de controlar como essas ferramentas são introduzidas, configuradas e governadas. Isso inclui a configuração de servidores MCP, o uso de um registro para descobrir servidores disponíveis e a imposição de listas de permissões para que somente servidores aprovados possam ser usados.

Nesta unidade, você aprenderá:

  • O que é MCP
  • Como funcionam os servidores MCP
  • Como os registros facilitam a descoberta do servidor
  • Como listas de permissão controlam quais servidores podem ser usados
  • Como o MCP se encaixa em fluxos de trabalho e ferramentas de agente no GitHub

O que é MCP?

O Protocolo de Contexto de Modelo é uma maneira padrão para os clientes de IA se conectarem a ferramentas e serviços por meio de servidores MCP. Em vez de criar uma integração única para cada ferramenta, um cliente compatível com MCP pode se conectar a um servidor que expõe ferramentas em um formato estruturado.

Isso fornece aos agentes um modelo consistente para:

  • Descobrindo ferramentas disponíveis
  • Enviar solicitações estruturadas
  • Recebendo resultados estruturados
  • Reutilizando o mesmo padrão de interação em sistemas diferentes

O que é um servidor MCP?

Um servidor MCP é o componente que expõe ferramentas a um cliente de IA.

O servidor fica entre o cliente e o sistema subjacente. Ele apresenta as ferramentas disponíveis em um formato que o cliente entende, aceita solicitações e, em seguida, executa a ação real no serviço conectado.

Dependendo da configuração, um servidor MCP pode:

  • Executar localmente em um computador desenvolvedor
  • Executar remotamente como um serviço hospedado
  • Conectar-se aos recursos locais
  • Ponte para APIs e plataformas remotas

O servidor MCP GitHub é um exemplo. Ele conecta clientes de IA a recursos de GitHub, como repositórios, problemas e solicitações de pull.

Servidores MCP locais e remotos

Os servidores MCP podem ser configurados local ou remotamente.

Um servidor MCP local é executado em seu computador. Isso é útil quando você deseja um controle mais rígido sobre a configuração, o acesso aos recursos locais ou uma configuração personalizada.

Um servidor MCP remoto é hospedado em outro lugar e acessado pela rede. Isso reduz o trabalho de instalação e facilita o uso do mesmo servidor entre ambientes.

Em IDEs com suporte, o servidor MCP GitHub pode ser configurado remotamente ou localmente, com a opção remota posicionada como a configuração recomendada para a maioria dos usuários. GitHub Enterprise Server dá suporte à configuração do servidor MCP local, enquanto GitHub Enterprise Cloud com residência de dados dá suporte a opções locais e remotas.

Adicionar um servidor MCP remoto como uma ferramenta a um agente (VS Code)

Os servidores MCP são adicionados diretamente por meio da interface Copilot Chat e se tornam ferramentas que o agente pode usar.

Steps:

  1. Clique no ícone GitHub Copilot na parte superior do editor
  2. Abrir Copilot Chat e alternar para o modo agente
  3. Clique no ícone Ferramentas no painel de chat
  4. Clique em Configurar ferramentas no canto superior direito do painel Copilot Chat.
  5. Clique em Adicionar servidor MCP
  6. Na caixa de diálogo de configuração:
    1. Selecione HTTP como o tipo de servidor
    2. Insira a URL do servidor (por exemplo, GitHub servidor MCP):
    3. https://api.githubcopilot.com/mcp/
    4. Pressione Enter
    5. Um nome de servidor é gerado automaticamente
    6. Escolha o escopo: área de trabalho atual ou todas as áreas de trabalho
    7. Clique em Autenticar e entrar para o GitHub
    8. Salvar a configuração

O servidor MCP agora está disponível como uma ferramenta dentro do agente e o agente pode chamar seus recursos durante as tarefas.

Adicionar um servidor MCP local como uma ferramenta a um agente

Um servidor MCP local é executado em seu computador e permite que seu agente interaja com ferramentas locais, arquivos ou serviços personalizados. O processo de instalação no VS Code é o mesmo que adicionar qualquer servidor MCP.

A única diferença é o servidor ao qual você se conecta. Em vez de usar uma URL hospedada como o servidor MCP GitHub, você fornece um ponto de extremidade local, por exemplo:

http://localhost:3000

Servidores MCP locais:

  • Executar em seu computador
  • Pode acessar recursos locais e fluxos de trabalho personalizados
  • Normalmente, não exija autenticação externa

O que é um registro MCP?

Um registro MCP é um catálogo de servidores MCP.

Em vez de solicitar que todos os desenvolvedores configurem manualmente cada servidor, um registro fornece um local central onde os clientes compatíveis podem descobrir quais servidores estão disponíveis e como usá-los.

Isso simplifica a configuração de duas maneiras:

  • Isso facilita a descoberta do servidor
  • Ele padroniza como os servidores são descritos e distribuídos

Por padrão, as experiências de IDE com suporte podem usar o Registro MCP GitHub e os desenvolvedores também podem alternar para um registro personalizado quando necessário.

Como os registros ajudam na configuração

Os registros reduzem o atrito porque removem grande parte do trabalho manual envolvido na adição de servidores.

Em vez de editar arquivos de configuração manualmente para cada servidor, um desenvolvedor pode procurar ou pesquisar um registro, selecionar um servidor, instalá-lo e confiar nele para uso em seu ambiente.

Isso torna os registros especialmente úteis quando:

  • As equipes querem uma experiência de configuração mais simples
  • As organizações querem um conjunto padrão de servidores aprovados
  • Os desenvolvedores precisam de uma lista selecionada em vez de descoberta não gerenciada

GitHub também dá suporte a registros MCP personalizados para organizações e empresas, desde que o registro siga a especificação e a estrutura de ponto de extremidade necessárias do registro MCP.

Configurar registros MCP

Para usar um registro MCP personalizado em GitHub, uma organização ou empresa deve criar ou hospedar um registro que GitHub Copilot possa acessar.

Steps:

  1. Crie ou hospede um registro MCP. Você pode fazer isso de uma das três maneiras:
    • Fork e auto-hospedar o Registro MCP de código aberto
    • Executar o registro de software livre localmente usando o Docker
    • Criar e publicar sua própria implementação de registro personalizado
  2. Verifique se o registro atende aos requisitos de GitHub. O registro deve:
    • Siga a especificação do registro MCP v0.1
    • Exponha os pontos de extremidade HTTPS necessários:
      • GET /v0.1/servers
      • GET /v0.1/servers/{serverName}/versions/latest
      • GET /v0.1/servers/{serverName}/versions/{version}
    • Inclua cabeçalhos CORS necessários para que Copilot possa acessá-lo:
      • Access-Control-Allow-Origin: *
      • Access-Control-Allow-Methods: GET, OPTIONS
      • Access-Control-Allow-Headers: Authorization, Content-Type
  3. (Opcional) Inclua servidores MCP locais:
    • Se você quiser que os desenvolvedores usem servidores MCP locais em políticas restritas, esses servidores deverão ser listados no registro
    • As IDs do servidor devem corresponder exatamente
  4. (Alternativa) Usar Centro de APIs do Azure
    • Azure Centro de API pode atuar como um registro MCP gerenciado
    • Habilitar o acesso anônimo para que Copilot possa buscar o registro
    • Copiar a URL do endpoint do Centro de API para salvar para uso posterior
  5. Forneça a URL do Registro para sua organização ou empresa
    • Essa URL será usada nas configurações de política de Copilot
    • Ele disponibiliza o registro em toda a sua empresa

Depois de configurado, o Registro se torna a fonte da verdade para servidores MCP disponíveis, permitindo que os desenvolvedores descubram e usem ferramentas aprovadas de maneira consistente.

O que é uma lista de permissões?

Uma lista de permissões é uma política que controla quais servidores MCP são permitidos.

Isso importa porque o MCP expande o que um agente pode acessar. Sem guardrails, um agente pode ser conectado a ferramentas que expõem sistemas confidenciais ou permitem ações não seguras.

Uma lista de permissões resolve isso restringindo o uso do servidor a entradas aprovadas. Na prática, isso significa que uma organização ou empresa pode decidir se os desenvolvedores podem:

  • Utilize servidores MCP em todos os casos
  • Usar qualquer servidor MCP
  • Usar apenas servidores MCP específicos definidos em um registro

O GitHub oferece suporte à aplicação de listas de permissões do MCP no nível da organização e da empresa, vinculadas à licença do Copilot associada ao usuário.

Como servidores MCP, registros e listas de permissões funcionam em conjunto

Esses três conceitos resolvem diferentes partes do mesmo problema:

  • Servidor MCP expõe ferramentas
  • O Registro torna os servidores detectáveis e confiáveis
  • A lista de permissões decide quais servidores são permitidos

Juntos, eles criam um modelo flexível e controlado.

Um desenvolvedor ou equipe pode descobrir servidores úteis por meio de um registro, enquanto a organização ainda mantém a governança sobre quais servidores são permitidos na prática.

Configurar listas de permissões do MCP

O MCP permite que as listas controlem quais servidores MCP os desenvolvedores têm permissão para usar. Isso é configurado no nível da organização ou da empresa em GitHub.

Etapas (Enterprise):

  1. Navegue até sua empresa no GitHub
  2. Na parte superior da página, clique em controles de IA
  3. Na barra lateral, clique em MCP
  4. Verifique se os servidores MCP em Copilot estão definidos como Habilitados em todos os lugares
  5. Na seção URL do Registro MCP:
    • Insira a URL do registro
    • Clique em Salvar
    • Se estiver usando Azure Centro de API, insira apenas a URL base (não inclua /v0.1/servers)
  6. Em Restringir o acesso do MCP aos servidores do Registro, escolha:
    • Permitir todos → sem restrições, qualquer servidor MCP pode ser usado
    • Somente registro → apenas servidores do registro são permitidos

Etapas (Organização):

  1. Em GitHub, clique em sua imagem de perfil e selecione Organizações
  2. Selecione sua organização
  3. Clique em Configurações
  4. Na barra lateral, clique em Copilot e em Políticas
  5. Na seção Recursos:
    • Verifique se os servidores MCP no Copilot estão habilitados
  6. (Opcional) Na URL do registro do MCP:
    • Insira a URL do registro
    • Clique em Salvar
    • Se estiver usando Azure Centro de API, insira apenas a URL base
  7. Em Restringir o acesso do MCP aos servidores do Registro, escolha:
    • Permitir tudo
    • Somente registro

Note

Observações: se a opção Permitir tudo estiver selecionada, os desenvolvedores poderão adicionar e usar qualquer servidor MCP sem restrições. Se o Registro estiver selecionado apenas, os desenvolvedores serão limitados a usar apenas os servidores MCP definidos no registro configurado. Nesse caso, até mesmo servidores MCP locais devem ser incluídos no registro e suas IDs de servidor devem corresponder exatamente. Depois que uma política é selecionada, ela é aplicada imediatamente a todos os desenvolvedores.

Permitir listas garante que os agentes usem apenas servidores MCP aprovados, dando às organizações controle sobre quais ferramentas podem ser acessadas.

Um fluxo de trabalho GitHub prático

Um fluxo de MCP centrado em GitHub realista tem esta aparência:

  1. Uma organização configura um registro MCP
  2. A organização define uma política de lista de permissões para servidores aprovados
  3. Um desenvolvedor abre um IDE ou cliente compatível com MCP
  4. O cliente descobre servidores aprovados do registro
  5. O desenvolvedor habilita um servidor, como o servidor MCP GitHub
  6. O agente usa ferramentas desse servidor durante uma tarefa

Nesse modelo, os agentes ganham novos recursos sem abrir mão do controle sobre segurança e governança.

Por que isso é importante para a execução do agente

O MCP fornece aos agentes acesso a mais ferramentas, mas mais ferramentas também significam mais responsabilidade.

Para usar o MCP com segurança em escala, você precisa de mais do que conectividade. Você precisa:

  • Um servidor que expõe as ferramentas corretamente
  • Um registro que torna os servidores aprovados detectáveis
  • Uma lista de permissões que limita o que pode ser usado

Essa combinação torna o MCP prático para equipes reais. Ele permite que os agentes expandam além de GitHub mantendo a instalação gerenciável e o acesso controlado.

Conclusão principal

O MCP estende os recursos do agente conectando-os a ferramentas por meio de servidores MCP. Os registros simplificam a forma como esses servidores são descobertos e configurados. As listas de permissões fornecem os guardrails que decidem quais servidores são permitidos.

Juntas, essas peças tornam o MCP escalonável e governável.

Em seguida, você aprenderá a definir ambientes de execução e limites de permissão para que os agentes possam usar GitHub e ferramentas conectadas ao MCP com segurança.