CircleCI

oficial

Permita que Agentes de IA corrijam falhas de build do CircleCI.

O que você pode fazer com CircleCI MCP?

  • Validar configuração — Peça ao assistente para validar seu .circleci/config.yml e obter orientação sobre erros de sintaxe e semânticos via config_helper.
  • Diagnosticar falhas de build — Recupere logs detalhados de falha de um build do CircleCI com get_build_failure_logs.
  • Encontrar testes instáveis — Identifique testes instáveis analisando o histórico de execução de testes de um projeto com find_flaky_tests.
  • Verificar status do pipeline — Obtenha o status do pipeline mais recente de uma branch usando get_latest_pipeline_status.
  • Executar workflows novamente — Execute novamente um workflow desde o início ou a partir do job que falhou com rerun_workflow.
  • Disparar pipelines — Execute um pipeline ou dispare um rollback de projeto usando run_pipeline e run_rollback_pipeline.

Documentação

[!IMPORTANT] Este pacote está obsoleto. Por favor, migre.

@circleci/mcp-server-circleci não recebe mais novos recursos. Use o servidor MCP hospedado do CircleCI ou o CircleCI CLI MCP — consulte a visão geral do CircleCI MCP.

Este repositório será arquivado. As versões existentes continuam instaláveis via npm, mas não é recomendado executar um servidor sem manutenção que armazena um Token de API Pessoal do CircleCI.

Se você está executando o transporte remoto autogerenciado (start=remote), migre primeiro: o servidor hospedado é o substituto direto e elimina a necessidade de operar um serviço exposto à rede que intermedeia o token da sua organização.

CircleCI MCP Server

License: Apache 2.0 CircleCI npm

O Model Context Protocol (MCP) é um novo protocolo padronizado para gerenciar contexto entre grandes modelos de linguagem (LLMs) e sistemas externos. Neste repositório, fornecemos um MCP Server para o CircleCI.

Use Cursor, Windsurf, Copilot, Claude ou qualquer cliente compatível com MCP para interagir com o CircleCI usando linguagem natural — sem sair da sua IDE.

Ferramentas

FerramentaDescrição
config_helperValide e obtenha orientações para sua configuração do CircleCI
download_usage_api_dataBaixe dados de uso da API de Uso do CircleCI
find_flaky_testsIdentifique testes instáveis analisando o histórico de execução de testes
find_underused_resource_classesEncontre jobs com recursos de computação subutilizados
get_build_failure_logsRecupere logs detalhados de falhas de builds do CircleCI
get_job_test_resultsRecupere metadados e resultados de testes de jobs do CircleCI
get_latest_pipeline_statusObtenha o status do pipeline mais recente de uma branch
list_artifactsListe os artefatos produzidos por um job do CircleCI
list_component_versionsListe todas as versões de um componente do CircleCI
list_followed_projectsListe todos os projetos do CircleCI que você segue
rerun_workflowExecute novamente um workflow desde o início ou a partir do job que falhou
run_pipelineDispare a execução de um pipeline
run_rollback_pipelineDispare um rollback de um projeto

Instalação

Equipe / implantação centralizada: Para executar um servidor remoto compartilhado para sua organização (Kubernetes, Docker, etc.) com tokens do CircleCI por desenvolvedor ou compartilhados, consulte Self-Managed Remote MCP Server.

Cursor

Pré-requisitos:

Usando NPX em um MCP Server local

Adicione o seguinte à sua configuração MCP do Cursor:

{
  "mcpServers": {
    "circleci-mcp-server": {
      "command": "npx",
      "args": ["-y", "@circleci/mcp-server-circleci@latest"],
      "env": {
        "CIRCLECI_TOKEN": "your-circleci-token",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      }
    }
  }
}

CIRCLECI_BASE_URL é opcional — necessário apenas para clientes on-prem. MAX_MCP_OUTPUT_LENGTH é opcional — comprimento máximo de saída para respostas MCP (padrão: 50000).

Usando Docker em um MCP Server local

Adicione o seguinte à sua configuração MCP do Cursor:

{
  "mcpServers": {
    "circleci-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "CIRCLECI_TOKEN",
        "-e",
        "CIRCLECI_BASE_URL",
        "-e",
        "MAX_MCP_OUTPUT_LENGTH",
        "circleci/mcp-server-circleci"
      ],
      "env": {
        "CIRCLECI_TOKEN": "your-circleci-token",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      }
    }
  }
}

Usando um Self-Managed Remote MCP Server

Consulte Self-Managed Remote MCP Server. Use a configuração de cliente por usuário e adicione-a à sua configuração MCP do Cursor (Cursor Settings → MCP).

VS Code

Pré-requisitos:

Usando NPX em um MCP Server local

