MCP-servers (Model Context Protocol), registers en acceptatielijsten

  • 5 minuten

Agents worden nuttiger wanneer ze verder kunnen gaan dan de opslagplaats en kunnen communiceren met andere hulpprogramma's, systemen en services. ModelContext Protocol of MCP maakt dat mogelijk door agents een consistente manier te bieden om externe mogelijkheden te detecteren en te gebruiken.

In GitHub omgevingen gaat MCP niet alleen over het maken van verbinding met hulpprogramma's. Het gaat ook om het beheren van de wijze waarop deze hulpprogramma's worden geïntroduceerd, geconfigureerd en beheerd. Dit omvat het configureren van MCP-servers, het gebruik van een register om beschikbare servers te detecteren en acceptatielijsten af te dwingen, zodat alleen goedgekeurde servers kunnen worden gebruikt.

In deze les leert u het volgende:

  • Wat is MCP
  • Hoe MCP-servers werken
  • Hoe registers serverdetectie eenvoudiger maken
  • Hoe lijsten toestaan bepalen welke servers kunnen worden gebruikt
  • Hoe MCP past in agentische werkstromen en agenthulpprogramma's op GitHub

Wat is MCP?

Model Context Protocol is een standaardmethode voor AI-clients om verbinding te maken met hulpprogramma's en services via MCP-servers. In plaats van een eenmalige integratie te bouwen voor elk hulpprogramma, kan een met MCP compatibele client verbinding maken met een server die hulpprogramma's in een gestructureerde indeling beschikbaar maakt.

Dit biedt agents een consistent model voor:

  • Beschikbare hulpprogramma's ontdekken
  • Gestructureerde aanvragen verzenden
  • Gestructureerde resultaten ontvangen
  • Hetzelfde interactiepatroon hergebruiken in verschillende systemen

Wat is een MCP-server?

Een MCP-server is het onderdeel dat hulpprogramma's beschikbaar maakt voor een AI-client.

De server bevindt zich tussen de client en het onderliggende systeem. Het biedt beschikbare hulpprogramma's in een indeling die de client begrijpt, aanvragen accepteert en vervolgens de echte actie uitvoert op basis van de verbonden service.

Afhankelijk van de installatie kan een MCP-server het volgende doen:

  • Lokaal uitvoeren op een ontwikkelcomputer
  • Extern uitvoeren als een gehoste service
  • Verbinding maken met lokale resources
  • Brug naar externe API's en platforms

De GitHub MCP-server is één voorbeeld. Het verbindt AI-clients met GitHub mogelijkheden, zoals opslagplaatsen, problemen en pull-aanvragen.

Lokale en externe MCP-servers

MCP-servers kunnen lokaal of extern worden geconfigureerd.

Een lokale MCP-server wordt uitgevoerd op uw computer. Dit is handig als u meer controle wilt over configuratie, toegang tot lokale resources of een aangepaste installatie.

Een externe MCP-server wordt elders gehost en toegankelijk via het netwerk. Dit vermindert het installatiewerk en maakt het eenvoudiger om dezelfde server in verschillende omgevingen te gebruiken.

In ondersteunde IDE's kan de GitHub MCP-server extern of lokaal worden geconfigureerd, waarbij de externe optie is ingesteld als de aanbevolen installatie voor de meeste gebruikers. GitHub Enterprise Server ondersteunt lokale MCP-serverconfiguratie, terwijl GitHub Enterprise Cloud met gegevenslocatie zowel lokale als externe opties ondersteunt.

Een externe MCP-server toevoegen als hulpprogramma aan een agent (VS Code)

MCP-servers worden rechtstreeks toegevoegd via de Copilot Chat-interface en worden hulpprogramma's die de agent kan gebruiken.

Steps:

  1. Klik boven aan de editor op het pictogram GitHub Copilot
  2. Open Copilot Chat en schakel over naar de agentmodus
  3. Klik op het hulpprogramma's-pictogram in het chatpanel
  4. Klik op Hulpprogramma's configureren in de rechterbovenhoek van het deelvenster Copilot Chat.
  5. Klik op MCP-server toevoegen
  6. In het installatiedialoogvenster:
    1. SELECTEER HTTP als het servertype
    2. Voer de server-URL in (bijvoorbeeld voor GitHub MCP-server):
    3. https://api.githubcopilot.com/mcp/
    4. Druk op Enter
    5. Er wordt automatisch een servernaam gegenereerd
    6. Kies het bereik; huidige werkruimte of alle werkruimten
    7. Klik op Verifiëren en meld u aan bij GitHub.
    8. De configuratie opslaan

De MCP-server is nu beschikbaar als hulpprogramma in de agent en de agent kan de mogelijkheden aanroepen tijdens taken.

Een lokale MCP-server toevoegen als hulpprogramma aan een agent

Een lokale MCP-server wordt uitgevoerd op uw computer en stelt uw agent in staat om te communiceren met lokale hulpprogramma's, bestanden of aangepaste services. Het installatieproces in VS Code is hetzelfde als het toevoegen van een MCP-server.

