Octopus Deploy Official MCP Server

Octopus Deploy Official MCP Server

Octopus macht es einfach, Software in Kubernetes, Multi-Cloud, On-Prem-Infrastruktur und überall sonst bereitzustellen. Automatisieren Sie die Freigabe, Bereitstellung und den Betrieb Ihrer Software- und KI-Workloads mit einem Tool, das CD in einer Größenordnung bewältigen kann, wie es kein anderes Tool vermag.

Model Context Protocol (MCP) ermöglicht es den KI-Assistenten, die Sie in Ihrer täglichen Arbeit verwenden, wie Claude Code oder ChatGPT, sich standardisiert mit den Systemen und Diensten zu verbinden, die Sie besitzen, sodass sie Informationen aus diesen Systemen und Diensten abrufen können, um Fragen zu beantworten und Aufgaben auszuführen.

Der Octopus MCP Server stattet Ihren KI-Assistenten mit leistungsstarken Werkzeugen aus, die es ihm ermöglichen, Ihre Octopus-Instanz zu inspizieren, abzufragen und Probleme darin zu diagnostizieren, und ihn so zu Ihrem ultimativen DevOps-Flügelmann zu machen. Eine Liste der unterstützten Anwendungsfälle und Beispiel-Prompts finden Sie in unserer Dokumentation.

Octopus Server-Kompatibilität

Die meisten vom MCP Server bereitgestellten Werkzeuge verwenden stabile APIs, die mindestens seit Version 2021.1 des Octopus Servers verfügbar sind. Neuere Werkzeuge geben die mindestens unterstützte Version in der Dokumentation an. Alternativ können Sie das Kommandozeilenargument --list-tools-by-version verwenden, um zu prüfen, wie bestimmte Werkzeuge mit Octopus-Versionen zusammenhängen.

🚀 Installation

Installation via Docker

Anmeldeinformationen müssen über Umgebungsvariablen bereitgestellt werden, um zu vermeiden, dass sie in der Host-Prozessliste (ps aux / /proc/<pid>/cmdline) offengelegt werden. Die Octopus-Server-URL kann weiterhin über das Flag --server-url angegeben werden.

docker run -i --rm -e OCTOPUS_API_KEY=your-key -e OCTOPUS_SERVER_URL=https://your-octopus.com octopusdeploy/mcp-server

Vollständige Beispielkonfiguration (für Claude Desktop, Claude Code und Cursor):

{
  "mcpServers": {
    "octopus-deploy": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "OCTOPUS_SERVER_URL",
        "-e",
        "OCTOPUS_API_KEY",
        "octopusdeploy/mcp-server"
      ],
      "env": {
        "OCTOPUS_SERVER_URL": "https://your-octopus.com",
        "OCTOPUS_API_KEY": "YOUR_API_KEY"
      }
    },
  }
}

Für Apple Mac-Benutzer müssen Sie möglicherweise die folgenden Argumente in der Konfiguration hinzufügen, um Docker zur Verwendung der Linux-Plattform zu zwingen:

"--platform",
"linux/amd64",

Wir planen, in Kürze einen nativen ARM-Build zu veröffentlichen, sodass diese Argumente nicht mehr erforderlich sein werden.

Installation via Node

Anforderungen

• Node.js >= v20.0.0
• Octopus Deploy-Instanz, auf die der MCP-Server über HTTPS zugreifen kann
• Octopus Deploy API-Schlüssel oder Zugriffstoken (siehe Authentifizierung unten)

Konfiguration

Vollständige Beispielkonfiguration (für Claude Desktop, Claude Code und Cursor):

Schreibwerkzeuge aktiviert (Standard):

