CircleCI

oficial

Permite que los Agentes de IA corrijan fallos de compilación de CircleCI.

¿Qué puedes hacer con CircleCI MCP?

  • Validar configuración de CircleCI — Pide validar tu .circleci/config.yml para errores de sintaxis y semántica mediante config_helper.
  • Obtener estado del pipeline — Comprueba el estado del último pipeline para una rama con get_latest_pipeline_status.
  • Disparar y volver a ejecutar pipelines — Inicia un nuevo pipeline con run_pipeline o vuelve a ejecutar un workflow desde el inicio o desde un trabajo fallido mediante rerun_workflow.
  • Investigar fallos de compilación — Recupera registros de fallos detallados con get_build_failure_logs y resultados de pruebas mediante get_job_test_results.
  • Encontrar pruebas inestables — Identifica pruebas inestables analizando el historial de ejecución de pruebas usando find_flaky_tests.
  • Analizar uso y costos — Descarga datos de uso con download_usage_api_data y encuentra clases de recursos subutilizadas mediante find_underused_resource_classes.

Documentación

[!IMPORTANT] Este paquete está obsoleto. Por favor, migra.

@circleci/mcp-server-circleci ya no recibe nuevas funcionalidades. Usa el servidor MCP alojado de CircleCI o el MCP CLI de CircleCI en su lugar; consulta la visión general de MCP de CircleCI.

Este repositorio será archivado. Las versiones existentes siguen siendo instalables desde npm, pero no se recomienda ejecutar un servidor sin mantenimiento que tenga un Token de API Personal de CircleCI.

Si estás ejecutando el transporte remoto autogestionado (start=remote), migra primero: el servidor alojado es su reemplazo directo y elimina la necesidad de operar un servicio orientado a la red que gestione el token de tu organización.

Servidor MCP de CircleCI

License: Apache 2.0 CircleCI npm

El Model Context Protocol (MCP) es un protocolo nuevo y estandarizado para gestionar el contexto entre modelos de lenguaje grandes (LLMs) y sistemas externos. En este repositorio, proporcionamos un Servidor MCP para CircleCI.

Usa Cursor, Windsurf, Copilot, Claude, o cualquier cliente compatible con MCP para interactuar con CircleCI usando lenguaje natural, sin salir de tu IDE.

Herramientas

HerramientaDescripción
config_helperValida y obtén orientación para tu configuración de CircleCI
download_usage_api_dataDescarga datos de uso desde la API de Uso de CircleCI
find_flaky_testsIdentifica pruebas inestables analizando el historial de ejecución de pruebas
find_underused_resource_classesEncuentra trabajos con recursos de cómputo infrautilizados
get_build_failure_logsRecupera registros detallados de fallos de las compilaciones de CircleCI
get_job_test_resultsRecupera metadatos y resultados de pruebas para trabajos de CircleCI
get_latest_pipeline_statusObtén el estado de la última canalización para una rama
list_artifactsEnumera los artefactos producidos por un trabajo de CircleCI
list_component_versionsEnumera todas las versiones de un componente de CircleCI
list_followed_projectsEnumera todos los proyectos de CircleCI que sigues
rerun_workflowVuelve a ejecutar un flujo de trabajo desde el inicio o desde el trabajo fallido
run_pipelineActiva la ejecución de una canalización
run_rollback_pipelineActiva una reversión para un proyecto

Instalación

Despliegue centralizado/para equipos: Para ejecutar un servidor remoto compartido para tu organización (Kubernetes, Docker, etc.) con tokens de CircleCI por desarrollador o compartidos, consulta Servidor MCP Remoto Autogestionado.

Cursor

Requisitos previos:

Usando NPX en un Servidor MCP local

Añade lo siguiente a la configuración MCP de tu 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 es opcional, requerido solo para clientes on-premise. MAX_MCP_OUTPUT_LENGTH es opcional: longitud máxima de salida para las respuestas MCP (valor por defecto: 50000).

Usando Docker en un Servidor MCP local