Het enige verschil is de server waarmee u verbinding maakt. In plaats van een gehoste URL zoals de GitHub MCP-server te gebruiken, geeft u een lokaal eindpunt op, bijvoorbeeld:

http://localhost:3000

Lokale MCP-servers:

  • Uitvoeren op uw computer
  • Toegang tot lokale resources en aangepaste werkstromen
  • Normaal gesproken is geen externe verificatie vereist

Wat is een MCP-register?

Een MCP-register is een catalogus met MCP-servers.

In plaats van elke ontwikkelaar te vragen om elke server handmatig te configureren, biedt een register een centrale locatie waar compatibele clients kunnen detecteren welke servers beschikbaar zijn en hoe ze kunnen worden gebruikt.

Dit vereenvoudigt de installatie op twee manieren:

  • Het maakt serverdetectie eenvoudiger
  • Het standaardiseert hoe servers worden beschreven en gedistribueerd

Standaard kunnen ondersteunde IDE-ervaringen gebruikmaken van het GitHub MCP-register en kunnen ontwikkelaars zo nodig ook overschakelen naar een aangepast register.

Hoe registers helpen met configuratie

Registers verminderen wrijving omdat ze veel van het handmatige werk verwijderen dat betrokken is bij het toevoegen van servers.

In plaats van configuratiebestanden handmatig te bewerken voor elke server, kan een ontwikkelaar door een register bladeren of zoeken, een server selecteren, installeren en vertrouwen voor gebruik in hun omgeving.

Dit maakt registers vooral nuttig wanneer:

  • Teams willen een eenvoudigere installatie-ervaring
  • Organisaties willen een standaardset goedgekeurde servers
  • Ontwikkelaars hebben een gecureerde lijst nodig in plaats van onbeheerde detectie

GitHub ondersteunt ook aangepaste MCP-registers voor organisaties en ondernemingen, zolang het register voldoet aan de vereiste MCP-registerspecificatie en eindpuntstructuur.

MCP-registers configureren

Als u een aangepast MCP-register in GitHub wilt gebruiken, moet een organisatie of onderneming een register maken of hosten waartoe GitHub Copilot toegang heeft.

Steps:

  1. Maak of host een MCP-register. U kunt dit op drie manieren doen:
    • Fork en zelf host het open-source MCP-Register
    • Het opensource-register lokaal uitvoeren met Docker
    • Uw eigen aangepaste register-implementatie bouwen en publiceren
  2. Zorg ervoor dat het register voldoet aan GitHub vereisten. Het register moet:
    • Volg het MCP-register v0.1-specificatie
    • Maak de vereiste HTTPS-eindpunten beschikbaar:
      • GET /v0.1/servers
      • GET /v0.1/servers/{serverName}/versions/latest
      • GET /v0.1/servers/{serverName}/versions/{version}
    • Neem vereiste CORS-headers op, zodat Copilot er toegang toe heeft:
      • Access-Control-Allow-Origin: *
      • Access-Control-Allow-Methods: GET, OPTIONS
      • Access-Control-Allow-Headers: Autorisatie, Inhoudstype
  3. (Optioneel) Lokale MCP-servers opnemen:
    • Als u wilt dat ontwikkelaars lokale MCP-servers gebruiken onder beperkt beleid, moeten deze servers worden vermeld in het register
    • Server-id's moeten exact overeenkomen
  4. (Alternatief) Azure API Center gebruiken
    • Azure API Center kan fungeren als een beheerd MCP-register
    • Anonieme toegang inschakelen zodat Copilot het register kan ophalen
    • De EINDPUNT-URL van HET API Center kopiëren voor later gebruik
  5. Geef de register-URL op voor uw organisatie of onderneming
    • Deze URL wordt gebruikt in Copilot beleidsinstellingen
    • Het register beschikbaar maken in uw bedrijf

Zodra het is geconfigureerd, wordt het register de bron van waarheid voor beschikbare MCP-servers, zodat ontwikkelaars goedgekeurde hulpprogramma's op een consistente manier kunnen detecteren en gebruiken.

Wat is een acceptatielijst?

Een acceptatielijst is een beleid dat bepaalt welke MCP-servers zijn toegestaan.

Dit is belangrijk omdat MCP uitbreidt waartoe een agent toegang heeft. Zonder kaders kan een agent worden verbonden met hulpprogramma's die gevoelige systemen blootstellen of onveilige acties toestaan.

Een acceptatielijst lost dit op door servergebruik te beperken tot goedgekeurde vermeldingen. In de praktijk betekent dit dat een organisatie of onderneming kan bepalen of ontwikkelaars het volgende kunnen doen:

  • MCP-servers helemaal gebruiken
  • Een MCP-server gebruiken
  • Alleen specifieke MCP-servers gebruiken die zijn gedefinieerd in een register

GitHub ondersteunt het afdwingen van MCP-acceptatielijsten op organisatie- en ondernemingsniveau, verbonden aan de Copilot seat die het beheer van de gebruiker regelt.