Adicione o seguinte ao .vscode/mcp.json no seu projeto:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "circleci-token",
      "description": "CircleCI API Token",
      "password": true
    },
    {
      "type": "promptString",
      "id": "circleci-base-url",
      "description": "CircleCI Base URL",
      "default": "https://circleci.com"
    }
  ],
  "servers": {
    "circleci-mcp-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@circleci/mcp-server-circleci@latest"],
      "env": {
        "CIRCLECI_TOKEN": "${input:circleci-token}",
        "CIRCLECI_BASE_URL": "${input:circleci-base-url}"
      }
    }
  }
}

💡 As entradas são solicitadas na primeira inicialização do servidor e depois armazenadas com segurança pelo VS Code.

Usando Docker em um MCP Server local

Adicione o seguinte ao .vscode/mcp.json no seu projeto:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "circleci-token",
      "description": "CircleCI API Token",
      "password": true
    },
    {
      "type": "promptString",
      "id": "circleci-base-url",
      "description": "CircleCI Base URL",
      "default": "https://circleci.com"
    }
  ],
  "servers": {
    "circleci-mcp-server": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "CIRCLECI_TOKEN",
        "-e",
        "CIRCLECI_BASE_URL",
        "circleci/mcp-server-circleci"
      ],
      "env": {
        "CIRCLECI_TOKEN": "${input:circleci-token}",
        "CIRCLECI_BASE_URL": "${input:circleci-base-url}"
      }
    }
  }
}

Usando um Self-Managed Remote MCP Server

Consulte Self-Managed Remote MCP Server. Use a configuração de cliente por usuário no .vscode/mcp.json.

Claude Desktop

Pré-requisitos:

Usando NPX em um MCP Server local

Adicione o seguinte ao seu claude_desktop_config.json:

{
  "mcpServers": {
    "circleci-mcp-server": {
      "command": "npx",
      "args": ["-y", "@circleci/mcp-server-circleci@latest"],
      "env": {
        "CIRCLECI_TOKEN": "your-circleci-token",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      }
    }
  }
}

Usando Docker em um MCP Server local

Adicione o seguinte ao seu claude_desktop_config.json:

{
  "mcpServers": {
    "circleci-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "CIRCLECI_TOKEN",
        "-e",
        "CIRCLECI_BASE_URL",
        "-e",
        "MAX_MCP_OUTPUT_LENGTH",
        "circleci/mcp-server-circleci"
      ],
      "env": {
        "CIRCLECI_TOKEN": "your-circleci-token",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      }
    }
  }
}

Usando um Self-Managed Remote MCP Server

Consulte Self-Managed Remote MCP Server. Crie um script wrapper conforme mostrado em Claude Desktop and CLI clients e então aponte seu claude_desktop_config.json para ele.

Para encontrar ou criar seu arquivo de configuração, abra as configurações do Claude Desktop, clique em Developer na barra lateral esquerda e então clique em Edit Config. O arquivo de configuração está localizado em:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Para mais informações: https://modelcontextprotocol.io/quickstart/user

Claude Code

Pré-requisitos:

Usando NPX em um MCP Server local

claude mcp add circleci-mcp-server -e CIRCLECI_TOKEN=your-circleci-token -- npx -y @circleci/mcp-server-circleci@latest

Usando Docker em um MCP Server local

claude mcp add circleci-mcp-server -e CIRCLECI_TOKEN=your-circleci-token -e CIRCLECI_BASE_URL=https://circleci.com -- docker run --rm -i -e CIRCLECI_TOKEN -e CIRCLECI_BASE_URL circleci/mcp-server-circleci

Usando um Self-Managed Remote MCP Server

Consulte Self-Managed Remote MCP Server e a configuração do cliente Claude Code lá.

Windsurf

Pré-requisitos:

Usando NPX em um MCP Server local

Adicione o seguinte ao seu mcp_config.json do Windsurf:

{
  "mcpServers": {
    "circleci-mcp-server": {
      "command": "npx",
      "args": ["-y", "@circleci/mcp-server-circleci@latest"],
      "env": {
        "CIRCLECI_TOKEN": "your-circleci-token",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      }
    }
  }
}

Usando Docker em um MCP Server local

Adicione o seguinte ao seu mcp_config.json do Windsurf:

{
  "mcpServers": {
    "circleci-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "CIRCLECI_TOKEN",
        "-e",
        "CIRCLECI_BASE_URL",
        "-e",
        "MAX_MCP_OUTPUT_LENGTH",
        "circleci/mcp-server-circleci"
      ],
      "env": {
        "CIRCLECI_TOKEN": "your-circleci-token",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      }
    }
  }
}

Usando um Self-Managed Remote MCP Server

Consulte Self-Managed Remote MCP Server. Use a configuração de cliente por usuário no seu mcp_config.json do Windsurf.

Para mais informações: https://docs.windsurf.com/windsurf/mcp

Amazon Q Developer CLI

Pré-requisitos:

