# Plug-Ins für GitHub Copilot

Plug-Ins verpacken verwandte Anpassungen, damit Sie sie auf unterstützten Copilot Oberflächen zusammen installieren können.

Plug-Ins packen verwandte Anpassungen, damit Sie sie zusammen installieren und verwalten können, anstatt jede einzeln einzurichten. Beispielsweise könnte ein Test-Plug-In eine Fähigkeit zum Ausführen von Tests, einen Agent für die Codeüberprüfung und einen MCP-Server für einen Testberichtsdienst kombinieren.

## Wo Sie Plug-Ins verwenden können

Plug-Ins sind auf diesen Copilot Plattformen verfügbar:

* Visual Studio Code. Durchsuchen und installieren Sie Plug-ins über **Customize** im seitlichen Chatbereich oder im Agents-Fenster. Details zum VS Code-Plug-In-Format finden Sie in der [Erstellungsreferenz für Agent-Plug-Ins](https://code.visualstudio.com/docs/agents/reference/agent-plugin-reference).
* GitHub Copilot CLI. Durchsuchen und installieren Sie Plug-Ins über einen registrierten Marketplace.
* Die GitHub Copilot app. Plugins über **Customize** durchsuchen und installieren.
* Copilot in the cloud. Konfigurieren Sie Plug-Ins über Repositoryeinstellungen.

Ein Plug-In kann Komponenten enthalten, die nur auf einer bestimmten Oberfläche funktionieren. Überprüfen Sie, ob das Plug-In das verwendete Material unterstützt. Die in dieser Kategorie beschriebene LSP-Serverkonfiguration ist beispielsweise für Copilot CLI. Weitere Informationen findest du unter [Plugin- und Marketplace-Referenz](/de/copilot/reference/plugin-and-marketplace-reference).

## Welche Plug-Ins sind enthalten?

Ein Plug-In kann einige oder alle diese Komponenten verpacken. Verfügbare Komponenten und deren Speicherorte hängen vom Plug-In-Format und der Oberfläche ab:

* **Benutzerdefinierte Agenten** – Spezialisierte KI-Assistenten (`*.agent.md` Dateien in `agents/`)
* **Skills** – Aufgabenspezifische Anweisungen, Skripts und Ressourcen (Skill-Unterverzeichnisse in `skills/`, die eine `SKILL.md`-Datei enthalten)
* **Hooks** – Ereignishandler, die auf Agentaktionen reagieren (eine `hooks.json` Datei im Plug-In-Stamm oder in `hooks/`)
* **Erweiterungen** – surface-spezifischer Code, der Funktionen wie Tools und Schrägstrichbefehle hinzufügt
* **MCP-Serverkonfigurationen** – Model Context Protocol-Integrationen (root `mcp.json` in Agent Plugins 1.0)
* **LSP-Serverkonfigurationen** – Language-Server-Protocol-Integrationen in unterstützten Bereichen

## Plugin-Formate

Agent Plugins ist ein Format für die Freigabe von Plug-In-Manifesten, Fähigkeiten und MCP-Serverkonfigurationen auf kompatiblen Oberflächen. Agent Plugins 1.0-Plugins deklarieren das kanonische Schema in `plugin.json`; seine Schema- und Komponentenspeicherorte werden nicht von allen Oberflächen in gleicher Weise unterstützt.
Copilot CLI unterstützt auch ein älteres Copilot Plug-In-Format. In der CLI verwendet ein Manifest ohne das Agent Plugins schema dieses Legacy-Format.

Wählen Sie Agent-Plug-Ins aus, wenn Sie Fähigkeiten und MCP-Server auf kompatiblen Oberflächen teilen möchten. Verwenden Sie das ältere CLI-Format, wenn Sie konfigurierbare Komponentenpfade benötigen oder ein vorhandenes Copilot-spezifisches Plug-In warten.

Verwenden Sie für ein neues Plug-In Agent Plugins 1.0, es sei denn, Sie benötigen konfigurierbare Komponentenpfade. Verwenden Sie das Legacyformat in erster Linie für vorhandene Legacy-Plug-Ins.

## Wie Plugins strukturiert sind

Ein Plug-In ist ein Verzeichnis mit einer bestimmten Struktur und einer `plugin.json` Manifestdatei. Agent Plugins 1.0 erfordert das Manifest im Plug-In-Stamm. Legacy-Plug-Ins unterstützen zusätzliche Manifestspeicherorte. Das Manifest gibt dem Plug-In einen Namen und Metadaten. Je nach Format kann es auch auf Komponenten verweisen. Neben dem Manifest kann das Verzeichnis Agents, Fähigkeiten, Hooks, MCP-Serverkonfigurationen und LSP-Serverkonfigurationen enthalten.

### Agent Plugins 1.0-Struktur

Agent Plugins 1.0 speichert Fähigkeiten und MCP-Server an Standardstandorten, damit kompatible Clients sie entdecken können. Andere Komponenten, einschließlich Agents, Hooks, Befehle und LSP-Server, sind clientspezifisch.
Copilot liest diese Komponenten aus dem `com.github.copilot` Verzeichnis. Andere Clients ignorieren dieses Verzeichnis, sodass dasselbe Plug-In gemeinsame Fähigkeiten und MCP-Server mit Copilot-spezifischen Komponenten kombinieren kann.

Ein Agent Plugins 1.0-Verzeichnis kann wie folgt aussehen:

```text
my-plugin/
├── plugin.json               # Required manifest
├── skills/                   # Skills (optional)
│   └── deploy/
│       └── SKILL.md
├── mcp.json                  # MCP server config (optional)
└── com.github.copilot/       # Copilot components (optional)
    ├── agents/
    │   └── helper.agent.md
    ├── commands/
    ├── rules/
    ├── hooks/
    │   └── hooks.json
    └── lsp.json
```

Das Manifest muss die Agent Plugins 1.0 `$schema`enthalten. Informationen zu unterstützten Manifestfeldern der obersten Ebene, Namensanforderungen und Komponentenstandorten finden Sie unter [Manifestfelder in Agent Plugins 1.0](/de/copilot/reference/copilot-cli-reference/cli-plugin-reference#agent-plugins-10-manifest-fields).

### Legacy-Plug-In-Struktur

Ein Legacy-Plug-In-Verzeichnis Copilot kann wie folgt aussehen:

```text
my-plugin/
├── plugin.json           # Required manifest
├── agents/               # Custom agents (optional)
│   └── helper.agent.md
├── skills/               # Skills (optional)
│   └── deploy/
│       └── SKILL.md
├── hooks.json            # Hook configuration (optional)
├── .mcp.json             # MCP server config (optional)
└── lsp.json              # LSP server config (optional)
```

Den vollständigen Satz von Feldern, die Sie im Manifest einfügen können, finden Sie unter [GitHub Copilot CLI-Plug-In-Referenz](/de/copilot/reference/copilot-cli-reference/cli-plugin-reference). Eine schrittweise Anleitung zum Erstellen eines Plug-Ins finden Sie unter [Erstellen eines Plug-Ins für GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/customize-copilot/plugins-creating).

## Warum Plug-Ins verwenden?

Plugins bieten die folgenden Vorteile:

* Wiederverwendbarkeit über Projekte hinweg
* Gemeinsame Copilot Konfiguration über Repositorys hinweg
* Teilen Sie Domänenkompetenz (z. B. durch die Bereitstellung der Fähigkeiten eines Rails-Experten oder eines Kubernetes-Experten)
* Kapseln komplexer MCP-Serverkonfigurationen

## Woher Plug-ins kommen

Der integrierte Marktplatz in Visual Studio Code, Copilot CLI und dem GitHub Copilot app ist [awesome-copilot](https://github.com/github/awesome-copilot?utm_source=customization-plugin-doc-awesome\&utm_medium=docs\&utm_campaign=universe-2026). Andere Marketplaces müssen hinzugefügt werden, bevor ihre Plug-Ins verfügbar sind.

Durch das Hinzufügen eines Marketplace werden die Plug-Ins zum Durchsuchen verfügbar. Es installiert oder aktiviert sie nicht. Der Bezeichner eines Plug-Ins kombiniert den Plugin-Namen mit dem Marketplace-Namen in der Form `PLUGIN-NAME@MARKETPLACE-NAME`. Der Marketplace-Name stammt aus dem `name` Feld in der `marketplace.json` Datei, nicht aus dem Repositorynamen.

## Was entscheidet, ob ein Plugin aktiviert ist

Plug-Ins können verfügbar, installiert oder aktiviert werden. Durch das Hinzufügen eines Marketplace werden die Plug-Ins zum Durchsuchen verfügbar. Durch die Installation eines Plug-Ins wird es zu einer Oberfläche hinzugefügt, und durch die Aktivierung werden seine Komponenten in Sitzungen auf dieser Oberfläche verfügbar gemacht. Die gemeinsame Konfiguration kann einen Standard festlegen oder erzwingen, ob ein Plug-In aktiviert ist:

| Konfigurationsquelle                         | Effect                                                                                                                         | Kann ein Mitglied das Plug-In deaktivieren?                    |
| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------- |
| Unternehmensverwaltete Einstellungen         | Plug-In vorschreiben oder blockieren über unterstützte Oberflächen hinweg.                                                     | No. Verwaltete Richtlinie gewinnt immer.                       |
| Vom Enterprise-Team verwaltete Einstellungen | Fügen Sie erforderliche Plug-Ins über `enabledPlugins` in Enterprise-Teamdateien hinzu, die auf der Enterprise-Basis aufbauen. | No. Diese Einträge sind Einträge einer verwalteten Richtlinie. |
| Standardeinstellungen für Repositorys        | Aktivieren Sie ein Plug-in für alle, die in einem Repository arbeiten.                                                         | Ja, wo die Oberfläche eine lokale Überschreibung unterstützt.  |

Standardwerte des Repositorys machen kein Plug-in obligatorisch. Sie können kein Plug-In aktivieren, das durch verwaltete Richtlinien blockiert wird, oder einen Marketplace verwenden, der durch Richtlinien nicht zulässig ist. Verwaltete Einstellungen können ein optionales Plug-In nicht standardmäßig aktivieren. Sie erfordern oder blockieren nur Plug-ins.

Dateien des Enterprise-Teams fügen der Enterprise-Basislinie verwaltete `enabledPlugins` Einträge hinzu. Mitglieder können die erforderlichen Plug-Ins nicht deaktivieren. Siehe [Überschreiben von unternehmensverwalteten Einstellungen für Unternehmensteams](/de/copilot/how-tos/administer-copilot/manage-for-enterprise/use-managed-settings/override-settings-for-teams).

Die Standardwerte des Repositorys werden verwendet `.github/copilot/settings.json`. Informationen zu konfigurations- und oberflächenspezifischen lokalen Überschreibungen finden Sie unter [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#repository-settings-githubcopilotsettingsjson).

Unternehmensadministratoren können zusätzliche Marketplaces und Plug-Ins angeben, die erforderlich oder blockiert sind. Siehe [Verwalten von Plug-In-Marketplaces und Plug-Ins mit unternehmensverwalteten Einstellungen](/de/copilot/how-tos/administer-copilot/manage-for-enterprise/use-managed-settings/manage-plugin-marketplaces-and-plugins).

## Funktionsweise von Plug-In-Marketplaces

Ein Plug-In-Marketplace ist eine Registrierung von Plug-Ins, von denen Sie durchsuchen und installieren können. Ein Marketplace kann in einem Repository auf GitHub.comeinem anderen Git-Host oder einem lokalen Verzeichnis gehostet werden. Da Plugins auf einem Marketplace versioniert sind, erleichtern Marketplaces das Auffinden, Installieren und Aktualisieren von Plug-Ins.

Ein Marketplace wird durch eine `marketplace.json` Datei definiert, die Metadaten zum Marketplace bereitstellt und seine Plug-Ins auflistet.

Eine plattformspezifische Anleitung zur Verwendung von Plug-ins oder zum Veröffentlichen eines Marketplace in einem GitHub-Repository finden Sie unter [Weitere Informationen](#further-reading).

## Plug-Ins im Vergleich zur manuellen Konfiguration

Alle Funktionen, die Sie mit einem Plugin hinzufügen können, können Sie auch manuell hinzufügen, indem Sie beispielsweise benutzerdefinierte Agentprofile oder MCP-Server konfigurieren. Plug-Ins bieten jedoch mehrere Vorteile gegenüber der manuellen Konfiguration:

| Feature            | Manuelle Konfiguration in einem Repository | Plug-In                                           |
| ------------------ | ------------------------------------------ | ------------------------------------------------- |
| Umfang             | Einzelnes Repository                       | Jedes Projekt                                     |
| Teilen             | Manuelles Kopieren/Einfügen                | Installationsbefehl oder `enabledPlugins`-Eintrag |
| Versionsverwaltung | Git-Verlaufsprotokoll                      | Marketplace-Versionen                             |
| Discovery          | Durchsuchen von Repositorys                | Marktplatz durchsuchen                            |

## Weiterführende Lektüre

* [Verwenden von Plug-Ins in Visual Studio Code](/de/copilot/how-tos/copilot-in-your-ide/customize-copilot/extend-copilot-with-tools-and-context/using-plugins)
* [Suchen und Installieren von Plug-Ins für GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/customize-copilot/plugins-finding-installing)
* [Anpassen der GitHub-App Copilot](/de/copilot/how-tos/github-copilot-app/customize-github-copilot-app#adding-plugins)
* [Konfigurieren von Einstellungen für GitHub Copilot in der Cloud](/de/copilot/how-tos/use-copilot-agents/cloud-agent/configuring-agent-settings#configuring-plugins-for-github-copilot-cloud-agent)
* [Einen Plug-in-Marktplatz auf GitHub erstellen und teilen](/de/copilot/how-tos/copilot-on-github/customize-copilot/create-and-share-plugin-marketplaces)