{
  "mcpServers": {
    "octopusdeploy": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@octopusdeploy/mcp-server"],
      "env": {
        "OCTOPUS_SERVER_URL": "https://your-octopus.com",
        "OCTOPUS_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Nur-Lese-Modus (empfohlen für Produktion):

{
  "mcpServers": {
    "octopusdeploy": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@octopusdeploy/mcp-server", "--read-only"],
      "env": {
        "OCTOPUS_SERVER_URL": "https://your-octopus.com",
        "OCTOPUS_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Der Octopus MCP Server wird normalerweise in Ihrem KI-Client Ihrer Wahl konfiguriert.

Er ist als npm-Paket verpackt und wird über den Node-Befehl npx ausgeführt. Anmeldeinformationen (API-Schlüssel oder Zugriffstoken) müssen über Umgebungsvariablen bereitgestellt werden – sie werden nicht als Kommandozeilenargumente akzeptiert, um zu vermeiden, dass Geheimnisse in der Prozessliste offengelegt werden. Die Octopus-Server-URL kann entweder über die Umgebungsvariable OCTOPUS_SERVER_URL oder das Flag --server-url angegeben werden.

OCTOPUS_API_KEY=API-KEY \
OCTOPUS_SERVER_URL=https://your-octopus.com \
npx -y @octopusdeploy/mcp-server

Oder mit der Server-URL in der Kommandozeile:

OCTOPUS_API_KEY=API-KEY \
npx -y @octopusdeploy/mcp-server --server-url https://your-octopus.com

Authentifizierung

Der MCP-Server unterstützt zwei Authentifizierungsmethoden. Beide werden über Umgebungsvariablen bereitgestellt – Anmeldeinformationen werden nicht in der Kommandozeile akzeptiert, da Flags in der Host-Prozessliste für jeden lokalen Benutzer sichtbar sind.

API-Schlüssel (empfohlen für interaktive Nutzung)

API-Schlüssel sind die Standard-Authentifizierungsmethode für Octopus Deploy. Sie können einen in Ihrem Octopus Deploy-Benutzerprofil generieren.

OCTOPUS_API_KEY=API-XXXXXXXXXXXXXXXXXXXXXXXXXX \
OCTOPUS_SERVER_URL=https://your-octopus.com \
npx -y @octopusdeploy/mcp-server

Zugriffstoken / Bearer-Token (nur für automatisierte Szenarien)

Der Server unterstützt auch kurzlebige Zugriffstoken (Bearer-Token) als Alternative zu API-Schlüsseln. Diese Authentifizierungsmethode ist nur für automatisierte Szenarien vorgesehen, in denen ein externes System ein kurzlebiges Token an den MCP-Server ausstellt (z. B. CI/CD-Pipelines, automatisierte Orchestrierung oder Machine-to-Machine-Workflows). Verwenden Sie keine langlebigen Bearer-Token – verwenden Sie stattdessen API-Schlüssel für interaktive oder lang laufende Sitzungen.

OCTOPUS_ACCESS_TOKEN=your-short-lived-token \
OCTOPUS_SERVER_URL=https://your-octopus.com \
npx -y @octopusdeploy/mcp-server

Vollständige Beispielkonfiguration mit einem Zugriffstoken:

{
  "mcpServers": {
    "octopusdeploy": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@octopusdeploy/mcp-server"],
      "env": {
        "OCTOPUS_SERVER_URL": "https://your-octopus.com",
        "OCTOPUS_ACCESS_TOKEN": "YOUR_TOKEN"
      }
    }
  }
}

Wenn sowohl ein API-Schlüssel als auch ein Zugriffstoken bereitgestellt werden, hat das Zugriffstoken Vorrang. Die aktive Authentifizierungsmethode wird in der Protokolldatei aufgezeichnet (konfigurierbar mit --log-file), sodass Operatoren bestätigen können, welche Anmeldeinformation verwendet wird.

Konfigurationsoptionen

Der Octopus MCP Server unterstützt mehrere Kommandozeilenoptionen, um anzupassen, welche Werkzeuge verfügbar sind.

Wenn Sie nicht sicher sind, welche Werkzeuge Sie benötigen, empfehlen wir, den Server ohne zusätzliche Kommandozeilenoptionen auszuführen und die bereitgestellten Standardeinstellungen zu verwenden.

Werkzeugsätze

Verwenden Sie den Parameter --toolsets, um bestimmte Gruppen von Werkzeugen zu aktivieren:

# Enable all toolsets (default)
npx -y @octopusdeploy/mcp-server

# Enable only specific toolsets
npx -y @octopusdeploy/mcp-server --toolsets projects,deployments

# Enable all toolsets explicitly
npx -y @octopusdeploy/mcp-server --toolsets all

Verfügbare Werkzeugsätze:

• core - Grundlegende Operationen (immer aktiviert)
• projects - Projektoperationen
• deployments - Bereitstellungsoperationen
• releases - Release-Management
• runbooks - Runbook-Erkennung und -Ausführung
• tasks - Aufgabenoperationen
• tenants - Multi-Tenancy-Operationen
• kubernetes - Kubernetes-Operationen
• machines - Bereitstellungsziel-Operationen
• certificates - Zertifikatsoperationen
• accounts - Kontooperationen
• interruptions - Manuelle Eingriffs- und Genehmigungsoperationen
• featureToggles - Kunden-Feature-Toggles prüfen und anpassen
• context - Authentifizierter Benutzer- und Projektkontext (aktueller Benutzer, Git-Branches)

Nur-Lese-Modus

Der Server läuft standardmäßig mit aktivierten Schreibwerkzeugen. Übergeben Sie --read-only, um alle Schreibwerkzeuge zu deaktivieren und POST/PUT/PATCH/DELETE über die execute-Rückfallebene zu blockieren. Die meisten kuratierten Werkzeuge sind bereits schreibgeschützt; nur ein kleiner Satz führt Schreibvorgänge aus.

Schreibaktivierte Werkzeuge (immer schreibend):

• create_release - Neue Releases erstellen
• deploy_release - Releases in Umgebungen und für Tenants bereitstellen
• run_runbook - Ein Runbook für eine oder mehrere Umgebungen (und optionale Tenants) ausführen
• update_feature_toggle - Umgebungsbezogenen Status und Rollout-Prozentsätze eines vorhandenen Feature-Toggles anpassen

Bedingt schreibendes Werkzeug: execute ist eine strukturierte REST-Rückfallebene, deren Stufe (Lesen / Schreiben / Löschen) durch die an sie übergebene HTTP-Methode bestimmt wird. Siehe den Abschnitt API-Katalog & Rückfallebene für Details.

Schreibwerkzeuge werden durch eine MCP-Aufforderung zur Einwilligung gesteuert: Clients, die Einwilligung unterstützen, werden vor der Ausführung des Aufrufs um Bestätigung gebeten. Clients ohne Einwilligungsunterstützung müssen confirm: true in den Werkzeugargumenten übergeben – andernfalls bricht das Werkzeug mit einem Fehler ab. Setzen Sie OCTOPUS_SKIP_ELICITATION=true, um die Sperre vollständig zu umgehen (vorgesehen für unbeaufsichtigte Automatisierung).

Der Server verwendet eine dreistufige Klassifizierung Lesen/Schreiben/Löschen, die serverseitig basierend auf der HTTP-Methode erzwungen wird (der Agent kann dies nicht durch falsche Absichtsangaben umgehen):

• read — immer erlaubt. GET-Anfragen über execute, plus alle find_* / get_* / list_* Werkzeuge.
• write — POST/PUT/PATCH über execute und die oben genannten immer schreibenden Werkzeuge. Blockiert, wenn --read-only gesetzt ist.
• delete — DELETE über execute. Erfordert --allow-deletes und wird blockiert, wenn --read-only gesetzt ist. Eine kleine Menge katastrophaler Löschpfade (z. B. DELETE /api/spaces/{id}, DELETE /api/users/{id}) und API-Schlüssel-Endpunkte befinden sich auf einer harten sensiblen Sperrliste, die beide Flags ignoriert.

# Default - write tools enabled (POST/PUT/PATCH)
npx -y @octopusdeploy/mcp-server

# Additionally permit DELETE requests through the execute tool
npx -y @octopusdeploy/mcp-server --allow-deletes

# Read-only mode - write/delete tools disabled
npx -y @octopusdeploy/mcp-server --read-only

Sicherheitshinweis: Verwenden Sie einen API-Schlüssel mit angemessenen, minimalen Berechtigungen – Schreiboperationen können Releases erstellen und Bereitstellungen in Ihrer Octopus-Instanz auslösen. Für die Produktion sollten Sie --read-only übergeben, es sei denn, Sie haben einen spezifischen, kontrollierten Anwendungsfall für Schreibvorgänge. --allow-deletes ist standardmäßig deaktiviert; aktivieren Sie es nur, wenn der Agent DELETE-Anfragen über execute ausgeben muss. Wenn Sie --allow-deletes zusammen mit --read-only übergeben, gibt der Server eine Startwarnung auf stderr aus – DELETE-Anfragen bleiben durch die Nur-Lese-Sperre blockiert.

Vollständige Beispiele

Alle folgenden Beispiele gehen davon aus, dass OCTOPUS_API_KEY in der Umgebung gesetzt ist. Das Flag --server-url wird zur Verdeutlichung angezeigt, kann aber auch über OCTOPUS_SERVER_URL bereitgestellt werden.

# Development setup with only core and project tools
npx -y @octopusdeploy/mcp-server --toolsets core,projects --server-url https://your-octopus.com

# Production setup with all tools and read-only enforcement
npx -y @octopusdeploy/mcp-server --toolsets all --read-only --server-url https://your-octopus.com

# Default invocation - all tools and writes enabled
npx -y @octopusdeploy/mcp-server --server-url https://your-octopus.com

Andere Kommandozeilenargumente

• --read-only - Nur-Lese-Modus aktivieren: alle kuratierten Schreibwerkzeuge deaktivieren und POST/PUT/PATCH/DELETE über execute blockieren. Schreibvorgänge sind standardmäßig aktiviert; dieses Flag schaltet sie aus. Siehe Nur-Lese-Modus.
• --allow-deletes - DELETE-Anfragen über das Werkzeug execute zulassen. Ignoriert (mit einer Startwarnung), wenn --read-only gesetzt ist. Standard false.
• --log-level <level> - Minimales Protokollniveau (info, error)
• --log-file <path> - Protokolldateipfad oder -dateiname. Wenn nicht angegeben, werden Protokolle nur auf der Konsole ausgegeben
• -q, --quiet - Dateiprotokollierung deaktivieren, nur Fehler auf der Konsole protokollieren
• --list-tools-by-version - Alle registrierten Werkzeuge nach ihrer unterstützten Octopus Server-Version auflisten und beenden

🔨 Werkzeuge

URL-basierte Werkzeuge

Schnellstart: Fügen Sie Octopus-URLs direkt ein, um Probleme ohne manuelle ID-Extraktion zu untersuchen.

• get_deployment_from_url: Bereitstellungsdetails von der Bereitstellungs-URL abrufen (gibt taskId für die Nachverfolgung zurück)
• get_task_from_url: Aufgabendetails und Protokolle von der Aufgaben-URL abrufen

Workflow zur Bereitstellungsuntersuchung:

1. get_deployment_from_url with deployment URL
   → Returns deployment context + taskResourceUri + grepTaskLogHint

2a. Fetch the structured activity tree via resources/read (or read_resource)
    octopus://spaces/{spaceName}/tasks/{taskId}/details

2b. Or call grep_task_log with the taskId to search the raw log without
    fetching the full body:
       grep_task_log({ spaceName, taskId, pattern: "error|fail", caseInsensitive: true })

Aufgabenuntersuchung (direkte Aufgaben-URL):

get_task_from_url with task URL
→ Returns task details and logs immediately

Diese Werkzeuge eliminieren die manuelle ID-Extraktion durch:

• Automatisches Parsen von URLs
• Auflösen von Space-IDs zu Space-Namen
• Validieren von ID-Formaten
• Bereitstellen klarer Fehlermeldungen

Beispiel-URLs:

• Bereitstellung: https://your-octopus.com/app#/Spaces-1/projects/my-app/deployments/Deployments-123
• Aufgabe: https://your-octopus.com/app#/Spaces-1/tasks/ServerTasks-456

Siehe Arbeiten mit URLs für detaillierte Workflows, Beispiele und Best Practices.

Kernwerkzeuge

• list_spaces: Alle Spaces in der Octopus Deploy-Instanz auflisten
• list_environments: Alle Umgebungen in einem bestimmten Space auflisten

API-Katalog & Rückfallebene

Diese Werkzeuge und Ressourcen ermöglichen es dem Agenten, Octopus REST-Endpunkte zu erreichen, für die es kein dediziertes kuratiertes Werkzeug gibt, mit harter serverseitiger Trennung zwischen Lese-, Schreib- und Löschoperationen.

• grep_llms_txt: Durchsucht den Octopus-API-Katalog (octopus://api/llms.txt) mit grep-ähnlicher Semantik (mindestens unterstützte Octopus-Version: 2026.2.3916). Der Kataloginhalt ist umfangreich (typischerweise 300+ KB) – rufen Sie dieses Tool auf, anstatt den Ressourceninhalt direkt zu lesen. Die Parameter entsprechen GNU grep (pattern, caseInsensitive, invertMatch, fixedString, beforeContext, afterContext, maxCount). Nützlich zum Entdecken von Endpunkten (POST /releases), zum Auflisten von Lösch-Endpunkten (DELETE ) oder zum Finden des Body-Typs für eine Schreiboperation (Body: Create.*Command).
• execute: Strukturierte REST-Absicherung. Erreicht jeden Octopus-REST-Endpunkt unter /api. Die HTTP-Methode ist der maßgebliche Lese-/Schreib-/Lösch-Klassifikator – niemals ein isWrite-Flag, das das LLM setzen kann. Die Methodensteuerung ist serverseitig fest codiert:
  • GET ist immer erlaubt (vorbehaltlich der Pfadformprüfung + sensibler Sperrliste).
  • POST/PUT/PATCH werden blockiert, wenn --read-only gesetzt ist; andernfalls erfordern sie eine Benutzerbestätigung durch Abfrage.
  • DELETE erfordert --allow-deletes (und wird blockiert, wenn --read-only gesetzt ist) plus eine stärkere „IRREVERSIBLE“-Abfragemeldung.
  • Die sensible Sperrliste (API-Key-Endpunkte, DELETE /api/spaces/{id}, DELETE /api/users/{id}) wird selbst bei aktivierten Flags durchgesetzt.
  • Der Pfad muss /api sein oder mit /api/ beginnen – absolute URLs, SDK-relative ~/api/...-Pfade und hostrelative Pfade außerhalb von /api (z. B. /octopus/portal/...) werden von vornherein abgelehnt, sodass execute auf die Octopus-REST-API-Oberfläche beschränkt bleibt.
  • Die pfadbezogene Werkzeugsatz-Zulassungsliste gilt nur, wenn --toolsets eingeschränkt wurde. Wenn alle Werkzeugsätze aktiviert sind (Standard oder explizit --toolsets all), wird die Zulassungsliste umgangen und jeder Pfad unter /api ist vorbehaltlich der obigen Beschränkungen erreichbar. Wenn --toolsets eingeschränkt ist, wird die Zulassungsliste zur Notbremse: Pfade werden nur aufgelöst, wenn ihr besitzender Werkzeugsatz aktiviert ist. Das Deaktivieren eines Werkzeugsatzes (z. B. certificates) macht seine Pfade über execute selbst bei GET unerreichbar.

Katalogdaten werden auch als MCP-Ressourcen bereitgestellt:

• octopus://api/llms.txt – Markdown-Katalog aller Octopus-REST-Endpunkte (HTTP-Methode, Pfad, Abfrageparameter, Anforderungs-/Antworttypen). Erfordert Octopus Server 2026.2.3916 oder höher. 5-Minuten-In-Memory-Cache, basierend auf der konfigurierten Server-URL. Bevorzugen Sie grep_llms_txt gegenüber dem direkten Lesen des Inhalts.
• octopus://api/capabilities – JSON, das die laufende Sitzung beschreibt: Serverversion, aktivierte Werkzeugsätze, verfügbare Werkzeuge (mit ihren minimumOctopusVersion) und ob --read-only / --allow-deletes aktiviert ist. Nützlich für den Agenten, um zu erkennen, was in dieser Sitzung erreichbar ist.

Projekte

• list_projects: Alle Projekte in einem bestimmten Bereich auflisten

Bereitstellungen

• deploy_release: Ein Release in Umgebungen bereitstellen (unterstützt sowohl mandantenfähige als auch nicht mandantenfähige Bereitstellungen)
• list_deployments: Bereitstellungen in einem Bereich mit optionaler Filterung auflisten

Releases

• create_release: Ein neues Release für ein Projekt erstellen
• find_releases: Releases in einem Bereich finden (kann ein bestimmtes Release anhand der ID abrufen oder Releases nach Projekt auflisten/filtern)

Release-Details sind auch als MCP-Ressource unter octopus://spaces/{spaceName}/releases/{releaseId} verfügbar – abrufbar über resources/read (oder das read_resource-Absicherungswerkzeug), um den vollständigen Release-Inhalt einschließlich Versionshinweisen und ausgewählten Paketen zu erhalten.

Runbooks

• find_runbooks: Runbooks in einem Projekt finden (kann ein bestimmtes Runbook anhand der ID abrufen oder Runbooks nach Teilnamen auflisten/filtern). Jede Zusammenfassung enthält die veröffentlichte Snapshot-ID, den Mandantenfähigkeitsmodus und den Umfangsbereich, sodass Aufrufer gültige Ziele vor der Ausführung auswählen können.
• run_runbook: Ein Runbook für eine oder mehrere Umgebungen ausführen. Unterstützt mandantenfähige Ausführungen (nach Mandantenname oder Mandanten-Tag), abgefragte Variablen, den Modus für geführte Fehler, geplante Ausführungsfenster und den Ein-/Ausschluss von Schritten oder Maschinen. Verwendet standardmäßig den veröffentlichten Snapshot des Runbooks, wenn runbookSnapshotId weggelassen wird.

Der vollständige Runbook-Inhalt (einschließlich Laufzeitrichtlinienfelder) ist als MCP-Ressource unter octopus://spaces/{spaceName}/runbooks/{runbookId} verfügbar.

Aufgaben

Aufgabendaten werden hauptsächlich als MCP-Ressourcen bereitgestellt. Verwenden Sie resources/read (oder das read_resource-Absicherungswerkzeug) mit einer der folgenden Optionen:

• octopus://spaces/{spaceName}/tasks/{taskId} – schlanke Metadaten (Status, Zeitplanung, Abschlussflags)
• octopus://spaces/{spaceName}/tasks/{taskId}/details – vollständige ServerTaskDetails (Fortschritt, Aktivitätsprotokollbaum usw.)

Verwenden Sie für die Protokollsuche das Werkzeug grep_task_log anstelle einer /log-Ressource:

• grep_task_log: Durchsucht das Aktivitätsprotokoll einer Aufgabe, ohne den gesamten Inhalt abzurufen. Die Parameter entsprechen GNU grep (pattern, caseInsensitive, invertMatch, fixedString, beforeContext, afterContext, maxCount). Gibt übereinstimmende Zeilen mit 1-indizierten lineNumber, optionalen Vorher-/Nachher-Kontext-Arrays und einer totalMatches-Anzahl über das gesamte Protokoll zurück.

Es gibt bewusst keine /log-Ressource: Aktivitätsprotokolle können mehrere Megabyte groß sein, und eine adressierbare Ressource würde Aufrufer dazu verleiten, den gesamten Inhalt abzurufen, wenn grep fast immer das richtige Grundelement ist.

Mandanten

• find_tenants: Mandanten in einem Bereich finden (kann einen bestimmten Mandanten anhand der ID abrufen oder Mandanten mit Filtern auflisten/durchsuchen)
• get_tenant_variables: Mandantenvariablen nach Typ abrufen (alle, gemeinsam oder Projekt)
• get_missing_tenant_variables: Mandantenvariablen abrufen, denen Werte fehlen

Kubernetes

• get_kubernetes_live_status: Live-Status von Kubernetes-Ressourcen für ein Projekt und eine Umgebung abrufen (mindestens unterstützte Version: 2025.3)

Maschinen (Bereitstellungsziele)

• find_deployment_targets: Bereitstellungsziele in einem Bereich finden (kann ein bestimmtes Ziel anhand der ID abrufen oder Ziele mit Filtern auflisten/durchsuchen)

Zertifikate

• find_certificates: Zertifikate in einem Bereich finden (kann ein bestimmtes Zertifikat anhand der ID abrufen oder Zertifikate mit Filtern auflisten/durchsuchen)

Konten

• find_accounts: Konten in einem Bereich finden (kann ein bestimmtes Konto anhand der ID abrufen oder Konten mit Filtern auflisten/durchsuchen)

Unterbrechungen

• find_interruptions: Ausstehende oder historische Unterbrechungen (manuelle Eingriffe, Genehmigungen, Eingabeaufforderungen für geführte Fehler) in einem Bereich finden, optional gefiltert nach Aufgabe, Projekt, Umgebung, betreffendem Dokument, Verantwortlichkeit oder ausstehendem Status. Gibt schlanke Zusammenfassungen zurück; dereferenzieren Sie die octopus://spaces/{spaceName}/interruptions/{interruptionId}-Ressource für die vollständige Formulardefinition (Steuerelementtypen, Markdown-Anweisungen, Schaltflächenoptionen, übermittelte Form.Values).

Feature-Toggles

• find_feature_toggles: Kunden-Feature-Toggles in einem Projekt auflisten. Jede Zusammenfassung enthält den Status pro Umgebung (isEnabled, rolloutPercentage, clientRolloutPercentage) plus eine resourceUri, sodass die Frage „Wo ist X aktiviert?“ aus der Listenantwort beantwortet werden kann.
• update_feature_toggle: Einen vorhandenen Toggle anpassen. Eingeschränkte Oberfläche – eine Umgebung ein-/ausschalten, Rollout-Prozentsätze ändern oder die Beschreibung/den Standardzustand auf Toggle-Ebene aktualisieren. Ruft intern den aktuellen Toggle ab, wendet Ihre Patches im Speicher an und sendet den zusammengeführten Inhalt per PUT, sodass nicht erwähnte Umgebungen und nicht erwähnte Felder erhalten bleiben. Patches, die auf eine Umgebung verweisen, die noch nicht im Toggle konfiguriert ist, werden abgelehnt.

Der vollständige Toggle-Inhalt (Beschreibung, Mandanten, Segmente, Mindestversionen) ist als MCP-Ressource unter octopus://spaces/{spaceName}/projects/{projectId}/featuretoggles/{slug} verfügbar. Rollout-Gruppeninhalte sind unter octopus://spaces/{spaceName}/projects/{projectId}/rolloutgroups/{rolloutGroupId} zur schreibgeschützten Überprüfung adressierbar.

Außerhalb des Umfangs (verwenden Sie die Octopus-Benutzeroberfläche): Erstellen neuer Feature-Toggles, Löschen von Toggles, Umbenennen oder Neumarkieren, Anhängen/Entfernen von Rollout-Gruppen, Mandantenzuordnung, Segmente, Mindestversionsfilter und Verwaltung von Rollout-Gruppen-/SDK-Client-Identifikatoren.

Zusätzliche Werkzeuge

• get_deployment_process: Bereitstellungsprozess anhand der ID für Projekte oder Releases abrufen
• get_variables: Alle Projektvariablen und Bibliotheksvariablensatz-Variablen für ein Projekt abrufen (unterstützt Config-as-Code-Projekte über gitRef)
• get_branches: Git-Branches für ein versionskontrolliertes Projekt abrufen (mindestens unterstützte Version: 2021.2)
• get_current_user: Informationen über den aktuell authentifizierten Benutzer abrufen

🔒 Sicherheitsüberlegungen

Der Octopus MCP Server umfasst sowohl Lese- als auch Schreiboperationen. Wichtige Sicherheitsüberlegungen:

Leseoperationen

• Können vollständige Bereitstellungsprotokolle lesen, die Produktionsgeheimnisse enthalten könnten, wenn diese nicht als Geheimnisse gekennzeichnet wurden
• Zugriff auf sensible Konfigurationsdaten und Variablen
• Seien Sie vorsichtig, wenn Sie eine Verbindung zu Werkzeugen und Modellen herstellen, denen Sie nicht vollständig vertrauen

Schreiboperationen

Standardmäßig sind die folgenden Schreiboperationen verfügbar:

• Erstellen von Releases: Kann neue Releases für Projekte erstellen
• Bereitstellen von Releases: Kann Bereitstellungen in Umgebungen (einschließlich Produktion) auslösen
• Ausführen von Runbooks: Kann Runbooks für Umgebungen und Mandanten ausführen
• Aktualisieren von Feature-Toggles: Kann den Status pro Umgebung umschalten und Rollout-Prozentsätze bei vorhandenen Toggles ändern
• Beliebiges POST/PUT/PATCH über die execute-Absicherung: Beschränkt auf Pfade unter /api, mit einer stets aktiven sensiblen Sperrliste. Die pfadbezogene Werkzeugsatz-Zulassungsliste gilt nur, wenn --toolsets eingeschränkt wurde; wenn alle Werkzeugsätze aktiviert sind (Standard), sind die einzigen Pfadbeschränkungen die /api-Grenze und die sensible Sperrliste.

Übergeben Sie --read-only, um alle oben genannten Punkte zu deaktivieren. DELETE-Anfragen über execute erfordern ein zusätzliches --allow-deletes-Flag – eine bewusste Zustimmung für irreversible Operationen – und bleiben blockiert, wenn --read-only gesetzt ist.

Kritische Sicherheitsmaßnahmen:

1. Geringste Rechte: Verwenden Sie API-Schlüssel mit den minimal erforderlichen Berechtigungen für Ihren Anwendungsfall
2. Nur-Lese-Modus aktivieren: Schreibvorgänge sind standardmäßig aktiviert. Übergeben Sie für die Produktion --read-only, es sei denn, Sie haben einen spezifischen, kontrollierten Anwendungsfall für Schreiboperationen. DELETE erfordert immer die zusätzliche --allow-deletes-Zustimmung.
3. Methodensteuerung ist serverseitig und fest codiert: Die an execute übergebene HTTP-Methode ist der maßgebliche Klassifikator. Der Agent kann die Steuerung nicht umgehen, indem er falsch darstellt, was der Aufruf tut – POST-/PUT-/PATCH-/DELETE-Anfragen erhalten eine stufenspezifische Steuerung, unabhängig vom Text im Anforderungstext.
4. Werkzeugsatzfilterung dient gleichzeitig als Notbremse: Das Einschränken von --toolsets entfernt sowohl die kuratierten Werkzeuge der deaktivierten Werkzeugsätze als auch deren Pfade aus der execute-Zulassungsliste. (Die Zulassungsliste wird nur konsultiert, wenn Werkzeugsätze eingeschränkt sind; wenn alle Werkzeugsätze aktiviert sind, wird execute durch die /api-Formprüfung und die sensible Sperrliste begrenzt.)
5. Risiko durch Prompt-Injection: Die Ausführung von Agenten in vollautomatisierter Weise könnte Sie anfällig für Prompt-Injection-Angriffe machen

Empfehlung: Übergeben Sie für Produktionsumgebungen --read-only, es sei denn, Sie haben einen spezifischen, kontrollierten Anwendungsfall für Schreiboperationen. Lassen Sie --allow-deletes deaktiviert, es sei denn, Sie benötigen ausdrücklich DELETE-Semantik über execute.

⚠️ Einschränkungen

Datenanalyse

Die Natur aktueller KI-Chat-Tools und des MCP-Protokolls selbst macht es unpraktisch, große Datenmengen zu analysieren. Die meisten MCP-Clients unterstützen derzeit keine Verkettung von Werkzeugaufrufen (Verwendung der Ausgabe eines Werkzeugs als Eingabe für das nächste) und fallen stattdessen auf das Token-für-Token-Kopieren der Ergebnisse zurück, was häufig zu Halluzinationen führt. Wenn Sie historische Daten Ihrer Octopus-Instanz zu Analysezwecken verarbeiten möchten, empfehlen wir, die API direkt zu verwenden oder einen eigenen MCP-Client zu schreiben, der in der Lage ist, die Ergebnisse der Werkzeugaufrufe programmgesteuert zu verarbeiten.

Leistung

Der MCP-Server ist technisch gesehen nur eine dünne Schicht über der bestehenden Octopus-Server-API. Daher ist er in der Lage, große Datenmengen abzurufen (z. B. das Anfordern von Tausenden von Bereitstellungen). Solche Abfragen können erhebliche Auswirkungen auf die Leistung Ihrer Instanz haben. Weisen Sie Ihre Modelle an, nur die minimal erforderliche Datenmenge abzurufen (die meisten Modelle sind von Haus aus sehr gut darin).

🤝 Beiträge

Beiträge sind willkommen! :heart: Bitte lesen Sie unseren Leitfaden für Beiträge, um zu erfahren, wie Sie sich an diesem Projekt beteiligen können.

Wir sind gespannt, wie Sie den Octopus MCP Server einsetzen möchten und welche Funktionen Sie sich für zukünftige Versionen wünschen.

Bitte nutzen Sie Issues, um Feedback zu geben oder Funktionen anzufragen.

Wenn Sie aktueller Octopus-Kunde sind, melden Sie bitte alle Probleme, die Sie bei der Nutzung unseres MCP-Servers feststellen, an unser Support-Team. So stellen Sie sicher, dass Sie innerhalb unserer üblichen Support-Garantien zeitnah eine Antwort erhalten.

🙋 FAQ

Planen Sie die Veröffentlichung eines Remote-MCP-Servers?

Wir arbeiten daran, einen MCP-Server direkt in den Octopus Server zu integrieren. Dies wird uns die Tür öffnen, um komplexere MCP-Tools zu entwickeln, sowie:

• Octopus-Administratoren eine granularere Kontrolle über MCP-Clients zu geben
• OAuth nativ für die Client-Authentifizierung zu unterstützen
• Sicherheitsscan-Tools in die MCP-Ausgabe zu integrieren

Falls dies für Sie von Interesse ist, registrieren Sie bitte Ihr Interesse auf unserem Roadmap-Eintrag.

Lizenz

Dieses Projekt ist unter den Bedingungen der Mozilla Public License 2.0 Open-Source-Lizenz lizenziert.