A configuração do cliente MCP no Amazon Q Developer é armazenada em formato JSON em um arquivo chamado mcp.json. Dois níveis de configuração são suportados:

  • Global: ~/.aws/amazonq/mcp.json — aplica-se a todos os workspaces
  • Workspace: .amazonq/mcp.json — específico do workspace atual

Se ambos os arquivos existirem, seus conteúdos são mesclados. Em caso de conflito, a configuração do workspace tem precedência.

Usando NPX em um MCP Server local

Edite ~/.aws/amazonq/mcp.json ou crie .amazonq/mcp.json com o seguinte:

{
  "mcpServers": {
    "circleci-local": {
      "command": "npx",
      "args": [
        "-y",
        "@circleci/mcp-server-circleci@latest"
      ],
      "env": {
        "CIRCLECI_TOKEN": "YOUR_CIRCLECI_TOKEN",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      },
      "timeout": 60000
    }
  }
}

Usando um Self-Managed Remote MCP Server

Consulte Self-Managed Remote MCP Server. Use um script wrapper conforme mostrado em Claude Desktop and CLI clients e então registre-o com q mcp add.

Amazon Q Developer in the IDE

Pré-requisitos:

Usando NPX em um MCP Server local

Edite ~/.aws/amazonq/mcp.json ou crie .amazonq/mcp.json com o seguinte:

{
  "mcpServers": {
    "circleci-local": {
      "command": "npx",
      "args": [
        "-y",
        "@circleci/mcp-server-circleci@latest"
      ],
      "env": {
        "CIRCLECI_TOKEN": "YOUR_CIRCLECI_TOKEN",
        "CIRCLECI_BASE_URL": "https://circleci.com",
        "MAX_MCP_OUTPUT_LENGTH": "50000"
      },
      "timeout": 60000
    }
  }
}

Usando um Self-Managed Remote MCP Server

Consulte Self-Managed Remote MCP Server. Use um script wrapper conforme mostrado em Claude Desktop and CLI clients e então adicione-o pela interface de configuração MCP:

  1. Acesse a interface de configuração MCP
  2. Escolha o símbolo +
  3. Selecione o escopo: global ou local
  4. Insira um nome (ex.: circleci-remote-mcp)
  5. Selecione o protocolo de transporte: stdio
  6. Insira o caminho do comando para o seu script
  7. Clique em Save
Smithery

Para instalar o CircleCI MCP Server no Claude Desktop automaticamente via Smithery:

npx -y @smithery/cli install @CircleCI-Public/mcp-server-circleci --client claude

Self-Managed Remote MCP Server

Execute o servidor MCP de forma centralizada (por exemplo, em Kubernetes ou Docker) para que sua equipe compartilhe uma única implantação. Escolha como os desenvolvedores se autenticam:

Escolha um modo de implantação

ModoQuando usarConfiguração do servidorConfiguração do clienteTrilha de auditoria do CircleCI
Tokens por usuário (recomendado)Equipes com Tokens de API Pessoais respaldados por SSOREQUIRE_REQUEST_TOKEN=true, sem PAT no servidorCada dev encaminha seu PATPor desenvolvedor
Token compartilhado (interino)Implantação rápida, identidade de serviço única é aceitávelCIRCLECI_TOKEN no servidor, REQUIRE_REQUEST_TOKEN=false (opt-out explícito)Nenhum cabeçalho de autenticação necessárioIdentidade compartilhada única

Segurança: A autenticação de requisições está ativada por padrão no modo remoto. O modo de token compartilhado a desativa (REQUIRE_REQUEST_TOKEN=false), permitindo que qualquer chamador aja como a identidade CIRCLECI_TOKEN do servidor sem credenciais — incluindo disparar pipelines com configuração arbitrária. Ative-o apenas em uma rede totalmente confiável e prefira tokens por usuário caso contrário. Terminar TLS em um ingress fornece criptografia, não autenticação.

Como essa combinação é insegura em uma interface pública, o servidor se recusa a iniciar quando REQUIRE_REQUEST_TOKEN=false é combinado com um endereço de bind não-loopback, a menos que você aceite explicitamente o risco com MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESS=true. A verificação de Host/Origin não substitui a autenticação — consulte DNS-rebinding protection abaixo.

1. Implante o servidor

Ambos os modos usam o modo HTTP remoto (start=remote). Publique a porta 8000 (ou a porta de sua escolha).

Tokens por usuário (recomendado) — acessado via mcp-remote a partir do localhost:

docker run --rm -p 8000:8000 \
  -e start=remote \
  -e port=8000 \
  -e REQUIRE_REQUEST_TOKEN=true \
  circleci/mcp-server-circleci

Tokens por usuário (recomendado) — acessado via mcp-remote a partir de um hostname público:

