MCP-servrar (Model Context Protocol), register och tillåtna listor

Agenter blir mer användbara när de kan gå utanför lagringsplatsen och interagera med andra verktyg, system och tjänster. Model Context Protocol, eller MCP, gör det möjligt genom att ge agenter ett konsekvent sätt att identifiera och använda externa funktioner.

I GitHub miljöer handlar MCP inte bara om att ansluta till verktyg. Det handlar också om att styra hur dessa verktyg introduceras, konfigureras och styrs. Det omfattar att konfigurera MCP-servrar, använda ett register för att identifiera tillgängliga servrar och framtvinga tillåtna listor så att endast godkända servrar kan användas.

I den här lektionen får du lära dig:

• Vad MCP är
• Så här fungerar MCP-servrar
• Så gör register serverupptäckt enklare
• Så här styr tillåtna listor vilka servrar som kan användas
• Så här passar MCP in i agentiska arbetsflöden och agentverktyg på GitHub

Vad är MCP?

Model Context Protocol är ett standardsätt för AI-klienter att ansluta till verktyg och tjänster via MCP-servrar. I stället för att skapa en engångsintegrering för varje verktyg kan en MCP-kompatibel klient ansluta till en server som exponerar verktyg i ett strukturerat format.

Detta ger agenter en konsekvent modell för:

• Identifiera tillgängliga verktyg
• Skicka strukturerade begäranden
• Ta emot strukturerade resultat
• Återanvända samma interaktionsmönster i olika system

Vad är en MCP-server?

En MCP-server är komponenten som exponerar verktyg för en AI-klient.

Servern finns mellan klienten och det underliggande systemet. Den presenterar tillgängliga verktyg i ett format som klienten förstår, accepterar begäranden och utför sedan den verkliga åtgärden mot den anslutna tjänsten.

Beroende på konfigurationen kan en MCP-server:

• Köra lokalt på en utvecklardator
• Kör på distans som en värdbaserad tjänst
• Ansluta till lokala resurser
• Brygga till fjärranslutna API:er och plattformar

GitHub MCP-servern är ett exempel. Den ansluter AI-klienter till GitHub funktioner som lagringsplatser, problem och pull-begäranden.

Lokala och fjärranslutna MCP-servrar

MCP-servrar kan konfigureras lokalt eller via fjärranslutning.

En lokal MCP-server körs på datorn. Detta är användbart när du vill ha mer kontroll över konfiguration, åtkomst till lokala resurser eller en anpassad konfiguration.

En fjärr-MCP-server finns någon annanstans och nås via nätverket. Detta minskar installationsarbetet och gör det enklare att använda samma server i olika miljöer.

I IDE:er som stöds kan GitHub MCP-servern konfigureras via fjärranslutning eller lokalt, med fjärralternativet positionerat som rekommenderad konfiguration för de flesta användare. GitHub Enterprise Server stöder lokal MCP-serverkonfiguration, medan GitHub Enterprise Cloud med datahemvist stöder både lokala och fjärranslutna alternativ.

Lägga till en fjärr-MCP-server som ett verktyg i en agent (VS Code)

MCP-servrar läggs till direkt via Copilot Chat-gränssnittet och blir verktyg som agenten kan använda.

Steps:

1. Klicka på ikonen GitHub Copilot överst i redigeraren
2. Öppna Copilot Chat och växla till agentläge
3. Klicka på ikonen Verktyg i chattpanelen
4. Klicka på Konfigurera verktyg i det övre högra hörnet på panelen Copilot Chat.
5. Klicka på Lägg till MCP-server
6. I installationsdialogrutan:
   1. Välj HTTP som servertyp
   2. Ange server-URL:en (till exempel för GitHub MCP-server):
   3. https://api.githubcopilot.com/mcp/
   4. Tryck på Enter
   5. Ett servernamn genereras automatiskt
   6. Välj omfång; aktuell arbetsyta eller alla arbetsytor
   7. Klicka på autentisera och logga in till GitHub
   8. Spara konfigurationen

MCP-servern är nu tillgänglig som ett verktyg i agenten och agenten kan anropa dess funktioner under aktiviteter.

Lägga till en lokal MCP-server som ett verktyg i en agent

