Octopus Deploy Official MCP Server

oficial

O servidor MCP Octopus fornece ao seu assistente de IA ferramentas poderosas que permitem inspecionar, consultar e diagnosticar problemas dentro da sua instância Octopus, transformando-o no seu melhor parceiro de DevOps.

GitHub
98

Documentação

Octopus Deploy Logo

Servidor MCP Oficial do Octopus Deploy

O Octopus facilita a entrega de software para Kubernetes, multi-cloud, infraestrutura local e qualquer outro lugar. Automatize a liberação, implantação e operação de suas cargas de trabalho de software e IA com uma ferramenta que lida com CD em escala de uma forma que nenhuma outra ferramenta consegue.

O Model Context Protocol (MCP) permite que os assistentes de IA que você usa no seu dia a dia, como Claude Code ou ChatGPT, se conectem aos sistemas e serviços que você possui de forma padronizada, permitindo que eles extraiam informações desses sistemas e serviços para responder perguntas e realizar tarefas.

O Servidor MCP do Octopus fornece ao seu assistente de IA ferramentas poderosas que permitem inspecionar, consultar e diagnosticar problemas dentro da sua instância do Octopus, transformando-o no seu melhor companheiro de DevOps. Para obter uma lista de casos de uso suportados e exemplos de prompts, consulte nossa documentação.

Compatibilidade com o Servidor Octopus

A maioria das ferramentas expostas pelo Servidor MCP usa APIs estáveis que estão disponíveis pelo menos desde a versão 2021.1 do Servidor Octopus. As ferramentas mais recentes especificarão a versão mínima suportada na documentação. Como alternativa, você pode usar o argumento de linha de comando --list-tools-by-version para verificar como ferramentas específicas se relacionam com as versões do Octopus.

🚀 Instalação

Instalar via Docker

As credenciais devem ser fornecidas por meio de variáveis de ambiente para evitar expô-las na lista de processos do host (ps aux / /proc/<pid>/cmdline). A URL do servidor Octopus ainda pode ser fornecida por meio da flag --server-url.

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

Exemplo completo de configuração (para Claude Desktop, Claude Code e 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"
      }
    },
  }
}

Para usuários de Apple Mac, pode ser necessário adicionar os seguintes argumentos na configuração para forçar o Docker a usar a plataforma Linux:

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

Estamos planejando lançar uma versão nativa para ARM em breve, para que esses argumentos não sejam mais necessários.

Instalar via Node

Requisitos

  • Node.js >= v20.0.0
  • Instância do Octopus Deploy que possa ser acessada pelo servidor MCP via HTTPS
  • Chave de API ou Token de Acesso do Octopus Deploy (consulte Autenticação abaixo)

Configuração

Exemplo completo de configuração (para Claude Desktop, Claude Code e Cursor):

Ferramentas de gravação habilitadas (padrão):

{
  "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"
      }
    }
  }
}

Modo somente leitura (recomendado para produção):

{
  "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"
      }
    }
  }
}

O Servidor MCP do Octopus é normalmente configurado dentro do seu Cliente de IA de preferência.

Ele é empacotado como um pacote npm e executado por meio do comando npx do Node. As credenciais (chave de API ou token de acesso) devem ser fornecidas por meio de variáveis de ambiente — elas não são aceitas como argumentos de linha de comando para evitar a exposição de segredos na lista de processos. A URL do servidor Octopus pode ser fornecida por meio da variável de ambiente OCTOPUS_SERVER_URL ou da flag --server-url.

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

Ou com a URL do servidor na linha de comando:

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

Autenticação

O servidor MCP suporta dois métodos de autenticação. Ambos são fornecidos por meio de variáveis de ambiente — as credenciais não são aceitas na linha de comando porque as flags ficam visíveis na lista de processos do host para qualquer usuário local.

Chave de API (recomendado para uso interativo)

As chaves de API são o método de autenticação padrão para o Octopus Deploy. Você pode gerar uma a partir do seu perfil de usuário do Octopus Deploy.

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

Token de Acesso / Token Bearer (apenas cenários automatizados)

O servidor também suporta tokens de acesso de curta duração (tokens Bearer) como alternativa às chaves de API. Este método de autenticação destina-se apenas a cenários automatizados onde um sistema externo emite um token de curta duração para o servidor MCP (por exemplo, pipelines de CI/CD, orquestração automatizada ou fluxos de trabalho máquina a máquina). Não use tokens Bearer de longa duração — use chaves de API para sessões interativas ou de longa execução.

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