docker run --rm -p 8000:8000 \
  -e start=remote \
  -e port=8000 \
  -e REQUIRE_REQUEST_TOKEN=true \
  -e MCP_ALLOWED_HOSTS=my-mcp.example.com \
  circleci/mcp-server-circleci

Token compartilhado (interino) — acessado via mcp-remote a partir de um hostname público:

Como este modo serve o PAT da organização a qualquer chamador sem credencial, ele deve ser executado apenas onde a porta publicada é inacessível a partir de redes não confiáveis, e você deve reconhecer isso explicitamente ou o servidor se recusará a iniciar:

docker run --rm -p 8000:8000 \
  -e start=remote \
  -e port=8000 \
  -e CIRCLECI_TOKEN=your-shared-circleci-pat \
  -e REQUIRE_REQUEST_TOKEN=false \
  -e MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESS=true \
  -e MCP_ALLOWED_HOSTS=my-mcp.example.com \
  circleci/mcp-server-circleci

Prefira colocar autenticação na frente da porta — um ingress que exija SSO, mTLS ou uma chave de API — ou mude para tokens por usuário acima.

Variáveis de ambiente:

VariávelDescrição
start=remoteInicia o servidor MCP HTTP+SSE em vez de stdio
portPorta de escuta dentro do contêiner (padrão: 8000)
REQUIRE_REQUEST_TOKENRejeita requisições sem o cabeçalho Authorization: Bearer ou Circle-Token. O padrão é obrigatório; defina REQUIRE_REQUEST_TOKEN=false para permitir requisições não autenticadas (modo token compartilhado)
CIRCLECI_TOKENPAT de fallback compartilhado para todas as requisições quando os cabeçalhos por usuário não são enviados
CIRCLECI_BASE_URLOpcional — obrigatório apenas para on-prem (padrão: https://circleci.com)
DISABLE_TELEMETRY=trueOpta por não exportar métricas de uso
MCP_ALLOWED_HOSTSLista separada por vírgulas de valores adicionais permitidos para o cabeçalho Host (ex.: my-mcp.example.com,my-mcp.example.com:443). Nomes de host de loopback são sempre permitidos. Obrigatório para qualquer implantação que não seja loopback.
MCP_ALLOWED_ORIGINSLista separada por vírgulas de valores adicionais permitidos para o cabeçalho Origin (ex.: https://my-app.example.com). Origens de loopback são sempre permitidas. Necessário apenas quando um navegador acessa este servidor diretamente (não via mcp-remote).
MCP_BIND_HOSTInterface de rede à qual se vincular (padrão: 0.0.0.0). Defina como 127.0.0.1 para restringir apenas ao loopback (incompatível com o mapeamento de portas -p do Docker).
MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESSObrigatório (=true) para iniciar com REQUIRE_REQUEST_TOKEN=false em um endereço de vinculação que não seja loopback. Reconhece que qualquer par capaz de alcançar a porta atua como a identidade CIRCLECI_TOKEN do servidor sem uma credencial. Não tem efeito quando tokens de requisição são exigidos.
MCP_FILE_OUTPUT_ROOTSLista separada por vírgulas de diretórios adicionais que as ferramentas de leitura/escrita de arquivos podem usar (ex.: /srv/reports,/data/exports). O diretório de trabalho, o diretório home e o diretório temporário são sempre permitidos. Consulte a observação abaixo.

Locais de saída de arquivos (aplica-se tanto a transportes stdio quanto remotos): As ferramentas que aceitam um caminho de sistema de arquivos — get_build_failure_logs (outputDir), download_usage_api_data (outputDir) e find_underused_resource_classes (csvFilePath) — só podem ler e gravar dentro do diretório de trabalho do servidor, do diretório home do usuário e do diretório temporário do sistema. Dentro dessas raízes, diretórios de configuração ocultos (~/.ssh, ~/.aws, ~/.config, .git, …), node_modules e diretórios de agentes de inicialização são rejeitados, assim como links simbólicos que resolvem para fora das raízes permitidas. Diretórios de sistema (/etc, /usr, /bin, /System, /Library, %SystemRoot%, …) são recusados incondicionalmente e não podem ser reativados. Arquivos de saída nunca são gravados por meio de um link simbólico.

Se o seu checkout estiver fora dessas raízes — /workspace em um contêiner, /srv, /opt, um volume secundário como /Volumes/work — defina MCP_FILE_OUTPUT_ROOTS para esse diretório, caso contrário esses caminhos serão rejeitados. Para um servidor stdio, o diretório de trabalho geralmente já é a raiz do projeto, então nenhuma configuração é necessária. Isso é mais importante para o transporte remoto, onde os caminhos vêm de clientes de rede em vez do usuário local.

Proteção contra DNS-rebinding (não é autenticação): O transporte remoto valida o cabeçalho Host em cada requisição /mcp. Por padrão, apenas endereços de loopback (localhost, 127.0.0.1, [::1]) são aceitos. Implantações públicas devem definir MCP_ALLOWED_HOSTS para o nome de host que os clientes usam, ou todas as requisições /mcp receberão 403 Forbidden. O endpoint de verificação de integridade /ping não é protegido, para que as sondagens do balanceador de carga continuem funcionando independentemente de Host.

O cabeçalho Origin (enviado por navegadores) também é validado quando presente. Clientes que não são navegadores, como mcp-remote, nunca enviam Origin, portanto não são afetados por essa verificação.

Esta verificação não é um controle de acesso e não deve ser tratada como tal. Ambos os cabeçalhos são escolhidos pelo chamador, então qualquer cliente que não seja navegador — curl, um script, um socket bruto — pode enviar um Host permitido e omitir Origin para satisfazê-la. Seu único propósito é impedir que um navegador seja direcionado ao servidor por DNS controlado pelo atacante, que é a ameaça de DNS-rebinding. Autenticar os chamadores é tarefa de REQUIRE_REQUEST_TOKEN (ou de um proxy de autenticação na frente da porta). Exigir um cabeçalho Origin quebraria todos os clientes CLI legítimos sem impedir nenhum atacante.

Atrás de um proxy reverso: Se o seu proxy reescreve Host para o endereço do backend (padrão do nginx), adicione proxy_set_header Host $host; para repassar o nome de host original, e então defina MCP_ALLOWED_HOSTS para esse nome de host público. Como alternativa, defina MCP_ALLOWED_HOSTS para qualquer nome de host que o proxy encaminhe.

O servidor aceita tokens por requisição via:

  • Authorization: Bearer <circleci-pat>
  • Circle-Token: <circleci-pat>

Se um cliente enviar um token de cabeçalho, ele tem precedência sobre CIRCLECI_TOKEN no servidor.

As métricas de telemetria registradas durante uma requisição são exportadas usando o mesmo token daquela requisição.

2. Configurar clientes

A maioria dos clientes MCP só oferece suporte a processos locais (stdio). Use mcp-remote, uma ponte stdio-para-HTTP de terceiros, para conectá-los ao seu servidor remoto.

Esquema de URL: Use http://localhost:8000/mcp com --allow-http para testes locais. Em produção, encerre o TLS no seu ingress/balanceador de carga e use https://your-host/mcp sem --allow-http.

Windows: Evite espaços ao redor dos dois-pontos em valores --header. Coloque o valor completo de Bearer <token> em uma variável de ambiente.

Segurança: Os exemplos usam npx por conveniência. Para implantações em produção ou em equipe, fixe uma versão específica na sua configuração MCP (por exemplo, mcp-remote@0.1.38 em vez de mcp-remote). Não use versões abaixo de 0.1.16 (CVE-2025-6514).

Configuração do cliente: tokens por usuário

Cada desenvolvedor encaminha seu próprio Token de API Pessoal do CircleCI em cada requisição:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "circleci-token",
      "description": "CircleCI API Token",
      "password": true
    }
  ],
  "mcpServers": {
    "circleci-mcp-server-remote": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://localhost:8000/mcp",
        "--allow-http",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer ${input:circleci-token}"
      }
    }
  }
}