Hoe MCP-servers, registers en acceptatielijsten samenwerken

Deze drie concepten lossen verschillende onderdelen van hetzelfde probleem op:

  • MCP-server biedt hulpprogramma's
  • Register maakt servers detecteerbaar en vertrouwbaar
  • Lijst toestaan bepaalt welke servers zijn toegestaan

Samen maken ze een model dat zowel flexibel als beheerd is.

Een ontwikkelaar of team kan nuttige servers detecteren via een register, terwijl de organisatie nog steeds governance behoudt over welke servers in de praktijk zijn toegestaan.

MCP-acceptatielijsten configureren

MCP-acceptatielijsten bepalen welke MCP-servers ontwikkelaars mogen gebruiken. Dit is geconfigureerd op organisatie- of ondernemingsniveau in GitHub.

Stappen (Enterprise):

  1. Navigeer naar uw onderneming op GitHub
  2. Klik boven aan de pagina op AI-besturingselementen
  3. Klik in de zijbalk op MCP
  4. Zorg ervoor dat MCP-servers in Copilot overal zijn ingesteld op Ingeschakeld
  5. In de sectie MCP-register-URL:
    • Voer de URL van uw register in
    • Klik op Opslaan
    • Als u Azure API Center gebruikt, voert u alleen de basis-URL in (neem geen /v0.1/servers op)
  6. Kies in MCP-toegang tot registerservers beperken:
    • Geen beperkingen toestaan, elke MCP-server kan worden gebruikt
    • Alleen → alleen servers uit het register zijn toegestaan

Stappen (organisatie):

  1. Klik in GitHub op uw profielfoto en selecteer Organisaties
  2. Uw organisatie selecteren
  3. Klik op Instellingen
  4. Klik in de zijbalk op Copilot en vervolgens op Beleid
  5. In de sectie Functies:
    • Zorg ervoor dat MCP-servers in Copilot is ingeschakeld
  6. (Optioneel) In MCP-register-URL:
    • Voer uw register-URL in
    • Klik op Opslaan
    • Als u Azure API Center gebruikt, voert u alleen de basis-URL in
  7. Kies in MCP-toegang tot registerservers beperken:
    • Alles toestaan
    • Alleen registratie

Note

Opmerkingen: Als de optie Alles toestaan is geselecteerd, kunnen ontwikkelaars zonder beperkingen een MCP-server toevoegen en gebruiken. Als alleen register is geselecteerd, kunnen ontwikkelaars alleen de MCP-servers gebruiken die zijn gedefinieerd in het geconfigureerde register. In dit geval moeten zelfs lokale MCP-servers worden opgenomen in het register en moeten hun server-id's exact overeenkomen. Zodra een beleid is geselecteerd, wordt het onmiddellijk toegepast op alle ontwikkelaars.

Acceptatielijsten zorgen ervoor dat agents alleen goedgekeurde MCP-servers gebruiken, waardoor organisaties kunnen bepalen welke hulpprogramma's kunnen worden geopend.

Een praktische GitHub werkstroom

Een realistische GitHub-gecentreerde MCP-stroom ziet er als volgt uit:

  1. Een organisatie configureert een MCP-register
  2. De organisatie definieert een beleid voor toegestane lijsten voor goedgekeurde servers
  3. Een ontwikkelaar opent een IDE of client die geschikt is voor MCP
  4. De client detecteert goedgekeurde servers uit het register
  5. De ontwikkelaar schakelt een server in, zoals de GitHub MCP-server
  6. De agent gebruikt hulpprogramma's van die server tijdens een taak

In dit model krijgen agents nieuwe mogelijkheden zonder controle over beveiliging en governance op te geven.

Waarom dit belangrijk is voor agentuitvoering

MCP biedt agents toegang tot meer hulpprogramma's, maar meer hulpprogramma's betekent ook meer verantwoordelijkheid.

Als u MCP veilig op schaal wilt gebruiken, hebt u meer nodig dan connectiviteit. U hebt het volgende nodig:

  • Een server die hulpprogramma's correct beschikbaar maakt
  • Een register dat goedgekeurde servers detecteerbaar maakt
  • Een acceptatielijst die beperkt wat kan worden gebruikt

Deze combinatie maakt MCP praktisch voor echte teams. Hierdoor kunnen agents zich uitbreiden buiten GitHub, terwijl de installatie eenvoudig te houden is en de toegang beheerd blijft.

Belangrijkste bevinding

MCP breidt agentmogelijkheden uit door ze te verbinden met hulpprogramma's via MCP-servers. Registers vereenvoudigen hoe deze servers worden gedetecteerd en geconfigureerd. Toestemmingslijsten bieden de richtlijnen die bepalen welke servers zijn toegelaten.

Samen maken deze onderdelen MCP schaalbaar en bestuurbaar.

Vervolgens leert u hoe u uitvoeringsomgevingen en machtigingsgrenzen definieert, zodat agents veilig GitHub en met MCP verbonden hulpprogramma's kunnen gebruiken.