Einführung
Bei Model Context Protocol (MCP) handelt es sich um einen offenen Standard, der definiert, wie Anwendungen Kontext mit großen Sprachmodellen (LLMs) teilen. Eine Übersicht über MCP findest du unter Informationen zum Model Context Protocol (MCP).
Informationen zu derzeit verfügbaren MCP-Servern findest du im Repository der MCP-Server.
Unternehmen und Organisationen können die Verwendung von MCP für Mitglieder ihrer Organisation oder ihres Unternehmens über die Richtlinie MCP servers in Copilot aktivieren oder deaktivieren. Diese Richtlinie ist standardmäßig deaktiviert. Weitere Informationen findest du unter Verwalten von Richtlinien und Features für GitHub Copilot in deinem Unternehmen und Verwalten von Richtlinien und Features für GitHub Copilot in deiner Organisation. Die MCP-Richtlinie gilt nur für Benutzende, die über ein Copilot Business- oder Copilot Enterprise-Abonnement von einer Organisation oder einem Unternehmen verfügen, das die Richtlinie konfiguriert. Copilot Free, Copilot Pro oder Copilot Pro+ verfügen nicht über ihren MCP-Zugriff, der von dieser Richtlinie gesteuert wird.
Voraussetzungen
- Zugriff auf Copilot Weitere Informationen findest du unter Was ist GitHub Copilot?.
- Visual Studio Code Version 1.99 oder höher. Informationen zum Installieren von Visual Studio Code findest du auf der Visual Studio Code-Downloadseite.
- Wenn du Mitglied einer Organisation oder eines Unternehmens mit einem Copilot Business- oder Copilot Enterprise-Plan bist, muss die Richtlinie „MCP servers in Copilot“ aktiviert sein, damit MCP mit Copilot verwendet werden kann.
Konfigurieren von MCP-Servern in Visual Studio Code
MCP-Server können manuell in einer Konfigurationsdatei oder über die MCP-Registrierung von GitHub konfiguriert werden. Die MCP-Registrierung von GitHub enthält eine kuratierte Liste von MCP-Servern, die du deiner Visual Studio Code-Instanz einfach hinzufügen kannst.
Verwenden der MCP-Registrierung von GitHub
Hinweis
Die MCP-Registrierung GitHub befindet sich in der public preview. Änderungen sind vorbehalten.
Ausschließlich MCP-Server, die in der MCP-Registrierung von GitHub aufgeführt sind, können über die Registrierung hinzugefügt werden. Weitere Server können manuell konfiguriert werden. Weitere Informationen findest du unter Manuelles Konfigurieren von MCP-Servern.
- Besuche die MCP-Registrierung von GitHub.
- Suche in der Suchleiste nach dem MCP-Server, den du hinzufügen möchtest, und klicke anschließend in der Liste der Übereinstimmungen auf den MCP-Server.
- Lies auf der Seite des MCP-Servers die Beschreibung, um Details zu den Installationsanforderungen und weitere wichtige Nutzungsinformationen zu erfahren. Das kann je nach Server variieren.
- Klicke auf Install server, und wähle Install in VS Code aus.
- Visual Studio Code wird auf der Marketplaceseite des Servers geöffnet. Klicke auf Install, um deiner Visual Studio Code-Instanz den MCP-Server hinzuzufügen.
- Wenn eine weitere Konfiguration erforderlich ist, befolge die Anweisungen auf der Seite des MCP-Servers in der MCP-Registrierung von GitHub.
- Um zu überprüfen, ob der MCP-Server hinzugefügt wurde, klicke im Agent-Modus von Copilot Chat auf das Symbol „Tools“. Daraufhin wird eine Dropdownliste mit allen MCP-Servern und zugehörigen Tools angezeigt, die derzeit in deiner Visual Studio Code-Instanz verfügbar sind.
Manuelles Konfigurieren von MCP-Servern
Um in Visual Studio Code MCP-Server zu konfigurieren, musst du ein Konfigurationsskript einrichten, das die Details der gewünschten MCP-Server angibt. Du kannst MCP-Server für Folgendes konfigurieren:
-
Ein bestimmtes Repository: Dadurch kannst du MCP-Server für alle Personen freigegeben, die das Projekt in Visual Studio Code öffnen. Erstelle hierzu im Stammverzeichnis deines Repositorys eine
.vscode/mcp.json
-Datei. -
Deine persönliche Instanz von Visual Studio Code: Du bist die einzige Person mit Zugriff auf konfigurierte MCP-Server. Füge deiner
settings.json
-Datei hierzu in Visual Studio Code die Konfiguration hinzu. MCP-Server, die auf diese Weise konfiguriert wurden, sind in allen Arbeitsbereichen verfügbar.Hinweis
We recommend you use only one location per server. Adding the same server to both locations may cause conflicts and unexpected behavior.
Die folgenden Schritte veranschaulichen, wie du in deiner .vscode/mcp.json
-Datei den Fetch MCP-Server konfigurierst. Der Fetch MCP-Server ist ein einfacher MCP-Server, der Funktionen zum Fetchen von Webinhalten bereitstellt. Weitere Informationen zum Fetch MCP-Server findest du im MCP Server-Repository unter Fetch-Verzeichnis.
Du kannst dieselben Schritte verwenden, um MCP-Server in deinen persönlichen Visual Studio Code-Einstellungen zu konfigurieren. Details zum Konfigurieren weiterer MCP-Server sind im Repository der MCP-Server verfügbar.
Informationen zur Konfiguration des MCP-Servers von GitHub findest du unter Verwenden des GitHub-MCP-Servers.
-
Füge deiner
.vscode/mcp.json
-Datei die folgende Konfiguration hinzu:JSON { "inputs": [ // The "inputs" section defines the inputs required for the MCP server configuration. { "type": "promptString" } ], "servers": { // The "servers" section defines the MCP servers you want to use. "fetch": { "command": "uvx", "args": ["mcp-server-fetch"] } } }
{ "inputs": [ // The "inputs" section defines the inputs required for the MCP server configuration. { "type": "promptString" } ], "servers": { // The "servers" section defines the MCP servers you want to use. "fetch": { "command": "uvx", "args": ["mcp-server-fetch"] } } }
-
Speichern Sie die Datei
.vscode/mcp.json
. -
In deiner
.vscode/mcp.json
-Datei wird oben in der Liste der Server die Schaltfläche „Start“ angezeigt. Klicke auf die Schaltfläche „Start“, um die MCP-Server zu starten. Dadurch werden der Eingabedialog ausgelöst und die Servertools ermittelt, die dann für spätere Sitzungen gespeichert werden. -
Öffne Copilot Chat durch Klicken auf das Symbol auf der Titelleiste von Visual Studio Code.
-
Wähle im Feld Copilot Chat im Popupmenü die Option Agent aus.
-
Um die Liste der verfügbaren MCP-Server anzuzeigen, klicke in der oberen linken Ecke des Chatfelds auf das Symbol „Tools“. Dadurch wird die Liste der MCP-Server geöffnet, in der alle MCP-Server und die zugehörigen Tools angezeigt werden, die derzeit in deiner Instanz von Visual Studio Code verfügbar sind.
- Optional kannst du Toolsets definieren. Dabei handelt es sich um verwandte Tools, auf die du im Chat verweisen kannst. Toolsets erleichtern es, verwandte MCP-Tools zu gruppen und schnell zu aktivieren oder zu deaktivieren. Informationen zur Definition und Verwendung von Toolsets findest du in der Dokumentation von VS Code.
Weitere Informationen zum Konfigurieren von MCP-Servern in Visual Studio Code findest du in der Visual Studio Code-Dokumentation unter Verwenden von MCP-Servern in Visual Studio Code.
Verwenden von MCP-Servern in Copilot Chat
Nachdem du deine MCP-Server konfiguriert hast, kannst du sie in Copilot Chat verwenden, um auf eine Vielzahl von Tools und Diensten zuzugreifen. Im folgenden Beispiel wird Fetch MCP-Server zum Fetchen von Details zu einer Webseite verwendet.
-
Öffne Copilot Chat durch Klicken auf das Symbol auf der Titelleiste von Visual Studio Code.
-
Wähle im Feld Copilot Chat im Popupmenü die Option Agent aus.
-
Stelle in der Datei mit der MCP-Konfiguration sicher, dass der MCP-Server ausgeführt wird. Wenn er nicht ausgeführt wird, klicke auf die Schaltfläche „Start“, um den MCP-Server zu starten.
-
Weise Copilot Chat an, die Details einer URL zu fetchen. Zum Beispiel:
Fetch https://github.com/github/docs.
-
Wenn du von Copilot aufgefordert wirst, zu bestätigen, dass du fortfahren möchtest, klicke auf Continue.
-
Copilot fetcht die Details der URL und zeigt diese im Chatfeld an.
Optional kannst du MCP-Prompts und -Ressourcen in VS Code verwenden.
- MCP-Server können vorkonfigurierte Prompts für die Interaktion mit ihren Tools definieren. Im Chat kannst du mit Slash-Befehlen im Format
/mcp.servername.promptname
auf diese Prompts zugreifen. - MCP-Server stellen Ressourcen bereit. Dabei handelt es sich um alle Daten, die der Server zur Verfügung stellen möchte. Beispielsweise stellt der MCP-Server von GitHub Repositoryinhalte als Ressource bereit. Um Ressourcen von einem MCP-Server zu deinem Chatkontext hinzuzufügen, klicke im Chatfeld auf Add Context... und dann auf MCP Resources.
Weitere Informationen zum Verwenden von MCP-Servern in Visual Studio Code findest du in der Visual Studio Code-Dokumentation unter Verwenden von MCP-Servern in Visual Studio Code.
Verwenden vorhandener MCP-Konfigurationen
Wenn du in Claude Desktop bereits über eine MCP-Konfiguration verfügst, kannst du diese Konfiguration in Visual Studio Code verwenden, um auf dieselben MCP-Server zuzugreifen. Füge deiner settings.json
-Datei hierzu in Visual Studio Code die folgende Konfiguration hinzu:
"chat.mcp.discovery.enabled": true
"chat.mcp.discovery.enabled": true
Visual Studio Code sucht deine vorhandene Konfiguration automatisch und verwendet sie in deiner Instanz von Visual Studio Code.
Voraussetzungen
- Zugriff auf Copilot Weitere Informationen findest du unter Was ist GitHub Copilot?.
- Visual Studio Version 17.14 oder höher. Weitere Informationen zum Installieren von Visual Studio findest du auf der Seite mit den Visual Studio-Downloads.
- Melde dich in Visual Studio bei GitHub an.
- Wenn du Mitglied einer Organisation oder eines Unternehmens mit einem Copilot Business- oder Copilot Enterprise-Plan bist, muss die Richtlinie „MCP servers in Copilot“ aktiviert sein, damit MCP mit Copilot verwendet werden kann.
Konfigurieren von MCP-Servern in Visual Studio
-
Klicke in der Menüleiste Visual Studio auf View und dann auf GitHub Copilot Chat.
-
Wähle unten im Chatpanel in der Dropdownliste den Modus Agent aus.
-
Klicke im Fenster von Copilot Chat auf das Symbol „Tools“ und dann im Toolauswahlfenster auf das Pluszeichen.
-
Fülle im Popupfenster „Configure MCP server“ die Felder aus, einschließlich der Server-ID, des Typs und aller zusätzlichen Felder, die für die spezifische MCP-Serverkonfiguration erforderlich sind.
Visual Studio unterstützt sowohl Remoteserver als auch lokale Server. Remoteserver, die mit einer URL und Anmeldeinformationen definiert sind, werden zur einfacheren Einrichtung und Freigabe extern gehostet, während lokale Server, die mit Befehlszeilenaufrufen definiert sind, auf deinem lokalen Computer ausgeführt werden und auf lokale Ressourcen zugreifen können. Sieh dir die folgenden Beispielkonfigurationen an, in denen der GitHub-MCP-Server verwendet wird.
-
Klicken Sie auf Speichern.
-
Wenn du einen Remoteserver mit OAuth-Authentifizierung verwendest, klicke in der Datei
mcp.json
in CodeLens über dem Server auf Auth, um die Authentifizierung beim Server durchzuführen. Es wird ein Popup oder ein neues Fenster angezeigt, in dem du dich mit deinem Konto authentifizieren kannst. Der Server kann nur auf die Bereiche zugreifen, die du genehmigst und die deine Organisationsrichtlinien zulassen. -
Klicke im Fenster von Copilot Chat auf das Symbol „Tools“. Nun sollten weitere Tools von dem MCP-Server, den du konfiguriert hast, angezeigt werden.
Beispiel für die Konfiguration eines Remoteservers mit OAuth
-
Gib unter „Server ID“
github
ein. -
Wähle unter „Type“ in der Dropdownliste die Option „HTTP/SSE“ aus.
-
Gib unter „URL“
https://api.githubcopilot.com/mcp/
ein. -
Nachdem du auf Speichern geklickt hast, sollte die Konfiguration in der Datei
mcp.json
wie folgt aussehen:JSON { "servers": { "github": { "url": "https://api.githubcopilot.com/mcp/" } } }
{ "servers": { "github": { "url": "https://api.githubcopilot.com/mcp/" } } }
-
Klicke in der Datei
mcp.json
in CodeLens über dem Server auf Auth, um die Authentifizierung beim Server durchzuführen. Es wird ein Popup angezeigt, in dem du dich mit deinem GitHub-Konto authentifizieren kannst.
Beispiel für die Konfiguration eines lokalen Servers
-
Gib unter „Server ID“
github
ein. -
Wähle unter „Type“ in der Dropdownliste die Option „stdio“ aus.
-
Gib unter „Command (with optional arguments)“
docker "run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"
ein. -
Füge eine Umgebungsvariable GITHUB_PERSONAL_ACCESS_TOKEN hinzu, die auf dein personal access token festgelegt ist.
-
Nachdem du auf Speichern geklickt hast, sollte die Konfiguration in der Datei
mcp.json
wie folgt aussehen:JSON { "servers": { "github": { "type": "stdio", "command": "docker", "args": [ "run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server" ], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT" } } } }
{ "servers": { "github": { "type": "stdio", "command": "docker", "args": [ "run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server" ], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT" } } } }
Weitere Informationen zum Konfigurieren von MCP-Servern in Visual Studio findest du in der Visual Studio-Dokumentation unter Verwenden von MCP-Servern in Visual Studio (Vorschau).
Voraussetzungen
-
Zugriff auf Copilot Weitere Informationen findest du unter Was ist GitHub Copilot?.
-
Eine kompatible JetBrains-IDE. GitHub Copilot ist mit den folgenden IDEs kompatibel:
- IntelliJ IDEA (Ultimate, Community, Educational)
- Android Studio
- AppCode
- CLion
- Code With Me Guest
- DataGrip
- DataSpell
- GoLand
- JetBrains Client
- MPS
- PhpStorm
- PyCharm (Professional, Community, Educational)
- Rider
- RubyMine
- RostRover
- WebStorm
- Writerside
Informationen zum Herunterladen findest du im JetBrains-IDEs-Tool-Finder.
-
Wenn du Mitglied einer Organisation oder eines Unternehmens mit einem Copilot Business- oder Copilot Enterprise-Plan bist, muss die Richtlinie „MCP servers in Copilot“ aktiviert sein, damit MCP mit Copilot verwendet werden kann.
Konfigurieren von MCP-Servern in JetBrains-IDEs
- Klicke in der unteren rechten Ecke auf .
- Wähle im Menü „Open Chat“ aus, stelle sicher, dass du dich im Agent-Modus befindest, und klicke dann unten im Chatfenster auf das Symbol „Tools“ (namens „Configure your MCP server“).
- Klicke auf Add MCP Tools.
- Definiere in der Datei
mcp.json
deine MCP-Server. JetBrains-IDEs unterstützen sowohl Remoteserver als auch lokale Server. Remoteserver werden zur einfacheren Einrichtung und Freigabe extern gehostet, während lokale Server auf deinem lokalen Computer ausgeführt werden und auf lokale Ressourcen zugreifen können.
Du kannst die folgenden Konfigurationen als Beispiele verwenden:
Beispiel für die Konfiguration eines Remoteservers mit einem persönlichen Zugriffstoken (PAT)
{ "servers": { "github": { "url": "https://api.githubcopilot.com/mcp/", "requestInit": { "headers": { "Authorization": "Bearer YOUR_PAT_HERE" } } } } }
{
"servers": {
"github": {
"url": "https://api.githubcopilot.com/mcp/",
"requestInit": {
"headers": {
"Authorization": "Bearer YOUR_PAT_HERE"
}
}
}
}
}
Beispiel für die Konfiguration eines lokalen Servers
{ "servers": { "memory": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-memory" ] } } }
{
"servers": {
"memory": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-memory"
]
}
}
}
Voraussetzungen
- Zugriff auf Copilot Weitere Informationen findest du unter Was ist GitHub Copilot?.
- GitHub Copilot-Erweiterung für Xcode Weitere Informationen findest du unter Installation der GitHub Copilot-Erweiterung in Ihrer Umgebung.
- Wenn du Mitglied einer Organisation oder eines Unternehmens mit einem Copilot Business- oder Copilot Enterprise-Plan bist, muss die Richtlinie „MCP servers in Copilot“ aktiviert sein, damit MCP mit Copilot verwendet werden kann.
Konfigurieren von MCP-Servern in Xcode
- Öffne GitHub Copilot für die Xcode-Erweiterung, und wechsle zu „Settings“.
- Alternativ kannst du in einem aktiven Xcode-Arbeitsbereich die Einstellungen finden, indem du in der Menüleiste auf Editor klickst, GitHub Copilot auswählst und dann auf Open GitHub Copilot for Xcode Settings klickst.
- Wähle die Registerkarte MCP aus, und klicke auf Edit Config.
- Definiere deine MCP-Server, indem du
mcp.json
bearbeitest. Xcode unterstützt sowohl Remoteserver als auch lokale Server. Remoteserver werden zur einfacheren Einrichtung und Freigabe extern gehostet, während lokale Server auf deinem lokalen Computer ausgeführt werden und auf lokale Ressourcen zugreifen können.
Du kannst die folgenden Konfigurationen als Beispiele verwenden:
Beispiel für die Konfiguration eines Remoteservers mit einem persönlichen Zugriffstoken (PAT)
{ "servers": { "github": { "url": "https://api.githubcopilot.com/mcp/", "requestInit": { "headers": { "Authorization": "Bearer YOUR_PAT_HERE" } } } } }
{
"servers": {
"github": {
"url": "https://api.githubcopilot.com/mcp/",
"requestInit": {
"headers": {
"Authorization": "Bearer YOUR_PAT_HERE"
}
}
}
}
}
Beispiel für die Konfiguration eines lokalen Servers
{ "servers": { "memory": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-memory" ] } } }
{
"servers": {
"memory": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-memory"
]
}
}
}
Voraussetzungen
- Zugriff auf Copilot Weitere Informationen findest du unter Was ist GitHub Copilot?.
- Kompatible Eclipse-Version: Um die GitHub Copilot-Erweiterung zu verwenden, musst du über Eclipse Version 2024-09 oder höher verfügen. Weitere Informationen findest du auf der Eclipse-Downloadseite.
- Wenn du Mitglied einer Organisation oder eines Unternehmens mit einem Copilot Business- oder Copilot Enterprise-Plan bist, muss die Richtlinie „MCP servers in Copilot“ aktiviert sein, damit MCP mit Copilot verwendet werden kann.
Konfigurieren von MCP-Servern in Eclipse
- Klicke auf der Statusleiste unten in Eclipse auf das Copilot-Symbol ().
- Wähle im Menü Open Chat aus, und klicke im Chatfenster auf das Symbol „Configure Tools...“.
- Alternativ kannst du Edit preferences auswählen, dann im linken Bereich GitHub Copilot erweitern und auf MCP klicken.
- Definiere unter „Server Configurations“ deine MCP-Server. Eclipse unterstützt sowohl Remoteserver als auch lokale Server. Remoteserver werden zur einfacheren Einrichtung und Freigabe extern gehostet, während lokale Server auf deinem lokalen Computer ausgeführt werden und auf lokale Ressourcen zugreifen können.
Du kannst die folgenden Konfigurationen als Beispiele verwenden:
Beispiel für die Konfiguration eines Remoteservers mit einem persönlichen Zugriffstoken (PAT)
{ "servers": { "github": { "url": "https://api.githubcopilot.com/mcp/", "requestInit": { "headers": { "Authorization": "Bearer YOUR_PAT_HERE" } } } } }
{
"servers": {
"github": {
"url": "https://api.githubcopilot.com/mcp/",
"requestInit": {
"headers": {
"Authorization": "Bearer YOUR_PAT_HERE"
}
}
}
}
}
Beispiel für die Konfiguration eines lokalen Servers
{ "servers": { "memory": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-memory" ] } } }
{
"servers": {
"memory": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-memory"
]
}
}
}
Erstellen eines neuen MCP-Servers
Du kannst einen neuen MCP-Server erstellen, der deine spezifischen Anforderungen erfüllt. Anschließend kannst du diesen mit Copilot Chat integrieren. Beispiel: Du kannst einen MCP-Server erstellen, der eine Verbindung mit einer Datenbank oder einem Webdienst herstellt, und diesen Server anschließend in Copilot Chat verwenden, um Aufgaben für diese Datenbank oder diesen Webdienst auszuführen.
Weitere Informationen zum Erstellen und Konfigurieren deiner eigenen MCP-Server findest du in der offiziellen MCP-Dokumentation.