Substitua http://localhost:8000/mcp pela URL do servidor da sua equipe. O Cursor e o VS Code oferecem suporte a prompts ${input:...}; outros clientes podem definir AUTH_HEADER diretamente.

Configuração do cliente: token compartilhado

Quando o servidor tem CIRCLECI_TOKEN definido e é iniciado com REQUIRE_REQUEST_TOKEN=false (a autenticação de requisição é ativada por padrão e deve ser explicitamente desativada, e uma vinculação que não seja loopback exige adicionalmente MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESS=true), os clientes não precisam enviar um token:

{
  "mcpServers": {
    "circleci-mcp-server-remote": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://localhost:8000/mcp",
        "--allow-http"
      ]
    }
  }
}

Clientes Claude Desktop e CLI

Crie um script wrapper (ex.: circleci-remote-mcp.sh):

#!/bin/bash
export AUTH_HEADER="Bearer your-circleci-token"
npx mcp-remote http://localhost:8000/mcp --allow-http --header "Authorization:${AUTH_HEADER}"

Torne-o executável (chmod +x circleci-remote-mcp.sh) e então faça referência a ele na sua configuração MCP:

{
  "mcpServers": {
    "circleci-remote-mcp-server": {
      "command": "/full/path/to/circleci-remote-mcp.sh"
    }
  }
}

Claude Code

claude mcp add circleci-mcp-server \
  -e AUTH_HEADER="Bearer your-circleci-token" \
  -- npx mcp-remote http://localhost:8000/mcp --allow-http --header "Authorization:${AUTH_HEADER}"

Omita --header e AUTH_HEADER ao usar um servidor de token compartilhado.