En lokal MCP-server körs på datorn och gör att agenten kan interagera med lokala verktyg, filer eller anpassade tjänster. Konfigurationsprocessen i VS Code är densamma som när du lägger till en MCP-server.

Den enda skillnaden är den server som du ansluter till. I stället för att använda en värdbaserad URL som den GitHub MCP-servern anger du en lokal slutpunkt, till exempel:

http://localhost:3000

Lokala MCP-servrar:

• Kör på din dator
• Kan komma åt lokala resurser och anpassade arbetsflöden
• Kräver vanligtvis inte extern autentisering

Vad är ett MCP-register?

Ett MCP-register är en katalog med MCP-servrar.

I stället för att be alla utvecklare att manuellt konfigurera varje server, ger ett register en central plats där kompatibla klienter kan identifiera vilka servrar som är tillgängliga och hur de ska användas.

Detta förenklar konfigurationen på två sätt:

• Det gör serverupptäckt enklare
• Den standardiserar hur servrar beskrivs och distribueras

Som standard kan IDE-funktioner som stöds använda GitHub MCP Registry, och utvecklare kan också växla till ett anpassat register när det behövs.

Så här hjälper register till med konfigurationen

Register minskar friktionen eftersom de tar bort mycket av det manuella arbetet med att lägga till servrar.

I stället för att redigera konfigurationsfiler för hand för varje server kan en utvecklare bläddra i eller söka i ett register, välja en server, installera den och lita på att den används i deras miljö.

Detta gör register särskilt användbara när:

• Teams vill ha en enklare konfigurationsupplevelse
• Organisationer vill ha en standarduppsättning godkända servrar
• Utvecklare behöver en kurerad lista i stället för ohanterad upptäckt

GitHub stöder även anpassade MCP-register för organisationer och företag, så länge registret följer den nödvändiga MCP-registerspecifikationen och slutpunktsstrukturen.

Konfigurera MCP-register

Om du vill använda ett anpassat MCP-register i GitHub måste en organisation eller ett företag skapa eller vara värd för ett register som GitHub Copilot kan komma åt.

Steps:

1. Skapa eller vara värd för ett MCP-register. Du kan göra detta på något av tre sätt:
   • Förgrening och egen värd för MCP-registret med öppen källkod
   • Kör registret med öppen källkod lokalt med Docker
   • Skapa och publicera din egen implementering av anpassade register
2. Kontrollera att registret uppfyller GitHub krav. Registret måste:
   • Följ specifikationen för MCP-registret v0.1
   • Exponera nödvändiga HTTPS-slutpunkter:
     • GET /v0.1/servers
     • GET /v0.1/servers/{serverName}/versions/latest
     • GET /v0.1/servers/{serverName}/versions/{version}
   • Inkludera nödvändiga CORS-huvuden så att Copilot kan komma åt det:
     • Access-Control-Allow-Origin: *
     • Access-Control-Allow-Methods: GET, OPTIONS
     • Access-Control-Allow-Headers: Authorization, Content-Type
3. (Valfritt) Inkludera lokala MCP-servrar:
   • Om du vill att utvecklare ska använda lokala MCP-servrar under begränsade principer måste dessa servrar anges i registret
   • Server-ID:t måste matcha exakt
4. (Alternativ) Använda Azure API Center
   • Azure API Center kan fungera som ett hanterat MCP-register
   • Aktivera anonym åtkomst så att Copilot kan hämta registret
   • Kopiera API Center-slutpunkts-URL:en för senare användning
5. Ange register-URL:en till din organisation eller ditt företag
   • Den här URL:en används i Copilot principinställningar
   • Det gör registret tillgängligt i hela företaget

När registret har konfigurerats blir det sanningens källa för tillgängliga MCP-servrar, vilket gör det möjligt för utvecklare att identifiera och använda godkända verktyg på ett konsekvent sätt.

Vad är en lista över tillåtna?

En lista över tillåtna är en princip som styr vilka MCP-servrar som tillåts.

Detta är viktigt eftersom MCP utökar vad en agent kan komma åt. Utan skyddsräcken kan en agent anslutas till verktyg som exponerar känsliga system eller tillåter osäkra åtgärder.