Exemplo completo de configuração com um token de acesso:

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

Se uma chave de API e um token de acesso forem fornecidos, o token de acesso terá precedência. O método de autenticação ativo é registrado no arquivo de log (configurável com --log-file) para que os operadores possam confirmar qual credencial está em uso.

Opções de Configuração

O Servidor MCP do Octopus suporta várias opções de linha de comando para personalizar quais ferramentas estão disponíveis.

Se você não tiver certeza de quais ferramentas precisa, recomendamos executar sem nenhuma opção adicional de linha de comando e usar os padrões fornecidos.

Conjuntos de Ferramentas

Use o parâmetro --toolsets para habilitar grupos específicos de ferramentas:

# 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

Conjuntos de ferramentas disponíveis:

  • core - Operações básicas (sempre habilitado)
  • projects - Operações de projeto
  • deployments - Operações de implantação
  • releases - Gerenciamento de liberações
  • runbooks - Descoberta e execução de runbooks
  • tasks - Operações de tarefa
  • tenants - Operações de multilocação
  • kubernetes - Operações do Kubernetes
  • machines - Operações de destino de implantação
  • certificates - Operações de certificado
  • accounts - Operações de conta
  • interruptions - Operações de intervenção manual e aprovação
  • featureToggles - Inspecionar e ajustar os feature toggles do cliente
  • context - Contexto do usuário autenticado e do projeto (usuário atual, branches Git)

Modo Somente Leitura

O servidor é executado com ferramentas de gravação habilitadas por padrão. Passe --read-only para desabilitar todas as ferramentas de gravação e bloquear POST/PUT/PATCH/DELETE por meio do backstop execute. A maioria das ferramentas com curadoria já são somente leitura; apenas um pequeno conjunto realiza gravações.

Ferramentas habilitadas para gravação (sempre gravam):

  • create_release - Criar novas liberações
  • deploy_release - Implantar liberações em ambientes e tenants
  • run_runbook - Executar um runbook em um ou mais ambientes (e tenants opcionais)
  • update_feature_toggle - Ajustar o estado por ambiente e as porcentagens de lançamento em um feature toggle existente

Ferramenta de gravação condicional: execute é um backstop REST estruturado cujo nível (leitura / gravação / exclusão) é determinado pelo método HTTP passado a ele. Consulte a seção Catálogo de API e Backstop para obter detalhes.

As ferramentas de gravação são controladas por um prompt de elicitação MCP: os clientes que suportam elicitação serão solicitados a confirmar antes que a chamada prossiga. Clientes sem suporte a elicitação devem passar confirm: true nos argumentos da ferramenta — caso contrário, a ferramenta será abortada com um erro. Defina OCTOPUS_SKIP_ELICITATION=true para ignorar totalmente o controle (destinado à automação não assistida).

O servidor usa uma classificação de três níveis de leitura/gravação/exclusão, aplicada no lado do servidor com base no método HTTP (o agente não pode contornar isso mentindo sobre a intenção):

  • read — sempre permitido. Solicitações GET por meio de execute, além de todas as ferramentas find_* / get_* / list_*.
  • write — POST/PUT/PATCH por meio de execute e as ferramentas de gravação sempre ativas acima. Bloqueado quando --read-only está definido.
  • delete — DELETE por meio de execute. Requer --allow-deletes e é bloqueado quando --read-only está definido. Um pequeno conjunto de caminhos de exclusão catastrófica (por exemplo, DELETE /api/spaces/{id}, DELETE /api/users/{id}) e endpoints de chave de API estão em uma lista de negação sensível rígida que ignora ambas as flags.
# 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

Nota de Segurança: Use uma chave de API com permissões apropriadas e de privilégio mínimo — as operações de gravação podem criar liberações e acionar implantações em sua instância do Octopus. Para produção, considere passar --read-only, a menos que você tenha um caso de uso específico e controlado para gravações. --allow-deletes está desativado por padrão; habilite-o apenas quando o agente precisar emitir solicitações DELETE por meio de execute. Se você passar --allow-deletes junto com --read-only, o servidor imprime um aviso de inicialização no stderr — as solicitações DELETE permanecem bloqueadas pelo controle de somente leitura.