3. Verificar a implantação

# Health check (no auth required)
curl http://localhost:8000/ping

# Should return 401 when REQUIRE_REQUEST_TOKEN=true and no token is sent
curl -s -o /dev/null -w "%{http_code}\n" -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

# Should return 200 with a valid Bearer token and MCP Accept headers
curl -s -o /dev/null -w "%{http_code}\n" -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer your-circleci-pat" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

Demonstração

Veja em ação

Exemplo: "Encontre o pipeline com falha mais recente no meu branch e obtenha os logs" — consulte a wiki para mais exemplos.

https://github.com/user-attachments/assets/3c765985-8827-442a-a8dc-5069e01edb74

Detalhes das Ferramentas

config_helper

Auxilia em tarefas de configuração do CircleCI fornecendo orientação e validação.

  • Valida seu .circleci/config.yml quanto a erros de sintaxe e semânticos
  • Fornece resultados detalhados de validação e recomendações de configuração
  • Exemplo: "Valide minha configuração do CircleCI"
download_usage_api_data

Baixa dados de uso da API de Uso do CircleCI para uma determinada organização. Aceita entrada de data flexível (ex.: "março de 2025" ou "mês passado"). Recurso exclusivo do Cloud.

Opção 1: Inicie um novo job de exportação fornecendo:

  • orgId, startDate, endDate (máx. 32 dias), outputDir

Opção 2: Verifique/baixe um job de exportação existente fornecendo:

  • orgId, jobId, outputDir

Retorna um arquivo CSV com dados de uso do CircleCI para o período especificado.

[!NOTE] Os dados de uso podem ser alimentados na ferramenta find_underused_resource_classes para análise de otimização de custos.

find_flaky_tests

Identifica testes instáveis no seu projeto CircleCI analisando o histórico de execução de testes. Aproveita o recurso de detecção de testes instáveis do CircleCI.

Esta ferramenta pode ser usada de três maneiras:

  1. Usando o Project Slug (Recomendado):

    • Primeiro use list_followed_projects para obter seus projetos, depois:
    • Exemplo: "Obtenha testes instáveis do my-project"
  2. Usando a URL do Projeto CircleCI:

  3. Usando o Contexto do Projeto Local:

    • Funciona a partir do seu workspace local fornecendo a raiz do workspace e a URL remota do git
    • Exemplo: "Encontre testes instáveis no meu projeto atual"

Modos de saída:

  • Texto (padrão): Retorna detalhes dos testes instáveis em formato de texto
  • Arquivo (requer a variável de ambiente FILE_OUTPUT_DIRECTORY): Cria um diretório com os detalhes dos testes instáveis
find_underused_resource_classes

Analisa um arquivo CSV de dados de uso do CircleCI para encontrar jobs com uso médio ou máximo de CPU/RAM abaixo de um determinado limite (padrão: 40%).

Forneça um arquivo CSV obtido de download_usage_api_data.

Retorna uma lista em markdown de jobs subutilizados organizados por projeto e workflow — útil para identificar oportunidades de otimização de custos.

get_build_failure_logs

Recupera logs detalhados de falhas de builds do CircleCI. Esta ferramenta pode ser usada de três maneiras:

  1. Usando o Project Slug e o Branch (Recomendado):

    • Primeiro use list_followed_projects para obter seus projetos, depois:
    • Exemplo: "Obtenha falhas de build do my-project no branch main"
  2. Usando URLs do CircleCI:

  3. Usando o Contexto do Projeto Local:

    • Funciona a partir do seu workspace local fornecendo a raiz do workspace, a URL remota do git e o nome do branch
    • Exemplo: "Encontre o pipeline com falha mais recente no meu branch atual"

A ferramenta retorna logs formatados incluindo:

  • Nomes dos jobs
  • Detalhes de execução passo a passo
  • Mensagens de falha e contexto
get_job_test_results

Recupera metadados de testes de jobs do CircleCI, permitindo que você analise os resultados dos testes sem sair da sua IDE. Esta ferramenta pode ser usada de três maneiras:

  1. Usando o Project Slug e o Branch (Recomendado):

    • Exemplo: "Obtenha os resultados de testes do my-project no branch main"
  2. Usando a URL do CircleCI:

    • URL do job: https://app.circleci.com/pipelines/github/org/repo/123/workflows/abc-def/jobs/789
    • URL do workflow: https://app.circleci.com/pipelines/github/org/repo/123/workflows/abc-def
    • URL do pipeline: https://app.circleci.com/pipelines/github/org/repo/123
  3. Usando o Contexto do Projeto Local:

    • Funciona a partir do seu workspace local fornecendo a raiz do workspace, a URL remota do git e o nome do branch

A ferramenta retorna:

  • Resumo de todos os testes (total, bem-sucedidos, com falha)
  • Informações detalhadas sobre testes com falha: nome, classe, arquivo, mensagem de erro, duração
  • Lista de testes bem-sucedidos com seus tempos
  • Filtro por resultado de teste