En lista över tillåtna löser detta genom att begränsa serveranvändningen till godkända poster. I praktiken innebär det att en organisation eller ett företag kan avgöra om utvecklare kan:

• Använd MCP-servrar alls
• Använda valfri MCP-server
• Använd endast specifika MCP-servrar som definierats i ett register

GitHub har stöd för genomdrivande av MCP-tillåtelselista på organisations- och företagsnivå, kopplat till den Copilot-licens som hanterar användaren.

Så här fungerar MCP-servrar, register och tillåtna listor tillsammans

Dessa tre begrepp löser olika delar av samma problem:

• MCP-servern exponerar verktyg
• Registret gör servrarna identifierbara och tillförlitliga
• Tillåt lista avgör vilka servrar som tillåts

Tillsammans skapar de en modell som är både flexibel och kontrollerad.

En utvecklare eller ett team kan identifiera användbara servrar via ett register, medan organisationen fortfarande behåller styrningen över vilka servrar som tillåts i praktiken.

Konfigurera MCP-tillåtna listor

MCP tillåter listor som styr vilka MCP-servrar som utvecklare får använda. Detta konfigureras på organisations- eller företagsnivå i GitHub.

Steg (Företag):

1. Gå till ditt företag på GitHub
2. Överst på sidan klickar du på AI-kontroller
3. I sidofältet klickar du på MCP
4. Kontrollera att MCP-servrar i Copilot är inställda på Aktiverad överallt
5. I avsnittet för URL:en till MCP-registret:
   • Ange URL:en för registret
   • Klicka på Spara
   • Om du använder Azure API Center anger du endast bas-URL:en (inkludera inte /v0.1/servers)
6. I Begränsa MCP-åtkomst till registerservrar väljer du:
   • Tillåt alla → inga begränsningar, kan alla MCP-servrar användas
   • Register endast → endast servrar från registret tillåts

Steg (Organisation):

1. I GitHub klickar du på profilbilden och väljer Organisationer
2. Välj din organisation
3. Klicka på Inställningar
4. Klicka på Copilot i sidofältet och sedan på Principer
5. I avsnittet Funktioner:
   • Kontrollera att MCP-servrar i Copilot är aktiverade
6. (Valfritt) I MCP-registrets URL:
   • Ange din registeradress
   • Klicka på Spara
   • Om du använder Azure API Center anger du endast bas-URL:en
7. I Begränsa MCP-åtkomst till registerservrar väljer du:
   • Tillåt alla
   • Endast register

Tillåtelselistor ser till att agenter endast använder godkända MCP-servrar, som ger organisationer kontroll över verktyg som kan användas.

Ett praktiskt GitHub arbetsflöde

Ett realistiskt GitHub centrerad MCP-flöde ser ut så här:

1. En organisation konfigurerar ett MCP-register
2. Organisationen definierar en tillåtelselista för godkända servrar
3. En utvecklare öppnar en MCP-kompatibel IDE eller klient
4. Klienten identifierar godkända servrar från registret
5. Utvecklaren aktiverar en server som GitHub MCP-server
6. Agenten använder verktyg från servern under en uppgift

I den här modellen får agenter nya funktioner utan att ge upp kontrollen över säkerhet och styrning.

Varför detta är viktigt för agentutförande

MCP ger agenter tillgång till fler verktyg, men fler verktyg innebär också mer ansvar.

Om du vill använda MCP på ett säkert sätt i stor skala behöver du mer än anslutning. Du behöver:

• En server som exponerar verktyg korrekt
• Ett register som gör godkända servrar identifierbara
• En lista över tillåtna som begränsar vad som kan användas

Den kombinationen gör MCP praktiskt för riktiga team. Det gör att agenter kan expandera bortom GitHub samtidigt som konfigurationen är hanterbar och åtkomstkontrollerad.

Viktig insikt

MCP utökar agentfunktionerna genom att ansluta dem till verktyg via MCP-servrar. Register förenklar hur dessa servrar identifieras och konfigureras. Tillåtslistor anger de regler som bestämmer vilka servrar som tillåts.

Tillsammans gör dessa bitar MCP både skalbart och styrbart.

Därefter får du lära dig hur du definierar körningsmiljöer och behörighetsgränser så att agenter kan använda GitHub och MCP-anslutna verktyg på ett säkert sätt.