Exemplos Completos

Todos os exemplos abaixo assumem que OCTOPUS_API_KEY está definido no ambiente. A flag --server-url é mostrada para maior clareza, mas também pode ser fornecida por meio de OCTOPUS_SERVER_URL.

# 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

Outros argumentos de linha de comando

  • --read-only - Habilitar o modo somente leitura: desabilitar todas as ferramentas de gravação com curadoria e bloquear POST/PUT/PATCH/DELETE por meio de execute. As gravações são habilitadas por padrão; esta flag as desativa. Consulte Modo Somente Leitura.
  • --allow-deletes - Permitir solicitações DELETE por meio da ferramenta execute. Ignorado (com um aviso de inicialização) quando --read-only está definido. Padrão false.
  • --log-level <level> - Nível mínimo de log (info, error)
  • --log-file <path> - Caminho ou nome do arquivo de log. Se não for especificado, os logs são gravados apenas no console
  • -q, --quiet - Desabilitar o log em arquivo, registrar apenas erros no console
  • --list-tools-by-version - Listar todas as ferramentas registradas por sua versão suportada do Servidor Octopus e sair

🔨 Ferramentas

Ferramentas Baseadas em URL

Início rápido: Cole URLs do Octopus diretamente para investigar problemas sem extração manual de IDs.

  • get_deployment_from_url: Obter detalhes da implantação a partir da URL de implantação (retorna taskId para acompanhamento)
  • get_task_from_url: Obter detalhes da tarefa e logs a partir da URL da tarefa

Fluxo de trabalho de investigação de implantação:

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 })

Investigação de tarefa (URL direta da tarefa):

get_task_from_url with task URL
→ Returns task details and logs immediately

Essas ferramentas eliminam a extração manual de IDs ao:

  • Analisar URLs automaticamente
  • Resolver IDs de espaço para nomes de espaço
  • Validar formatos de ID
  • Fornecer mensagens de erro claras

Exemplos de URLs:

  • Implantação: https://your-octopus.com/app#/Spaces-1/projects/my-app/deployments/Deployments-123
  • Tarefa: https://your-octopus.com/app#/Spaces-1/tasks/ServerTasks-456

Consulte Trabalhando com URLs para fluxos de trabalho detalhados, exemplos e práticas recomendadas.

Ferramentas Principais

  • list_spaces: Listar todos os espaços na instância do Octopus Deploy
  • list_environments: Listar todos os ambientes em um determinado espaço

Catálogo de API e Backstop