[!NOTE] Os metadados de testes devem ser configurados na sua configuração do CircleCI. Consulte Coletar Dados de Testes para instruções de configuração.

get_latest_pipeline_status Recupera o status do pipeline mais recente de um determinado branch. Esta ferramenta pode ser usada de três maneiras:
  1. Usando Project Slug e Branch (Recomendado):

    • Exemplo: "Obtenha o status do pipeline mais recente do my-project no branch main"
  2. Usando a URL do Projeto no CircleCI:

  3. Usando o Contexto do Projeto Local:

    • Funciona a partir do seu workspace local fornecendo a raiz do workspace, a URL remota do git e o nome do branch

Exemplo de saída:

---
Workflow: build
Status: success
Duration: 5 minutes
Created: 4/20/2025, 10:15:30 AM
Stopped: 4/20/2025, 10:20:45 AM
---
Workflow: test
Status: running
Duration: unknown
Created: 4/20/2025, 10:21:00 AM
Stopped: in progress
list_artifacts

Recupera a lista de artefatos produzidos por um job do CircleCI. Esta ferramenta pode ser usada de três maneiras:

  1. Usando Project Slug e Branch (Recomendado):

    • Primeiro use list_followed_projects para obter seus projetos, depois:
    • Exemplo: "Liste os artefatos do my-project no branch main"
  2. Usando a URL do CircleCI:

    • URL do Job: https://app.circleci.com/pipelines/gh/organization/project/123/workflows/abc-def/jobs/789
    • URL do Workflow: https://app.circleci.com/pipelines/gh/organization/project/123/workflows/abc-def
    • URL do Pipeline: https://app.circleci.com/pipelines/gh/organization/project/123
  3. Usando o Contexto do Projeto Local:

    • Funciona a partir do seu workspace local fornecendo a raiz do workspace, a URL remota do git e o nome do branch

Útil para:

  • Encontrar URLs de download de artefatos de build (binários, relatórios, logs)
  • Verificar quais artefatos foram produzidos por uma execução de pipeline
list_component_versions

Lista todas as versões de um componente específico do CircleCI em um ambiente. Inclui status de implantação, informações de commit e timestamps.

A ferramenta solicitará que você selecione o componente e o ambiente, caso não sejam fornecidos.

Útil para:

  • Identificar qual versão está atualmente em produção
  • Selecionar versões de destino para operações de rollback
  • Obter detalhes de implantação (pipeline, workflow, job)
list_followed_projects

Lista todos os projetos que o usuário segue no CircleCI.

  • Mostra todos os projetos aos quais você tem acesso com seu projectSlug
  • Exemplo: "Liste meus projetos do CircleCI"

Exemplo de saída:

Projects followed:
1. my-project (projectSlug: gh/organization/my-project)
2. another-project (projectSlug: gh/organization/another-project)

[!NOTE] O projectSlug (não o nome do projeto) é necessário para muitas outras ferramentas do CircleCI.

rerun_workflow

Executa novamente um workflow desde o início ou a partir do job que falhou.

Retorna o ID do workflow recém-criado e um link para monitorá-lo.

run_pipeline

Dispara um pipeline para execução. Esta ferramenta pode ser usada de três maneiras:

  1. Usando Project Slug e Branch (Recomendado):

    • Exemplo: "Execute o pipeline do my-project no branch main"
  2. Usando a URL do CircleCI:

  3. Usando o Contexto do Projeto Local:

    • Funciona a partir do seu workspace local fornecendo a raiz do workspace, a URL remota do git e o nome do branch

A ferramenta retorna um link para monitorar a execução do pipeline.

run_rollback_pipeline

Dispara um rollback para um projeto do CircleCI. A ferramenta orienta você interativamente por meio de:

  1. Seleção de Projeto — lista os projetos seguidos para você escolher
  2. Seleção de Ambiente — lista os ambientes disponíveis (seleciona automaticamente se houver apenas um)
  3. Seleção de Componente — lista os componentes disponíveis (seleciona automaticamente se houver apenas um)
  4. Seleção de Versão — exibe as versões disponíveis; você seleciona o destino do rollback
  5. Detecção do Modo de Rollback — verifica se um pipeline de rollback está configurado
  6. Executar Rollback — duas opções:
    • Rollback de Pipeline: dispara o pipeline de rollback
    • Reexecução de Workflow: executa novamente um workflow anterior usando seu workflow ID
  7. Confirmação — resume e confirma antes da execução

Solução de Problemas

Correções Rápidas

Problemas mais comuns:

  1. Limpar caches de pacotes:

    npx clear-npx-cache
    npm cache clean --force
    
  2. Forçar a versão mais recente: Adicione @latest à sua configuração:

    "args": ["-y", "@circleci/mcp-server-circleci@latest"]
    
  3. Reinicie sua IDE completamente (não apenas recarregue a janela)

