Servidores, registos e listas de permissões do Protocolo de Contexto de Modelo (MCP)

  • 5 minutos

Os agentes tornam-se mais úteis quando conseguem ir além do repositório e interagir com outras ferramentas, sistemas e serviços. O Model Context Protocol, ou MCP, torna isso possível ao dar aos agentes uma forma consistente de descobrir e utilizar capacidades externas.

Em ambientes GitHub, o MCP não se resume apenas a ligar a ferramentas. Trata-se também de controlar como essas ferramentas são introduzidas, configuradas e governadas. Isso inclui configurar servidores MCP, usar um registo para descobrir os servidores disponíveis e impor listas de autorização para que apenas servidores aprovados possam ser usados.

Nesta unidade, você aprenderá:

  • O que é o MCP
  • Como funcionam os servidores MCP
  • Como os registos facilitam a descoberta de servidores
  • Como as listas de permissões controlam quais os servidores que podem ser usados
  • Como o MCP se integra nos fluxos de trabalho e ferramentas de agentes no GitHub

O que é MCP?

O Protocolo de Contexto de Modelo é uma forma padrão para os clientes de IA se ligarem a ferramentas e serviços através de servidores MCP. Em vez de construir uma integração única para cada ferramenta, um cliente compatível com MCP pode ligar-se a um servidor que expõe as ferramentas num formato estruturado.

Isto dá aos agentes um modelo consistente para:

  • Descoberta das ferramentas disponíveis
  • Envio de pedidos estruturados
  • Obtenção de resultados estruturados
  • Reutilizar o mesmo padrão de interação entre diferentes sistemas

O que é um servidor MCP?

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

O servidor situa-se entre o cliente e o sistema subjacente. Apresenta as ferramentas disponíveis num formato que o cliente compreende, aceita pedidos e depois realiza a ação real contra o serviço ligado.

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

  • Executar localmente numa máquina de desenvolvimento
  • Executar remotamente como um serviço hospedado
  • Liga-te a recursos locais
  • Ponte para APIs e plataformas remotas

O servidor MCP do GitHub é um exemplo. Conecta clientes de IA às capacidades do GitHub, como repositórios, issues e pull requests.

Servidores MCP locais e remotos

Os servidores MCP podem ser configurados local ou remotamente.

Um servidor MCP local corre na tua máquina. Isto é útil quando se quer um controlo mais apertado sobre a configuração, acesso a recursos locais ou uma configuração personalizada.

Um servidor MCP remoto é alojado noutro local e acedido através da rede. Isto reduz o trabalho de configuração e facilita a utilização do mesmo servidor em diferentes ambientes.

Em IDEs suportados, o servidor MCP do GitHub pode ser configurado remotamente ou localmente, com a opção remota posicionada como a configuração recomendada para a maioria dos utilizadores. O GitHub Enterprise Server suporta configuração local de servidores MCP, enquanto o GitHub Enterprise Cloud com residência de dados suporta opções locais e remotas.

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

Os servidores MCP são adicionados diretamente através da interface do Copilot Chat e tornam-se ferramentas que o agente pode usar.

Passos:

  1. Clique no ícone do GitHub Copilot no topo do editor
  2. Abre o Copilot Chat e muda para o modo Agente
  3. Clica no ícone das Ferramentas no painel de chat
  4. Clique em Configurar ferramentas no canto superior direito do painel do Copilot Chat.
  5. Clique em Adicionar servidor MCP
  6. No diálogo de configuração:
    1. Selecione HTTP como tipo de servidor
    2. Introduza a URL do servidor (exemplo para o servidor GitHub MCP):
    3. https://api.githubcopilot.com/mcp/
    4. Pressione a tecla Enter
    5. Um nome de servidor é gerado automaticamente
    6. Escolha o âmbito; Espaço de trabalho atual ou todos os espaços de trabalho
    7. Clica em Autenticar e inicia sessão no GitHub
    8. Guardar a configuração

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

Adicionar um servidor MCP local como ferramenta a um agente