Essas ferramentas e recursos permitem que o agente alcance endpoints REST do Octopus que não possuem uma ferramenta dedicada com curadoria, com um controle rígido no lado do servidor entre operações de leitura, gravação e exclusão.

  • grep_llms_txt: Pesquisa o catálogo da API do Octopus (octopus://api/llms.txt) com semântica estilo grep (versão mínima suportada do Octopus: 2026.2.3916). O corpo do catálogo é grande (tipicamente mais de 300 KB) — chame esta ferramenta em vez de ler o corpo do recurso diretamente. Os parâmetros espelham o GNU grep (pattern, caseInsensitive, invertMatch, fixedString, beforeContext, afterContext, maxCount). Útil para descobrir endpoints (POST /releases), enumerar endpoints de exclusão (DELETE ) ou encontrar o tipo de corpo para uma operação de escrita (Body: Create.*Command).
  • execute: Retaguarda REST estruturada. Alcança qualquer endpoint REST do Octopus sob /api. O método HTTP é o classificador autoritativo de leitura/escrita/exclusão — nunca uma flag isWrite que o LLM possa definir. O controle de método é fixo no lado do servidor:
    • GET é sempre permitido (sujeito à verificação de formato do caminho + lista de bloqueio de itens sensíveis).
    • POST/PUT/PATCH são bloqueados quando --read-only está definido; caso contrário, exigem confirmação do usuário via elicitação.
    • DELETE exige --allow-deletes (e é bloqueado quando --read-only está definido) mais uma mensagem de elicitação mais forte de "IRREVERSÍVEL".
    • A lista de bloqueio de itens sensíveis (endpoints de chave de API, DELETE /api/spaces/{id}, DELETE /api/users/{id}) é aplicada mesmo com ambas as flags ativadas.
    • O caminho deve ser /api ou começar com /api/ — URLs absolutas, caminhos relativos ao SDK ~/api/... e caminhos relativos ao host fora de /api (ex.: /octopus/portal/...) são rejeitados de imediato, para que execute permaneça limitado à superfície da API REST do Octopus.
    • A lista de permissões de caminhos por conjunto de ferramentas aplica-se somente quando --toolsets foi restringido. Com todos os conjuntos de ferramentas habilitados (o padrão, ou --toolsets all explícito), a lista de permissões é ignorada e qualquer caminho sob /api é acessível, sujeito aos controles acima. Quando --toolsets é restringido, a lista de permissões torna-se o interruptor de segurança: os caminhos só são resolvidos se o conjunto de ferramentas proprietário estiver habilitado, portanto, desabilitar um conjunto de ferramentas (ex.: certificates) torna seus caminhos inacessíveis através de execute, mesmo em GET.

Os dados do catálogo também são expostos como Recursos MCP:

  • octopus://api/llms.txt — catálogo em markdown de cada endpoint REST do Octopus (método HTTP, caminho, parâmetros de consulta, tipos de requisição/resposta). Requer Octopus Server 2026.2.3916 ou posterior. Cache em memória de 5 minutos indexado pela URL do servidor configurado. Prefira grep_llms_txt a ler o corpo diretamente.
  • octopus://api/capabilities — JSON descrevendo a sessão em execução: versão do servidor, conjuntos de ferramentas habilitados, ferramentas disponíveis (com seus minimumOctopusVersion) e se --read-only / --allow-deletes está ativo. Útil para o agente descobrir o que está acessível nesta sessão.

Projetos

  • list_projects: Lista todos os projetos em um determinado espaço

Implantações

  • deploy_release: Implanta uma release em ambientes (suporta implantações com e sem tenants)
  • list_deployments: Lista implantações em um espaço com filtragem opcional

Releases

  • create_release: Cria uma nova release para um projeto
  • find_releases: Encontra releases em um espaço (pode obter uma release específica por ID, ou listar/filtrar releases por projeto)

Detalhes da release também estão disponíveis como um Recurso MCP em octopus://spaces/{spaceName}/releases/{releaseId} — obtenha via resources/read (ou a ferramenta de retaguarda read_resource) para obter o corpo completo da release, incluindo notas de release e pacotes selecionados.

Runbooks

  • find_runbooks: Encontra runbooks em um projeto (pode obter um runbook específico por ID, ou listar/filtrar runbooks por nome parcial). Cada resumo inclui o ID do snapshot publicado, modo de multi-tenancy e escopo de ambiente para que os chamadores possam escolher alvos válidos antes da execução.
  • run_runbook: Executa um runbook em um ou mais ambientes. Suporta execuções com tenants (por nome de tenant ou tag de tenant), variáveis solicitadas, modo de falha guiada, janelas de execução agendadas e inclusão/exclusão de etapas ou máquinas. Padroniza para o snapshot publicado do runbook se runbookSnapshotId for omitido.

O corpo completo do runbook (incluindo campos de política de tempo de execução) está disponível como um Recurso MCP em octopus://spaces/{spaceName}/runbooks/{runbookId}.

Tarefas

Os dados de tarefas são expostos principalmente como Recursos MCP. Use resources/read (ou a ferramenta de retaguarda read_resource) com um dos seguintes:

  • octopus://spaces/{spaceName}/tasks/{taskId} — metadados leves (estado, tempo, flags de conclusão)
  • octopus://spaces/{spaceName}/tasks/{taskId}/details — ServerTaskDetails completo (Progresso, árvore ActivityLogs, etc.)

Para busca em logs, use a ferramenta grep_task_log em vez de um recurso /log:

  • grep_task_log: Pesquisa o log de atividades de uma tarefa sem buscar o corpo completo. Os parâmetros espelham o GNU grep (pattern, caseInsensitive, invertMatch, fixedString, beforeContext, afterContext, maxCount). Retorna linhas correspondentes com lineNumber indexado em 1, arrays opcionais de contexto antes/depois e uma contagem totalMatches em todo o log.

Intencionalmente, não há recurso /log: logs de atividades podem ter vários megabytes, e um recurso endereçável tentaria os chamadores a buscar o corpo inteiro quando o grep é quase sempre a primitiva correta.

Tenants

  • find_tenants: Encontra tenants em um espaço (pode obter um tenant específico por ID ou listar/pesquisar tenants com filtros)
  • get_tenant_variables: Obtém variáveis de tenant por tipo (todas, comuns ou do projeto)
  • get_missing_tenant_variables: Obtém variáveis de tenant que estão sem valores

Kubernetes

  • get_kubernetes_live_status: Obtém o status ao vivo dos recursos Kubernetes para um projeto e ambiente (versão mínima suportada: 2025.3)

Máquinas (Alvos de Implantação)

  • find_deployment_targets: Encontra alvos de implantação em um espaço (pode obter um alvo específico por ID ou listar/pesquisar alvos com filtros)

Certificados

  • find_certificates: Encontra certificados em um espaço (pode obter um certificado específico por ID ou listar/pesquisar certificados com filtros)

Contas

  • find_accounts: Encontra contas em um espaço (pode obter uma conta específica por ID ou listar/pesquisar contas com filtros)

Interrupções

  • find_interruptions: Encontra interrupções pendentes ou históricas (intervenções manuais, aprovações, prompts de falha guiada) em um espaço, opcionalmente filtradas por tarefa, projeto, ambiente, documento referente, responsabilidade ou estado pendente. Retorna resumos enxutos; desreferencie o recurso octopus://spaces/{spaceName}/interruptions/{interruptionId} para obter a definição completa do Formulário (tipos de controle, instruções em Markdown, opções de botão, Form.Values enviados).

Feature Toggles

  • find_feature_toggles: Lista os feature toggles do cliente em um projeto. Cada resumo inclui o estado por ambiente (isEnabled, rolloutPercentage, clientRolloutPercentage) mais um resourceUri para que "onde X está ativado" possa ser respondido a partir da resposta da lista.
  • update_feature_toggle: Ajusta um toggle existente. Superfície restrita — ativa/desativa um ambiente, altera porcentagens de rollout ou atualiza a descrição / estado padrão no nível do toggle. Internamente, busca o toggle atual, aplica seus patches em memória e faz PUT do corpo mesclado, de modo que ambientes não mencionados e campos não mencionados sejam preservados. Patches que referenciam um ambiente ainda não configurado no toggle são rejeitados.

O corpo completo do toggle (descrição, tenants, segmentos, versões mínimas) está disponível como um Recurso MCP em octopus://spaces/{spaceName}/projects/{projectId}/featuretoggles/{slug}. Os corpos dos grupos de rollout são endereçáveis em octopus://spaces/{spaceName}/projects/{projectId}/rolloutgroups/{rolloutGroupId} para inspeção somente leitura.

Fora do escopo (use a UI do Octopus): criar novos feature toggles, excluir toggles, renomear ou retaggear, anexar/desanexar grupos de rollout, direcionamento de tenants, segmentos, filtros de versão mínima e gerenciamento de grupos de rollout / identificador de cliente SDK.

Ferramentas Adicionais

  • get_deployment_process: Obtém o processo de implantação por ID para projetos ou releases
  • get_variables: Obtém todas as variáveis do projeto e variáveis do conjunto de variáveis da biblioteca para um projeto (suporta projetos config-as-code via gitRef)
  • get_branches: Obtém branches Git para um projeto com controle de versão (versão mínima suportada: 2021.2)
  • get_current_user: Obtém informações sobre o usuário autenticado atual

🔒 Considerações de Segurança

O Servidor MCP do Octopus inclui operações de leitura e escrita. Considerações de segurança importantes:

Operações de Leitura

  • Podem ler logs completos de implantação, que podem incluir segredos de produção se não foram marcados como segredos
  • Acesso a dados de configuração e variáveis sensíveis
  • Tenha cuidado ao conectar-se a ferramentas e modelos nos quais você não confia totalmente

Operações de Escrita

Por padrão, as seguintes operações de escrita estão disponíveis:

  • Criação de releases: Pode criar novas releases para projetos
  • Implantação de releases: Pode acionar implantações em ambientes (incluindo produção)
  • Execução de runbooks: Pode executar runbooks em ambientes e tenants
  • Atualização de feature toggles: Pode alterar o estado por ambiente e mudar porcentagens de rollout em toggles existentes
  • POST/PUT/PATCH arbitrário via retaguarda execute: Limitado a caminhos sob /api, com uma lista de bloqueio de itens sensíveis sempre ativa. A lista de permissões de caminhos por conjunto de ferramentas aplica-se somente quando --toolsets foi restringido; com todos os conjuntos de ferramentas habilitados (o padrão), os únicos controles de caminho são o limite /api e a lista de bloqueio de itens sensíveis.

Passe --read-only para desabilitar todos os itens acima. Requisições DELETE através de execute exigem uma flag adicional --allow-deletes — uma aceitação deliberada para operações irreversíveis — e permanecem bloqueadas quando --read-only está definido.

Medidas Críticas de Segurança:

  1. Privilégio Mínimo: Use chaves de API com as permissões mínimas necessárias para o seu caso de uso
  2. Aceite o Modo Somente Leitura: Escritas são habilitadas por padrão. Para produção, passe --read-only a menos que você tenha um caso de uso específico e controlado para operações de escrita. DELETE sempre exige a aceitação adicional --allow-deletes.
  3. O controle de método é do lado do servidor e fixo no código: O método HTTP passado para execute é o classificador autoritativo. O agente não pode contornar o controle deturpando o que a chamada faz — requisições POST/PUT/PATCH/DELETE recebem controle específico por nível, independentemente do texto no corpo da requisição.
  4. A filtragem de conjunto de ferramentas funciona como interruptor de segurança: Restringir --toolsets remove tanto as ferramentas curadas dos conjuntos desabilitados quanto seus caminhos da lista de permissões execute. (A lista de permissões só é consultada quando os conjuntos de ferramentas são restringidos; com todos os conjuntos habilitados, execute é limitado pela verificação de formato /api e pela lista de bloqueio de itens sensíveis.)
  5. Risco de Injeção de Prompt: Executar agentes de forma totalmente automatizada pode torná-lo vulnerável a ataques de injeção de prompt

Recomendação: Para ambientes de produção, passe --read-only a menos que você tenha um caso de uso específico e controlado para operações de escrita. Deixe --allow-deletes desligado a menos que você precise especificamente da semântica DELETE através de execute.

⚠️ Limitações

Análise de Dados

A natureza das atuais ferramentas de chat com IA e do próprio protocolo MCP torna impraticável analisar grandes quantidades de dados. A maioria dos clientes MCP atualmente não suporta o encadeamento de chamadas de ferramentas (usar a saída de uma ferramenta como entrada para a próxima) e, em vez disso, recorre à cópia dos resultados token por token, o que frequentemente leva a alucinações. Se você deseja processar dados históricos da sua instância do Octopus para fins de análise, recomendamos usar a API diretamente ou escrever seu próprio cliente MCP capaz de processar os resultados das chamadas de ferramentas programaticamente.

Desempenho

O Servidor MCP é tecnicamente apenas uma camada fina sobre a API existente do Octopus Server. Como tal, é capaz de recuperar grandes quantidades de dados (por exemplo, solicitar milhares de implantações). Essas consultas podem ter um efeito significativo no desempenho da sua instância. Instrua seus modelos a recuperar apenas o conjunto mínimo de dados necessário (a maioria dos modelos é muito boa nisso por padrão).

🤝 Contribuições

Contribuições são bem-vindas! :heart: Por favor, leia nosso Guia de Contribuição para obter informações sobre como se envolver neste projeto.

Estamos ansiosos para saber como você planeja usar o Octopus MCP Server e quais recursos gostaria de ver incluídos em versões futuras.

Por favor, use as Issues para fornecer feedback ou solicitar recursos.

Se você é um cliente atual da Octopus, relate quaisquer problemas que tiver ao usar nosso servidor MCP para nossa equipe de suporte. Isso garantirá que você receba uma resposta em tempo hábil, dentro de nossas garantias de suporte padrão.

🙋 Perguntas Frequentes

Vocês têm planos de lançar um servidor MCP remoto?

Estamos trabalhando na integração de um servidor MCP diretamente no Octopus Server. Isso abrirá caminho para construirmos ferramentas MCP mais complexas, além de:

  • Dar aos Administradores Octopus um controle mais granular sobre os clientes MCP
  • Suporte nativo a OAuth para autenticação de clientes
  • Integrar ferramentas de varredura de segurança na saída do MCP

Se isso for do seu interesse, por favor, registre seu interesse em nosso item no roadmap.

Licença

Este projeto está licenciado sob os termos da licença de código aberto Mozilla Public License 2.0.