Problemas de Autenticação
  • Erros de token inválido: Verifique seu CIRCLECI_TOKEN em Personal API Tokens
  • Erros de permissão: Certifique-se de que o token tenha acesso de leitura aos seus projetos
  • Variáveis de ambiente não carregando: Teste com echo $CIRCLECI_TOKEN (Mac/Linux) ou echo %CIRCLECI_TOKEN% (Windows)
Problemas de Conexão e Rede
  • URL Base: Confirme que CIRCLECI_BASE_URL é https://circleci.com
  • Redes corporativas: Configure as definições de proxy do npm se estiver atrás de um firewall
  • Bloqueio por firewall: Verifique se o software de segurança bloqueia downloads de pacotes
Requisitos de Sistema
  • Versão do Node.js: Certifique-se de que atende a ^22.23.4 || ^24.22.1 || >=26.12.1 com node --version
  • Atualizar o Node.js: Considere a versão LTS mais recente se estiver enfrentando problemas de compatibilidade
  • Gerenciador de pacotes: Verifique se o npm/pnpm está funcionando: npm --version
Problemas Específicos da IDE
  • Localização do arquivo de configuração: Verifique novamente o caminho para o seu sistema operacional
  • Erros de sintaxe: Valide a sintaxe JSON no seu arquivo de configuração
  • Logs do console: Verifique o console do desenvolvedor da IDE para erros específicos
  • Tente uma IDE diferente: Teste em outro editor compatível para isolar o problema
Problemas de Processo

Processos travados — encerre os processos MCP existentes:

# Mac/Linux:
pkill -f "mcp-server-circleci"

# Windows:
taskkill /f /im node.exe

Conflitos de porta: Reinicie sua IDE se a conexão parecer bloqueada.

Depuração Avançada
  • Testar o pacote diretamente: npx @circleci/mcp-server-circleci@latest --help
  • Log detalhado: DEBUG=* npx @circleci/mcp-server-circleci@latest
  • Alternativa com Docker: Tente a instalação via Docker se o npx falhar consistentemente

Ainda precisa de ajuda?

  1. Verifique as GitHub Issues para problemas semelhantes
  2. Inclua seu sistema operacional, versão do Node e IDE ao relatar problemas
  3. Compartilhe mensagens de erro relevantes do console da IDE

Telemetria

O servidor suporta métricas OpenTelemetry para rastrear o uso das ferramentas. As métricas são exportadas, a menos que você defina DISABLE_TELEMETRY=true. Em implantações remotas, as métricas usam o mesmo token da requisição (PAT por usuário ou PAT compartilhado do servidor).

MétricaDescrição
circleci.mcp.tool.invocationsContagem de invocações da ferramenta
circleci.mcp.tool.duration_msTempo de execução em ms
circleci.mcp.tool.errorsContagem de erros

Desenvolvimento

Primeiros Passos

  1. Clone o repositório:

    git clone https://github.com/CircleCI-Public/mcp-server-circleci.git
    cd mcp-server-circleci
    
  2. Instale as dependências:

    pnpm install
    
  3. Compile o projeto:

    pnpm build
    

Compilando o Contêiner Docker

Você pode compilar o contêiner Docker localmente usando:

docker build -t circleci:mcp-server-circleci .

Isso criará uma imagem Docker marcada como circleci:mcp-server-circleci que você pode usar com qualquer cliente MCP.

Modo stdio local (desenvolvedor único, token no cliente):

docker run --rm -i \
  -e CIRCLECI_TOKEN=your-circleci-token \
  -e CIRCLECI_BASE_URL=https://circleci.com \
  circleci/mcp-server-circleci

Modo remoto (servidor centralizado para uma equipe): consulte Self-Managed Remote MCP Server.

Desenvolvimento com o MCP Inspector

A maneira mais fácil de iterar no MCP Server é usando o MCP inspector. Você pode saber mais sobre o MCP inspector em https://modelcontextprotocol.io/docs/tools/inspector

  1. Inicie o servidor de desenvolvimento:

    pnpm watch # Keep this running in one terminal
    
  2. Em um terminal separado, inicie o inspector:

    pnpm inspector
    
  3. Configure o ambiente:

    • Adicione seu CIRCLECI_TOKEN à seção Environment Variables na interface do inspector
    • O token precisa de acesso de leitura aos seus projetos do CircleCI
    • Opcionalmente, defina sua URL Base do CircleCI (o padrão é https://circleci.com)

Testes

  • Execute a suíte de testes:

    pnpm test
    
  • Execute os testes em modo watch durante o desenvolvimento:

    pnpm test:watch
    

Para diretrizes de contribuição mais detalhadas, consulte CONTRIBUTING.md