Um servidor MCP local corre na sua máquina e permite que o seu agente interaja com ferramentas locais, ficheiros ou serviços personalizados. O processo de configuração no VS Code é o mesmo de adicionar qualquer servidor MCP.

A única diferença é o servidor a que te ligas. Em vez de usar uma URL alojada como o servidor MCP do GitHub, fornece um endpoint local, por exemplo:

http://localhost:3000

Servidores MCP locais:

  • Funciona na tua máquina
  • Pode aceder a recursos locais e fluxos de trabalho personalizados
  • Normalmente, não requerem autenticação externa

O que é um registo MCP?

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

Em vez de pedir a cada programador que configure manualmente cada servidor, um registo fornece um local central onde os clientes compatíveis podem descobrir quais os servidores disponíveis e como os utilizar.

Isto simplifica a configuração de duas formas:

  • Facilita a descoberta de servidores
  • Padroniza a forma como os servidores são descritos e distribuídos

Por defeito, as experiências de IDE suportadas podem usar o GitHub MCP Registry, e os programadores também podem mudar para um registo personalizado quando necessário.

Como os registos ajudam na configuração

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

Em vez de editar manualmente os ficheiros de configuração para cada servidor, um programador pode navegar ou pesquisar num registo, selecionar um servidor, instalá-lo e confiar nele para uso no seu ambiente.

Isto torna as listas especialmente úteis quando:

  • As equipas querem uma experiência de configuração mais simples
  • As organizações querem um conjunto padrão de servidores aprovados
  • Os programadores precisam de uma lista curada em vez de uma descoberta desorganizada

O GitHub também suporta registos MCP personalizados para organizações e empresas, desde que o registo siga a especificação e a estrutura de endpoint exigidas do registo MCP.

Configurar registos MCP

Para usar um registo MCP personalizado no GitHub, uma organização ou empresa deve criar ou alojar um registo ao qual o GitHub Copilot possa aceder.

Passos:

  1. Crie ou aloje um registo MCP. Pode fazer isto de três formas:
    • Fazer fork e hospedar autonomamente o Registo MCP de código aberto
    • Execute o registo open-source localmente usando o Docker
    • Construa e publique a sua própria implementação personalizada de registo
  2. Garante que o registo cumpre os requisitos do GitHub. O registo deve:
    • Siga a especificação do registo MCP v0.1
    • Expor os endpoints HTTPS necessários:
      • GET /v0.1/servers
      • GET /v0.1/servers/{serverName}/versions/latest
      • GET /v0.1/servers/{serverName}/versions/{version}
    • Incluir os cabeçalhos CORS necessários para que o Copilot possa aceder a ele:
      • Acesso-Controlo-Permitir-Origem: *
      • Métodos Acesso-Controlo-Permite: GET, OPTIONS
      • Cabeçalhos de Controlo-de Acesso: Autorização, Tipo de Conteúdo
  3. (Opcional) Incluir servidores MCP locais:
    • Se quiser que os programadores usem servidores MCP locais sob políticas restritas, esses servidores devem estar listados no registo
    • Os IDs dos servidores devem corresponder exatamente
  4. (Alternativa) Use Azure API Center
    • O Azure API Center pode funcionar como um registo MCP gerido
    • Ative o acesso anónimo para que o Copilot possa aceder ao registo
    • Copie a URL do endpoint do API Center para uso posterior
  5. Forneça o URL do registo à sua organização ou empresa
    • Este URL será usado nas definições da política do Copilot
    • Torna o registo disponível em toda a sua empresa

Uma vez configurado, o registo torna-se a fonte de verdade para os servidores MCP disponíveis, permitindo aos programadores descobrir e utilizar ferramentas aprovadas de forma consistente.

O que é uma lista de autorizações?

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

Isto é importante porque o MCP expande o que um agente pode aceder. Sem proteções, um agente poderia ser ligado a ferramentas que expõem sistemas sensíveis ou permitem ações inseguras.

Uma lista de permissão resolve isto ao restringir o uso do servidor a entradas aprovadas. Na prática, isto significa que uma organização ou empresa pode decidir se os programadores podem:

  • Use sempre os servidores MCP
  • Usa qualquer servidor MCP
  • Use apenas servidores MCP específicos definidos num registo