Añade lo siguiente a la configuración MCP de tu 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 un Servidor MCP Remoto Autogestionado

Consulta Servidor MCP Remoto Autogestionado. Usa la configuración de cliente por usuario y añádela a la configuración MCP de tu Cursor (Cursor Settings → MCP).

VS Code

Requisitos previos:

Usando NPX en un Servidor MCP local

Añade lo siguiente a .vscode/mcp.json en tu proyecto:

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

💡 Las entradas se solicitan en el primer inicio del servidor y luego se almacenan de forma segura por VS Code.

Usando Docker en un Servidor MCP local

Añade lo siguiente a .vscode/mcp.json en tu proyecto:

{
  "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 un Servidor MCP Remoto Autogestionado

Consulta Servidor MCP Remoto Autogestionado. Usa la configuración de cliente por usuario en .vscode/mcp.json.

Claude Desktop

Requisitos previos:

Usando NPX en un Servidor MCP local

Añade lo siguiente a tu 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 en un Servidor MCP local

Añade lo siguiente a tu 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 un Servidor MCP Remoto Autogestionado

Consulta Servidor MCP Remoto Autogestionado. Crea un script envolvente como se muestra en Clientes de escritorio y CLI de Claude, luego apunta tu claude_desktop_config.json hacia él.

Para encontrar o crear tu archivo de configuración, abre la configuración de Claude Desktop, haz clic en Developer en la barra lateral izquierda, luego haz clic en Edit Config. El archivo de configuración se encuentra en:

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

Para más información: https://modelcontextprotocol.io/quickstart/user

Claude Code

Requisitos previos:

Usando NPX en un Servidor MCP local

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

Usando Docker en un Servidor MCP 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 un Servidor MCP Remoto Autogestionado

Consulta Servidor MCP Remoto Autogestionado y la configuración del cliente Claude Code allí.

Windsurf

Requisitos previos:

Usando NPX en un Servidor MCP local

Añade lo siguiente a tu mcp_config.json de 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 en un Servidor MCP local

Añade lo siguiente a tu mcp_config.json de 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 un Servidor MCP Remoto Autogestionado

Consulta Servidor MCP Remoto Autogestionado. Usa la configuración de cliente por usuario en tu mcp_config.json de Windsurf.

Para más información: https://docs.windsurf.com/windsurf/mcp

Amazon Q Developer CLI

Requisitos previos:

La configuración del cliente MCP en Amazon Q Developer se almacena en formato JSON en un archivo llamado mcp.json. Se admiten dos niveles de configuración:

  • Global: ~/.aws/amazonq/mcp.json — se aplica a todos los espacios de trabajo
  • Espacio de trabajo: .amazonq/mcp.json — específico para el espacio de trabajo actual

Si ambos archivos existen, sus contenidos se fusionan. En caso de conflicto, la configuración del espacio de trabajo tiene prioridad.

Usando NPX en un Servidor MCP local

Edita ~/.aws/amazonq/mcp.json o crea .amazonq/mcp.json con lo siguiente:

{
  "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 un Servidor MCP Remoto Autogestionado

Consulta Servidor MCP Remoto Autogestionado. Usa un script envolvente como se muestra en Clientes de escritorio y CLI de Claude, luego regístralo con q mcp add.

Amazon Q Developer en el IDE

Requisitos previos:

Usando NPX en un Servidor MCP local

Edita ~/.aws/amazonq/mcp.json o crea .amazonq/mcp.json con lo siguiente:

{
  "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 un Servidor MCP Remoto Autogestionado

Consulta Servidor MCP Remoto Autogestionado. Usa un script envolvente como se muestra en Clientes de escritorio y CLI de Claude, luego agrégalo a través de la interfaz de usuario de configuración MCP:

  1. Accede a la interfaz de usuario de configuración MCP
  2. Elige el símbolo +
  3. Selecciona el alcance: global o local
  4. Introduce un nombre (ej. circleci-remote-mcp)
  5. Selecciona el protocolo de transporte: stdio
  6. Introduce la ruta del comando para tu script
  7. Haz clic en Save
Smithery

Para instalar el Servidor MCP de CircleCI para Claude Desktop automáticamente a través de Smithery:

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

Servidor MCP Remoto Autogestionado

Ejecuta el servidor MCP de forma centralizada (por ejemplo, en Kubernetes o Docker) para que tu equipo comparta una única implementación. Elige cómo se autentican los desarrolladores:

Elige un modo de despliegue

ModoCuándo usarloConfiguración del servidorConfiguración del clienteTraza de auditoría de CircleCI
Tokens por usuario (recomendado)Equipos con Tokens de API Personal respaldados por SSOREQUIRE_REQUEST_TOKEN=true, sin PAT de servidorCada desarrollador envía su PATPor desarrollador
Token compartido (interino)Despliegue rápido, identidad de servicio único aceptableCIRCLECI_TOKEN en el servidor, REQUIRE_REQUEST_TOKEN=false (exclusión explícita)No se necesita encabezado de autenticaciónIdentidad compartida única

Seguridad: La autenticación de solicitudes está activada por defecto en modo remoto. El modo de token compartido la deshabilita (REQUIRE_REQUEST_TOKEN=false), lo que permite que cualquier llamante actúe como la identidad CIRCLECI_TOKEN del servidor sin credenciales, incluyendo la activación de canalizaciones con configuración arbitraria. Habilítalo solo en una red de total confianza; de lo contrario, prefiere los tokens por usuario. Terminar TLS en un ingress proporciona cifrado, no autenticación.

Debido a que esa combinación no es segura en una interfaz pública, el servidor se niega a iniciar cuando REQUIRE_REQUEST_TOKEN=false se combina con una dirección de enlace que no sea de bucle local, a menos que aceptes explícitamente el riesgo con MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESS=true. La comprobación de Host/Origin no es un sustituto de la autenticación; consulta Protección contra rebote de DNS a continuación.

1. Despliega el servidor

Ambos modos usan el modo HTTP remoto (start=remote). Publica el puerto 8000 (o el puerto que elijas).

Tokens por usuario (recomendado): acceso a través de mcp-remote desde localhost:

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

Tokens por usuario (recomendado): acceso a través de mcp-remote desde un nombre de host 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 compartido (interino): acceso a través de mcp-remote desde un nombre de host público:

Debido a que este modo sirve el PAT de la organización a cualquier llamante sin credencial, debe ejecutarse solo donde el puerto publicado sea inalcanzable desde redes no confiables, y debes reconocerlo explícitamente o el servidor se negará 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

Prefiere poner autenticación frente al puerto en su lugar (un ingress que requiera SSO, mTLS, o una clave API), o cambia a tokens por usuario arriba.

Variables de entorno:

VariableDescripción
start=remoteInicia el servidor MCP HTTP+SSE en lugar de stdio
portPuerto de escucha dentro del contenedor (predeterminado: 8000)
REQUIRE_REQUEST_TOKENRechaza solicitudes sin cabecera Authorization: Bearer o Circle-Token. Por defecto es obligatoria; establece REQUIRE_REQUEST_TOKEN=false para permitir solicitudes no autenticadas (modo de token compartido)
CIRCLECI_TOKENPAT compartido de respaldo para todas las solicitudes cuando no se envían cabeceras por usuario
CIRCLECI_BASE_URLOpcional: solo es obligatorio para on-prem (predeterminado: https://circleci.com)
DISABLE_TELEMETRY=trueExcluirse de la exportación de métricas de uso
MCP_ALLOWED_HOSTSLista separada por comas de valores adicionales de cabecera Host permitidos (p. ej. my-mcp.example.com,my-mcp.example.com:443). Los nombres de host de loopback siempre se permiten. Obligatorio para cualquier despliegue que no sea de loopback.
MCP_ALLOWED_ORIGINSLista separada por comas de valores adicionales de cabecera Origin permitidos (p. ej. https://my-app.example.com). Los orígenes de loopback siempre se permiten. Solo es necesario cuando un navegador llega directamente a este servidor (no a través de mcp-remote).
MCP_BIND_HOSTInterfaz de red a la que vincularse (predeterminado: 0.0.0.0). Establécelo en 127.0.0.1 para restringir solo a loopback (no compatible con el mapeo de puertos -p de Docker).
MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESSObligatorio (=true) para iniciar con REQUIRE_REQUEST_TOKEN=false en una dirección de enlace que no sea de loopback. Reconoce que cualquier par que pueda alcanzar el puerto actúa como la identidad CIRCLECI_TOKEN del servidor sin credencial. No tiene efecto cuando se exigen tokens de solicitud.
MCP_FILE_OUTPUT_ROOTSLista separada por comas de directorios adicionales que las herramientas de lectura/escritura de archivos pueden usar (p. ej. /srv/reports,/data/exports). El directorio de trabajo, el directorio personal y el directorio temporal siempre están permitidos. Consulta la nota a continuación.

Ubicaciones de salida de archivos (aplica tanto a transportes stdio como remotos): Las herramientas que aceptan una ruta de sistema de archivos — get_build_failure_logs (outputDir), download_usage_api_data (outputDir) y find_underused_resource_classes (csvFilePath) — solo pueden leer y escribir dentro del directorio de trabajo del servidor, el directorio personal del usuario y el directorio temporal del sistema. Dentro de esas raíces, se rechazan los directorios de configuración ocultos (~/.ssh, ~/.aws, ~/.config, .git, …), node_modules y los directorios de launch-agent, así como los enlaces simbólicos que resuelven fuera de las raíces permitidas. Los directorios del sistema (/etc, /usr, /bin, /System, /Library, %SystemRoot%, …) se rechazan incondicionalmente y no se pueden volver a habilitar. Los archivos de salida nunca se escriben a través de un enlace simbólico.

Si tu checkout se encuentra fuera de esas raíces — /workspace en un contenedor, /srv, /opt, un volumen secundario como /Volumes/work — establece MCP_FILE_OUTPUT_ROOTS a ese directorio; de lo contrario, esas rutas se rechazan. Para un servidor stdio, el directorio de trabajo suele ser ya la raíz del proyecto, por lo que no se necesita configuración. Esto es más relevante para el transporte remoto, donde las rutas provienen de clientes de red y no del usuario local.

Protección contra reenlace de DNS (no es autenticación): El transporte remoto valida la cabecera Host en cada solicitud /mcp. Por defecto solo se aceptan direcciones de loopback (localhost, 127.0.0.1, [::1]). Los despliegues públicos deben establecer MCP_ALLOWED_HOSTS al nombre de host que usan los clientes, o todas las solicitudes /mcp recibirán 403 Forbidden. El endpoint de comprobación de salud /ping no está protegido, por lo que las sondas del balanceador de carga siguen funcionando independientemente de Host.

La cabecera Origin (enviada por los navegadores) también se valida cuando está presente. Los clientes que no son navegadores, como mcp-remote, nunca envían Origin, por lo que esta comprobación no les afecta.

Esta comprobación no es un control de acceso y no debe usarse como tal. Ambas cabeceras las elige quien llama, por lo que cualquier cliente que no sea un navegador — curl, un script, un socket en bruto — puede enviar un Host permitido y omitir Origin para cumplirla. Su único propósito es evitar que un navegador sea dirigido al servidor mediante DNS controlado por un atacante, que es la amenaza de reenlace de DNS. Autenticar a quienes llaman es trabajo de REQUIRE_REQUEST_TOKEN (o de un proxy autenticador delante del puerto). Exigir una cabecera Origin rompería todos los clientes CLI legítimos sin detener a ningún atacante.

Detrás de un proxy inverso: Si tu proxy reescribe Host a la dirección del backend (el comportamiento predeterminado de nginx), añade proxy_set_header Host $host; para pasar el nombre de host original y luego establece MCP_ALLOWED_HOSTS a ese nombre de host público. Alternativamente, establece MCP_ALLOWED_HOSTS al nombre de host que el proxy reenvíe.

El servidor acepta tokens por solicitud mediante:

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

Si un cliente envía un token de cabecera, este tiene prioridad sobre CIRCLECI_TOKEN en el servidor.

Las métricas de telemetría registradas durante una solicitud se exportan usando el mismo token que esa solicitud.

2. Configurar clientes

La mayoría de los clientes MCP solo admiten procesos locales (stdio). Usa mcp-remote, un puente de terceros de stdio a HTTP, para conectarlos a tu servidor remoto.

Esquema de URL: Usa http://localhost:8000/mcp con --allow-http para pruebas locales. En producción, termina TLS en tu ingress/balanceador de carga y usa https://your-host/mcp sin --allow-http.

Windows: Evita espacios alrededor de los dos puntos en los valores de --header. Pon el valor completo de Bearer <token> en una variable de entorno.

Seguridad: Los ejemplos usan npx por comodidad. Para producción o despliegues en equipo, fija una versión concreta en tu configuración MCP (por ejemplo mcp-remote@0.1.38 en lugar de mcp-remote). No uses versiones por debajo de 0.1.16 (CVE-2025-6514).

Configuración de cliente: tokens por usuario

Cada desarrollador envía su propio token personal de API de CircleCI en cada solicitud:

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

Reemplaza http://localhost:8000/mcp con la URL del servidor de tu equipo. Cursor y VS Code admiten indicaciones de ${input:...}; otros clientes pueden establecer AUTH_HEADER directamente.

Configuración de cliente: token compartido

Cuando el servidor tiene CIRCLECI_TOKEN establecido y se inicia con REQUIRE_REQUEST_TOKEN=false (la autenticación de solicitudes está activada por defecto y debe desactivarse explícitamente, y un enlace que no sea de loopback requiere además MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESS=true), los clientes no necesitan enviar un token:

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

Clientes de Claude Desktop y CLI

Crea un script envoltorio (p. ej. 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}"

Hazlo ejecutable (chmod +x circleci-remote-mcp.sh) y luego haz referencia a él desde tu configuración 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}"

Omite --header y AUTH_HEADER cuando uses un servidor de token compartido.

3. Verificar el despliegue

# 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"}}}'

Demo

Míralo en acción

Ejemplo: "Encuentra el último pipeline fallido en mi rama y obtén los registros" — consulta la wiki para más ejemplos.

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

Detalles de las herramientas

config_helper

Ayuda con las tareas de configuración de CircleCI proporcionando orientación y validación.

  • Valida tu .circleci/config.yml en busca de errores de sintaxis y semánticos
  • Proporciona resultados de validación detallados y recomendaciones de configuración
  • Ejemplo: "Valida mi config de CircleCI"
download_usage_api_data

Descarga datos de uso de la API de uso de CircleCI para una organización determinada. Acepta entrada de fechas flexible (p. ej., "marzo de 2025" o "el mes pasado"). Función solo para cloud.

Opción 1: Inicia un nuevo trabajo de exportación proporcionando:

  • orgId, startDate, endDate (máx. 32 días), outputDir

Opción 2: Comprueba/descarga un trabajo de exportación existente proporcionando:

  • orgId, jobId, outputDir

Devuelve un archivo CSV con los datos de uso de CircleCI para el período de tiempo especificado.

[!NOTE] Los datos de uso se pueden introducir en la herramienta find_underused_resource_classes para el análisis de optimización de costes.

find_flaky_tests

Identifica tests inestables (flaky) en tu proyecto de CircleCI analizando el historial de ejecución de tests. Aprovecha la función de detección de tests inestables de CircleCI.

Esta herramienta se puede usar de tres maneras:

  1. Usando el slug del proyecto (recomendado):

    • Usa primero list_followed_projects para obtener tus proyectos y luego:
    • Ejemplo: "Obtén los tests inestables de mi-proyecto"
  2. Usando la URL del proyecto de CircleCI:

  3. Usando el contexto del proyecto local:

    • Funciona desde tu espacio de trabajo local proporcionando la raíz del espacio de trabajo y la URL remota de git
    • Ejemplo: "Encuentra tests inestables en mi proyecto actual"

Modos de salida:

  • Texto (predeterminado): Devuelve los detalles de los tests inestables en formato de texto
  • Archivo (requiere la variable de entorno FILE_OUTPUT_DIRECTORY): Crea un directorio con los detalles de los tests inestables
find_underused_resource_classes

Analiza un archivo CSV de datos de uso de CircleCI para encontrar trabajos con uso medio o máximo de CPU/RAM por debajo de un umbral determinado (predeterminado: 40%).

Proporciona un archivo CSV obtenido de download_usage_api_data.

Devuelve una lista en markdown de trabajos poco utilizados organizados por proyecto y workflow — útil para identificar oportunidades de optimización de costes.

get_build_failure_logs

Recupera registros de error detallados de los builds de CircleCI. Esta herramienta se puede usar de tres maneras:

  1. Usando el slug del proyecto y la rama (recomendado):

    • Usa primero list_followed_projects para obtener tus proyectos y luego:
    • Ejemplo: "Obtén los errores de build de mi-proyecto en la rama main"
  2. Usando URLs de CircleCI:

  3. Usando el contexto del proyecto local:

    • Funciona desde tu espacio de trabajo local proporcionando la raíz del espacio de trabajo, la URL remota de git y el nombre de la rama
    • Ejemplo: "Encuentra el último pipeline fallido en mi rama actual"

La herramienta devuelve registros formateados que incluyen:

  • Nombres de los trabajos
  • Detalles de ejecución paso a paso
  • Mensajes de error y contexto
get_job_test_results

Recupera metadatos de tests para trabajos de CircleCI, lo que te permite analizar los resultados de los tests sin salir de tu IDE. Esta herramienta se puede usar de tres maneras:

  1. Usando el slug del proyecto y la rama (recomendado):

    • Ejemplo: "Obtén los resultados de los tests de mi-proyecto en la rama main"
  2. Usando la URL de CircleCI:

    • URL del trabajo: https://app.circleci.com/pipelines/github/org/repo/123/workflows/abc-def/jobs/789
    • URL del workflow: https://app.circleci.com/pipelines/github/org/repo/123/workflows/abc-def
    • URL del pipeline: https://app.circleci.com/pipelines/github/org/repo/123
  3. Usando el contexto del proyecto local:

    • Funciona desde tu espacio de trabajo local proporcionando la raíz del espacio de trabajo, la URL remota de git y el nombre de la rama

La herramienta devuelve:

  • Resumen de todos los tests (total, correctos, fallidos)
  • Información detallada de los tests fallidos: nombre, clase, archivo, mensaje de error, duración
  • Lista de tests correctos con tiempos
  • Filtro por resultado del test

[!NOTE] Los metadatos de tests deben configurarse en tu archivo de configuración de CircleCI. Consulta Collect Test Data para obtener instrucciones de configuración.

get_latest_pipeline_status Recupera el estado de la última pipeline para una rama determinada. Esta herramienta puede utilizarse de tres formas:
  1. Usando Project Slug y rama (recomendado):

    • Ejemplo: "Obtén el estado de la última pipeline de mi-proyecto en la rama main"
  2. Usando la URL del proyecto de CircleCI:

  3. Usando el contexto del proyecto local:

    • Funciona desde tu espacio de trabajo local proporcionando la raíz del workspace, la URL remota de git y el nombre de la rama

Ejemplo de salida:

---
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 la lista de artefactos producidos por un job de CircleCI. Esta herramienta puede utilizarse de tres formas:

  1. Usando Project Slug y rama (recomendado):

    • Primero usa list_followed_projects para obtener tus proyectos, luego:
    • Ejemplo: "Lista los artefactos de mi-proyecto en la rama main"
  2. Usando la URL de CircleCI:

    • URL del job: https://app.circleci.com/pipelines/gh/organization/project/123/workflows/abc-def/jobs/789
    • URL del workflow: https://app.circleci.com/pipelines/gh/organization/project/123/workflows/abc-def
    • URL de la pipeline: https://app.circleci.com/pipelines/gh/organization/project/123
  3. Usando el contexto del proyecto local:

    • Funciona desde tu espacio de trabajo local proporcionando la raíz del workspace, la URL remota de git y el nombre de la rama

Útil para:

  • Encontrar URL de descarga de artefactos de compilación (binarios, informes, registros)
  • Verificar qué artefactos se produjeron en una ejecución de pipeline
list_component_versions

Lista todas las versiones de un componente específico de CircleCI en un entorno. Incluye estado de despliegue, información del commit y marcas de tiempo.

La herramienta te pedirá que selecciones el componente y el entorno si no se proporcionan.

Útil para:

  • Identificar qué versión está actualmente en producción
  • Seleccionar versiones objetivo para operaciones de rollback
  • Obtener detalles del despliegue (pipeline, workflow, job)
list_followed_projects

Lista todos los proyectos que el usuario sigue en CircleCI.

  • Muestra todos los proyectos a los que tienes acceso con su projectSlug
  • Ejemplo: "Lista mis proyectos de CircleCI"

Ejemplo de salida:

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

[!NOTE] El projectSlug (no el nombre del proyecto) es obligatorio para muchas otras herramientas de CircleCI.

rerun_workflow

Vuelve a ejecutar un workflow desde su inicio o desde el job que falló.

Devuelve el ID del workflow recién creado y un enlace para monitorearlo.

run_pipeline

Dispara la ejecución de una pipeline. Esta herramienta puede utilizarse de tres formas:

  1. Usando Project Slug y rama (recomendado):

    • Ejemplo: "Ejecuta la pipeline de mi-proyecto en la rama main"
  2. Usando la URL de CircleCI:

  3. Usando el contexto del proyecto local:

    • Funciona desde tu espacio de trabajo local proporcionando la raíz del workspace, la URL remota de git y el nombre de la rama

La herramienta devuelve un enlace para monitorear la ejecución de la pipeline.

run_rollback_pipeline

Dispara un rollback para un proyecto de CircleCI. La herramienta te guía de forma interactiva a través de:

  1. Selección de proyecto — lista los proyectos seguidos para que elijas
  2. Selección de entorno — lista los entornos disponibles (se selecciona automáticamente si solo hay uno)
  3. Selección de componente — lista los componentes disponibles (se selecciona automáticamente si solo hay uno)
  4. Selección de versión — muestra las versiones disponibles; seleccionas el objetivo del rollback
  5. Detección del modo de rollback — verifica si hay una pipeline de rollback configurada
  6. Ejecutar el rollback — dos opciones:
    • Rollback de pipeline: dispara la pipeline de rollback
    • Reejecución de workflow: vuelve a ejecutar un workflow anterior usando su ID de workflow
  7. Confirmación — resume y confirma antes de la ejecución

Solución de problemas

Soluciones rápidas

Los problemas más comunes:

  1. Limpia las cachés de paquetes:

    npx clear-npx-cache
    npm cache clean --force
    
  2. Forzar la versión más reciente: Agrega @latest a tu configuración:

    "args": ["-y", "@circleci/mcp-server-circleci@latest"]
    
  3. Reinicia tu IDE por completo (no solo recargues la ventana)

Problemas de autenticación
  • Errores de token no válido: Verifica tu CIRCLECI_TOKEN en Personal API Tokens
  • Errores de permisos: Asegúrate de que el token tenga acceso de lectura a tus proyectos
  • Variables de entorno que no se cargan: Prueba con echo $CIRCLECI_TOKEN (Mac/Linux) o echo %CIRCLECI_TOKEN% (Windows)
Problemas de conexión y red
  • URL base: Confirma que CIRCLECI_BASE_URL sea https://circleci.com
  • Redes corporativas: Configura el proxy de npm si estás detrás de un firewall
  • Bloqueo por firewall: Verifica si el software de seguridad bloquea las descargas de paquetes
Requisitos del sistema
  • Versión de Node.js: Asegúrate de tener >= 18.0.0 con node --version
  • Actualizar Node.js: Considera la última LTS si tienes problemas de compatibilidad
  • Gestor de paquetes: Verifica que npm/pnpm funcione: npm --version
Problemas específicos del IDE
  • Ubicación del archivo de configuración: Vuelve a verificar la ruta para tu sistema operativo
  • Errores de sintaxis: Valida la sintaxis JSON en tu archivo de configuración
  • Registros de consola: Revisa la consola de desarrollador del IDE para ver errores específicos
  • Prueba con otro IDE: Prueba en otro editor compatible para aislar el problema
Problemas de procesos

Procesos bloqueados: mata los procesos MCP existentes:

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

# Windows:
taskkill /f /im node.exe

Conflictos de puerto: Reinicia tu IDE si la conexión parece bloqueada.

Depuración avanzada
  • Prueba el paquete directamente: npx @circleci/mcp-server-circleci@latest --help
  • Registro detallado (verbose): DEBUG=* npx @circleci/mcp-server-circleci@latest
  • Alternativa con Docker: Prueba la instalación mediante Docker si npx falla de forma consistente

¿Aún necesitas ayuda?

  1. Revisa GitHub Issues para problemas similares
  2. Incluye tu sistema operativo, versión de Node e IDE al informar problemas
  3. Comparte los mensajes de error relevantes de la consola del IDE

Telemetría

El servidor admite métricas de OpenTelemetry para el seguimiento del uso de herramientas. Las métricas se exportan a menos que establezcas DISABLE_TELEMETRY=true. En implementaciones remotas, las métricas usan el mismo token que la solicitud (PAT por usuario o PAT compartido del servidor).

MétricaDescripción
circleci.mcp.tool.invocationsRecuento de invocaciones de herramientas
circleci.mcp.tool.duration_msTiempo de ejecución en ms
circleci.mcp.tool.errorsRecuento de errores

Desarrollo

Primeros pasos

  1. Clona el repositorio:

    git clone https://github.com/CircleCI-Public/mcp-server-circleci.git
    cd mcp-server-circleci
    
  2. Instala las dependencias:

    pnpm install
    
  3. Compila el proyecto:

    pnpm build
    

Compilar el contenedor Docker

Puedes compilar el contenedor Docker localmente usando:

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

Esto creará una imagen Docker etiquetada como circleci:mcp-server-circleci que puedes usar con cualquier cliente MCP.

Modo stdio local (desarrollador individual, token en el 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 un equipo): consulta Self-Managed Remote MCP Server.

Desarrollo con MCP Inspector

La forma más fácil de iterar en el MCP Server es usar el inspector de MCP. Puedes obtener más información sobre el inspector de MCP en https://modelcontextprotocol.io/docs/tools/inspector

  1. Inicia el servidor de desarrollo:

    pnpm watch # Keep this running in one terminal
    
  2. En una terminal separada, inicia el inspector:

    pnpm inspector
    
  3. Configura el entorno:

    • Agrega tu CIRCLECI_TOKEN a la sección de Variables de Entorno en la interfaz del inspector
    • El token necesita acceso de lectura a tus proyectos de CircleCI
    • Opcionalmente, establece tu URL base de CircleCI (el valor predeterminado es https://circleci.com)

Pruebas

  • Ejecuta la suite de pruebas:

    pnpm test
    
  • Ejecuta las pruebas en modo watch durante el desarrollo:

    pnpm test:watch
    

Para obtener pautas de contribución más detalladas, consulta CONTRIBUTING.md