O GitHub suporta a aplicação da lista de permissão MCP ao nível da organização e da empresa, associada à função Copilot que supervisiona o utilizador.

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

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

  • O servidor MCP expõe ferramentas
  • O registo torna os servidores detetáveis e de confiança
  • A lista de permitidos decide quais os servidores permitidos

Juntos, criam um modelo que é ao mesmo tempo flexível e controlado.

Um programador ou equipa pode descobrir servidores úteis através de um registo, enquanto a organização mantém a governação sobre quais servidores são permitidos na prática.

Configurar listas de permissões MCP

Listas de permissão MCP controlam quais servidores MCP os programadores estão autorizados a utilizar. Isto é configurado ao nível da organização ou empresa no GitHub.

Passos (Enterprise):

  1. Aceda à sua organização no GitHub
  2. No topo da página, clique em controlos de IA
  3. Na barra lateral, clique em MCP
  4. Garanta que os servidores MCP no Copilot estão configurados como Ativados em todo o lado
  5. Na secção URL do Registo MCP:
    • Introduza a URL do seu registo
    • Clique em Guardar
    • Se estiver a usar o Azure API Center, introduza apenas a URL base (não inclua /v0.1/servers)
  6. Em Restringir o acesso MCP a servidores de registo, escolha:
    • Permitir todos: sem restrições, qualquer servidor MCP pode ser usado
    • Apenas servidores do registo são permitidos

Passos (Organização):

  1. No GitHub, clique na sua foto de perfil e selecione Organizações
  2. Selecione a sua organização
  3. Clique em Definições
  4. Na barra lateral, clique em Copilot, depois em Políticas
  5. Na secção de Características:
    • Garantir que os servidores MCP no Copilot estão Ativados
  6. (Opcional) Na URL do Registo MCP:
    • Introduza o URL do seu registo
    • Clique em Guardar
    • Se estiver a usar o Azure API Center, introduza apenas a URL base
  7. Em Restringir o acesso MCP a servidores de registo, escolha:
    • Permitir tudo
    • Apenas registo

Note

Notas: Se a opção Permitir tudo estiver selecionada, os programadores podem adicionar e usar qualquer servidor MCP sem restrições. Se apenas o Registo for selecionado, os programadores ficam limitados a usar apenas os servidores MCP definidos no registo configurado. Neste caso, até os servidores MCP locais devem estar incluídos no registo, e os seus IDs de servidor devem corresponder exatamente. Uma vez selecionada uma política, aplica-se imediatamente a todos os programadores.

As listas de permissões garantem que os agentes utilizam apenas servidores MCP aprovados, dando às organizações controlo sobre que ferramentas podem ser acedidas.

Um fluxo de trabalho prático no GitHub

Um fluxo MCP realista centrado no GitHub é o seguinte:

  1. Uma organização configura um registo MCP
  2. A organização define uma política de lista de permissão para servidores aprovados
  3. Um programador abre um IDE ou cliente compatível com MCP
  4. O cliente descobre servidores aprovados no registo
  5. O programador ativa um servidor como o GitHub MCP
  6. O agente utiliza ferramentas desse servidor durante uma tarefa

Neste modelo, os agentes ganham novas capacidades sem abdicar do controlo sobre a segurança e a governação.

Porque isto é importante para a execução do agente

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

Para usar o MCP de forma segura em larga escala, precisas de mais do que conectividade. Precisas:

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

Essa combinação torna o MCP prático para equipas reais. Permite aos agentes expandir-se para além do GitHub, mantendo a configuração gerível e o acesso controlado.

Principal conclusão

O MCP estende as capacidades dos agentes ligando-os a ferramentas através dos servidores MCP. Os registos simplificam a forma como esses servidores são descobertos e configurados. As listas de permissão fornecem os limites que decidem quais os servidores permitidos.

Juntas, estas peças tornam o MCP escalável e governável.

De seguida, vais aprender a definir ambientes de execução e limites de permissões para que os agentes possam usar ferramentas ligadas ao GitHub e ao MCP em segurança.