CircleCI

officiel

Permettre aux agents IA de corriger les échecs de build depuis CircleCI.

Que pouvez-vous faire avec CircleCI MCP ?

  • Valider la configuration — Demandez à l’assistant de valider votre .circleci/config.yml et d’obtenir des conseils sur les erreurs de syntaxe et de sémantique via config_helper.
  • Diagnostiquer les échecs de build — Récupérez les journaux détaillés des échecs d’un build CircleCI avec get_build_failure_logs.
  • Trouver les tests instables — Identifiez les tests instables en analysant l’historique d’exécution des tests d’un projet avec find_flaky_tests.
  • Vérifier l’état du pipeline — Obtenez l’état du dernier pipeline d’une branche avec get_latest_pipeline_status.
  • Relancer les workflows — Relancez un workflow depuis le début ou à partir du job en échec avec rerun_workflow.
  • Déclencher des pipelines — Exécutez un pipeline ou déclenchez le retour arrière d’un projet avec run_pipeline et run_rollback_pipeline.

Documentation

[!IMPORTANT] Ce package est obsolète. Veuillez migrer.

@circleci/mcp-server-circleci ne fait plus l’objet de développements de fonctionnalités. Utilisez le serveur MCP hébergé de CircleCI ou le MCP de CircleCI CLI — consultez la présentation de CircleCI MCP.

Ce dépôt sera archivé. Les versions existantes restent installables depuis npm, mais il est déconseillé d’exécuter un serveur non maintenu qui détient un jeton d’API personnel CircleCI.

Si vous utilisez le transport distant autogéré (start=remote), migrez d’abord : le serveur hébergé le remplace directement et vous évite d’exploiter un service exposé au réseau qui relaie le jeton de votre organisation.

Serveur MCP CircleCI

License: Apache 2.0 CircleCI npm

Le Model Context Protocol (MCP) est un nouveau protocole standardisé permettant de gérer le contexte entre les grands modèles de langage (LLM) et les systèmes externes. Dans ce dépôt, nous fournissons un serveur MCP pour CircleCI.

Utilisez Cursor, Windsurf, Copilot, Claude ou tout client compatible avec MCP pour interagir avec CircleCI en langage naturel, sans quitter votre IDE.

Outils

OutilDescription
config_helperValider votre configuration CircleCI et obtenir des conseils
download_usage_api_dataTélécharger les données d’utilisation depuis l’API Usage de CircleCI
find_flaky_testsIdentifier les tests instables en analysant l’historique de leur exécution
find_underused_resource_classesTrouver les jobs dont les ressources de calcul sont sous-utilisées
get_build_failure_logsRécupérer les journaux détaillés des échecs des builds CircleCI
get_job_test_resultsRécupérer les métadonnées et les résultats des tests des jobs CircleCI
get_latest_pipeline_statusObtenir l’état du dernier pipeline d’une branche
list_artifactsRépertorier les artefacts produits par un job CircleCI
list_component_versionsRépertorier toutes les versions d’un composant CircleCI
list_followed_projectsRépertorier tous les projets CircleCI que vous suivez
rerun_workflowRelancer un workflow depuis le début ou à partir du job en échec
run_pipelineDéclencher l’exécution d’un pipeline
run_rollback_pipelineDéclencher un retour arrière pour un projet

Installation

Déploiement d’équipe / centralisé : Pour exécuter un serveur distant partagé pour votre organisation (Kubernetes, Docker, etc.) avec des jetons CircleCI individuels ou partagés, consultez Serveur MCP distant autogéré.

Cursor

Prérequis :

Utiliser NPX dans un serveur MCP local

Ajoutez ce qui suit à la configuration MCP de 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 est facultatif — requis uniquement pour les clients sur site. MAX_MCP_OUTPUT_LENGTH est facultatif — longueur maximale de sortie des réponses MCP (valeur par défaut : 50000).

Utiliser Docker dans un serveur MCP local

Ajoutez ce qui suit à la configuration MCP de 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"
      }
    }
  }
}

Utiliser un serveur MCP distant autogéré

Consultez Serveur MCP distant autogéré. Utilisez la configuration client par utilisateur et ajoutez-la à la configuration MCP de Cursor (Cursor Settings → MCP).

VS Code

Prérequis :

Utiliser NPX dans un serveur MCP local

Ajoutez ce qui suit à .vscode/mcp.json dans votre projet :

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

💡 Les informations sont demandées au premier démarrage du serveur, puis stockées de manière sécurisée par VS Code.

Utiliser Docker dans un serveur MCP local

Ajoutez ce qui suit à .vscode/mcp.json dans votre projet :

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

Utiliser un serveur MCP distant autogéré

Consultez Serveur MCP distant autogéré. Utilisez la configuration client par utilisateur dans .vscode/mcp.json.

Claude Desktop

Prérequis :

Utiliser NPX dans un serveur MCP local

Ajoutez ce qui suit à votre 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"
      }
    }
  }
}

Utiliser Docker dans un serveur MCP local

Ajoutez ce qui suit à votre 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"
      }
    }
  }
}

Utiliser un serveur MCP distant autogéré

Consultez Serveur MCP distant autogéré. Créez un script wrapper comme indiqué dans Clients Claude Desktop et CLI, puis indiquez son chemin dans votre claude_desktop_config.json.

Pour trouver ou créer votre fichier de configuration, ouvrez les paramètres de Claude Desktop, cliquez sur Developer dans la barre latérale gauche, puis sur Edit Config. Le fichier de configuration se trouve à l’emplacement suivant :

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

Pour en savoir plus : https://modelcontextprotocol.io/quickstart/user

Claude Code

Prérequis :

Utiliser NPX dans un serveur MCP local

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

Utiliser Docker dans un serveur 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

Utiliser un serveur MCP distant autogéré

Consultez Serveur MCP distant autogéré et la configuration du client Claude Code qui s’y trouve.

Windsurf

Prérequis :

Utiliser NPX dans un serveur MCP local

Ajoutez ce qui suit à votre mcp_config.json 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"
      }
    }
  }
}

Utiliser Docker dans un serveur MCP local

Ajoutez ce qui suit à votre mcp_config.json 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"
      }
    }
  }
}

Utiliser un serveur MCP distant autogéré

Consultez Serveur MCP distant autogéré. Utilisez la configuration client par utilisateur dans votre mcp_config.json Windsurf.

Pour en savoir plus : https://docs.windsurf.com/windsurf/mcp

Amazon Q Developer CLI

Prérequis :

La configuration du client MCP dans Amazon Q Developer est stockée au format JSON dans un fichier nommé mcp.json. Deux niveaux de configuration sont pris en charge :

  • Global : ~/.aws/amazonq/mcp.json — s’applique à tous les espaces de travail
  • Espace de travail : .amazonq/mcp.json — propre à l’espace de travail actuel

Si les deux fichiers existent, leur contenu est fusionné. En cas de conflit, la configuration de l’espace de travail est prioritaire.

Utiliser NPX dans un serveur MCP local

Modifiez ~/.aws/amazonq/mcp.json ou créez .amazonq/mcp.json avec le contenu suivant :

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

Utiliser un serveur MCP distant autogéré

Consultez Serveur MCP distant autogéré. Utilisez un script wrapper comme indiqué dans Clients Claude Desktop et CLI, puis enregistrez-le avec q mcp add.

Amazon Q Developer dans l’IDE

Prérequis :

Utiliser NPX dans un serveur MCP local

Modifiez ~/.aws/amazonq/mcp.json ou créez .amazonq/mcp.json avec le contenu suivant :

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

Utiliser un serveur MCP distant autogéré

Consultez Serveur MCP distant autogéré. Utilisez un script wrapper comme indiqué dans Clients Claude Desktop et CLI, puis ajoutez-le via l’interface de configuration MCP :

  1. Accéder à l’interface de configuration MCP
  2. Choisissez le symbole +
  3. Sélectionnez la portée : global ou local
  4. Saisissez un nom (par exemple circleci-remote-mcp)
  5. Sélectionnez le protocole de transport : stdio
  6. Saisissez le chemin de la commande vers votre script
  7. Cliquez sur Save
Smithery

Pour installer automatiquement le serveur MCP CircleCI pour Claude Desktop via Smithery :

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

Serveur MCP distant autogéré

Exécutez le serveur MCP de manière centralisée (par exemple sur Kubernetes ou Docker) afin que votre équipe utilise un déploiement partagé. Choisissez le mode d’authentification des développeurs :

Choisir un mode de déploiement

ModeQuand l’utiliserConfiguration du serveurConfiguration du clientPiste d’audit CircleCI
Jetons par utilisateur (recommandé)Équipes utilisant des jetons d’API personnels associés au SSOREQUIRE_REQUEST_TOKEN=true, aucun PAT sur le serveurChaque développeur transmet son PATPar développeur
Jeton partagé (provisoire)Déploiement rapide, identité de service unique acceptableCIRCLECI_TOKEN sur le serveur, REQUIRE_REQUEST_TOKEN=false (désactivation explicite)Aucun en-tête d’authentification requisIdentité partagée unique

Sécurité : L’authentification des requêtes est activée par défaut en mode distant. Le mode à jeton partagé la désactive (REQUIRE_REQUEST_TOKEN=false), ce qui permet à chaque appelant d’agir sans identifiants sous l’identité CIRCLECI_TOKEN du serveur — y compris de déclencher des pipelines avec une configuration arbitraire. Ne l’activez que sur un réseau auquel vous faites entièrement confiance et privilégiez les jetons par utilisateur dans les autres cas. La terminaison TLS au niveau d’un ingress assure le chiffrement, pas l’authentification.

Comme cette combinaison est dangereuse sur une interface publique, le serveur refuse de démarrer lorsque REQUIRE_REQUEST_TOKEN=false est associé à une adresse de liaison autre que loopback, sauf si vous acceptez explicitement le risque avec MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESS=true. La vérification Host/Origin ne remplace pas l’authentification — consultez la section Protection contre le DNS rebinding ci-dessous.

1. Déployer le serveur

Les deux modes utilisent le mode HTTP distant (start=remote). Publiez le port 8000 (ou le port de votre choix).

Jetons par utilisateur (recommandé) — accès via mcp-remote depuis localhost :

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

Jetons par utilisateur (recommandé) — accès via mcp-remote depuis un nom d’hôte public :

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

Jeton partagé (provisoire) — accès via mcp-remote depuis un nom d’hôte public :

Comme ce mode met le PAT de l’organisation à la disposition de tout appelant sans identifiants, il doit être exécuté uniquement lorsque le port publié est inaccessible depuis les réseaux non fiables, et vous devez le reconnaître explicitement, faute de quoi le serveur refusera de démarrer :

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

Privilégiez plutôt la mise en place d’une authentification devant le port — un ingress exigeant un SSO, mTLS ou une clé API — ou passez aux jetons par utilisateur ci-dessus.

Variables d’environnement :

VariableDescription
start=remoteDémarre le serveur MCP HTTP+SSE au lieu de stdio
portPort d’écoute dans le conteneur (par défaut : 8000)
REQUIRE_REQUEST_TOKENRejette les requêtes sans en-tête Authorization: Bearer ou Circle-Token. Obligatoire par défaut ; définissez REQUIRE_REQUEST_TOKEN=false pour autoriser les requêtes non authentifiées (mode jeton partagé)
CIRCLECI_TOKENPAT de secours partagé pour toutes les requêtes lorsque les en-têtes par utilisateur ne sont pas envoyés
CIRCLECI_BASE_URLFacultatif — requis uniquement pour les installations sur site (par défaut : https://circleci.com)
DISABLE_TELEMETRY=trueDésactive l’export des métriques d’utilisation
MCP_ALLOWED_HOSTSListe séparée par des virgules de valeurs supplémentaires d’en-tête Host autorisées (par ex. my-mcp.example.com,my-mcp.example.com:443). Les noms d’hôte de bouclage sont toujours autorisés. Requis pour tout déploiement hors bouclage.
MCP_ALLOWED_ORIGINSListe séparée par des virgules de valeurs supplémentaires d’en-tête Origin autorisées (par ex. https://my-app.example.com). Les origines de bouclage sont toujours autorisées. Nécessaire uniquement lorsqu’un navigateur accède directement à ce serveur (et non via mcp-remote).
MCP_BIND_HOSTInterface réseau à laquelle se lier (par défaut : 0.0.0.0). Définissez sur 127.0.0.1 pour limiter l’accès au bouclage uniquement (incompatible avec le mappage de ports Docker -p).
MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESSObligatoire (=true) pour démarrer avec REQUIRE_REQUEST_TOKEN=false sur une adresse de liaison hors bouclage. Reconnaît que tout pair pouvant accéder au port agit comme l’identité CIRCLECI_TOKEN du serveur sans identifiant. Sans effet lorsque les jetons de requête sont obligatoires.
MCP_FILE_OUTPUT_ROOTSListe séparée par des virgules de répertoires supplémentaires que les outils de lecture/écriture de fichiers peuvent utiliser (par ex. /srv/reports,/data/exports). Le répertoire de travail, le répertoire personnel et le répertoire temporaire sont toujours autorisés. Voir la remarque ci-dessous.

Emplacements de sortie des fichiers (s’applique aux transports stdio et distants) : Les outils qui acceptent un chemin de système de fichiers — get_build_failure_logs (outputDir), download_usage_api_data (outputDir) et find_underused_resource_classes (csvFilePath) — ne peuvent lire et écrire que dans le répertoire de travail du serveur, le répertoire personnel de l’utilisateur et le répertoire temporaire du système. Dans ces emplacements, les répertoires de configuration masqués (~/.ssh, ~/.aws, ~/.config, .git, …), node_modules et les répertoires des agents de lancement sont refusés, tout comme les liens symboliques pointant en dehors des emplacements autorisés. Les répertoires système (/etc, /usr, /bin, /System, /Library, %SystemRoot%, …) sont toujours refusés et ne peuvent pas être réautorisés. Les fichiers de sortie ne sont jamais écrits via un lien symbolique.

Si votre copie de travail se trouve en dehors de ces emplacements — /workspace dans un conteneur, /srv, /opt, un volume secondaire tel que /Volumes/work — définissez MCP_FILE_OUTPUT_ROOTS sur ce répertoire, sinon ces chemins seront refusés. Pour un serveur stdio, le répertoire de travail est généralement déjà la racine du projet ; aucune configuration n’est donc nécessaire. Cela concerne surtout le transport distant, où les chemins proviennent de clients réseau plutôt que de l’utilisateur local.

Protection contre le DNS rebinding (pas une authentification) : Le transport distant valide l’en-tête Host pour chaque requête /mcp. Par défaut, seules les adresses de bouclage (localhost, 127.0.0.1, [::1]) sont acceptées. Les déploiements publics doivent définir MCP_ALLOWED_HOSTS sur le nom d’hôte utilisé par les clients, sinon toutes les requêtes /mcp recevront 403 Forbidden. Le point de terminaison de vérification d’état /ping n’est pas protégé, afin que les sondes de l’équilibreur de charge continuent de fonctionner, quelle que soit la valeur de Host.

L’en-tête Origin (envoyé par les navigateurs) est également validé lorsqu’il est présent. Les clients non navigateurs tels que mcp-remote n’envoient jamais Origin et ne sont donc pas concernés par cette vérification.

Cette vérification ne constitue pas un contrôle d’accès et ne doit pas être considérée comme telle. Les deux en-têtes sont choisis par l’appelant ; tout client non navigateur — curl, un script, une socket brute — peut donc envoyer un Host autorisé et omettre Origin pour satisfaire cette vérification. Son seul objectif est d’empêcher qu’un navigateur soit dirigé vers le serveur par un DNS contrôlé par un attaquant, ce qui constitue la menace du DNS rebinding. L’authentification des appelants relève de REQUIRE_REQUEST_TOKEN (ou d’un proxy d’authentification placé devant le port). Exiger un en-tête Origin interromprait le fonctionnement de tous les clients CLI légitimes sans arrêter aucun attaquant.

Derrière un proxy inverse : Si votre proxy réécrit Host avec l’adresse du serveur principal (valeur par défaut de nginx), ajoutez proxy_set_header Host $host; pour transmettre le nom d’hôte d’origine, puis définissez MCP_ALLOWED_HOSTS sur ce nom d’hôte public. Vous pouvez également définir MCP_ALLOWED_HOSTS sur le nom d’hôte que le proxy transmet effectivement.

Le serveur accepte les jetons par requête via :

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

Si un client envoie un jeton dans un en-tête, celui-ci prend le pas sur CIRCLECI_TOKEN sur le serveur.

Les métriques de télémétrie enregistrées pendant une requête sont exportées avec le même jeton que celui de cette requête.

2. Configurer les clients

La plupart des clients MCP ne prennent en charge que les processus locaux (stdio). Utilisez mcp-remote, un pont tiers de stdio vers HTTP, pour les connecter à votre serveur distant.

Schéma d’URL : Utilisez http://localhost:8000/mcp avec --allow-http pour les tests locaux. En production, terminez TLS au niveau de votre point d’entrée ou de votre équilibreur de charge et utilisez https://your-host/mcp sans --allow-http.

Windows : Évitez les espaces autour des deux-points dans les valeurs --header. Placez la valeur complète de Bearer <token> dans une variable d’environnement.

Sécurité : Les exemples utilisent npx par commodité. Pour la production ou les déploiements en équipe, épinglez une version précise dans votre configuration MCP (par exemple mcp-remote@0.1.38 au lieu de mcp-remote). N’utilisez pas de versions antérieures à 0.1.16 (CVE-2025-6514).

Configuration du client : jetons par utilisateur

Chaque développeur transmet son propre jeton d’API personnelle CircleCI à chaque requête :

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

Remplacez http://localhost:8000/mcp par l’URL du serveur de votre équipe. Cursor et VS Code prennent en charge les invites ${input:...} ; les autres clients peuvent définir directement AUTH_HEADER.

Configuration du client : jeton partagé

Lorsque le serveur a défini CIRCLECI_TOKEN et est démarré avec REQUIRE_REQUEST_TOKEN=false (l’authentification des requêtes est activée par défaut et doit être explicitement désactivée ; une liaison hors bouclage nécessite également MCP_ALLOW_UNAUTHENTICATED_NETWORK_ACCESS=true), les clients n’ont pas besoin d’envoyer de jeton :

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

Claude Desktop et clients CLI

Créez un script wrapper (par 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}"

Rendez-le exécutable (chmod +x circleci-remote-mcp.sh), puis référencez-le dans votre configuration 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}"

Omettez --header et AUTH_HEADER si vous utilisez un serveur à jeton partagé.

3. Vérifier le déploiement

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

Démo

Voir la démonstration

Exemple : « Trouve le dernier pipeline en échec sur ma branche et récupère les journaux » — consultez le wiki pour d’autres exemples.

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

Détails des outils

config_helper

Aide à effectuer des tâches de configuration CircleCI en fournissant des conseils et une validation.

  • Valide votre .circleci/config.yml pour détecter les erreurs de syntaxe et de sémantique
  • Fournit des résultats de validation détaillés et des recommandations de configuration
  • Exemple : « Valide ma configuration CircleCI »
download_usage_api_data

Télécharge les données d’utilisation de l’API Usage de CircleCI pour une organisation donnée. Accepte des dates exprimées de manière flexible (par ex. « mars 2025 » ou « le mois dernier »). Fonctionnalité réservée au cloud.

Option 1 : Lancez une nouvelle tâche d’export en fournissant :

  • orgId, startDate, endDate (32 jours maximum), outputDir

Option 2 : Vérifiez ou téléchargez une tâche d’export existante en fournissant :

  • orgId, jobId, outputDir

Renvoie un fichier CSV contenant les données d’utilisation de CircleCI pour la période spécifiée.

[!NOTE] Les données d’utilisation peuvent être transmises à l’outil find_underused_resource_classes pour analyser les possibilités d’optimisation des coûts.

find_flaky_tests

Identifie les tests instables dans votre projet CircleCI en analysant l’historique de leur exécution. S’appuie sur la fonctionnalité de détection des tests instables de CircleCI.

Cet outil peut être utilisé de trois façons :

  1. Avec un slug de projet (recommandé) :

    • Utilisez d’abord list_followed_projects pour obtenir vos projets, puis :
    • Exemple : « Trouve les tests instables de my-project »
  2. Avec l’URL d’un projet CircleCI :

  3. Avec le contexte d’un projet local :

    • Fonctionne depuis votre espace de travail local en fournissant la racine de l’espace de travail et l’URL du dépôt Git distant
    • Exemple : « Trouve les tests instables dans mon projet actuel »

Modes de sortie :

  • Texte (par défaut) : Renvoie les détails des tests instables au format texte
  • Fichier (nécessite la variable d’environnement FILE_OUTPUT_DIRECTORY) : Crée un répertoire contenant les détails des tests instables
find_underused_resource_classes

Analyse un fichier CSV de données d’utilisation CircleCI pour trouver les tâches dont l’utilisation moyenne ou maximale du processeur ou de la mémoire vive est inférieure à un seuil donné (40 % par défaut).

Fournissez un fichier CSV obtenu avec download_usage_api_data.

Renvoie une liste Markdown des tâches sous-utilisées, classées par projet et par workflow — utile pour repérer les possibilités d’optimisation des coûts.

get_build_failure_logs

Récupère les journaux détaillés des échecs de compilation CircleCI. Cet outil peut être utilisé de trois façons :

  1. Avec un slug de projet et une branche (recommandé) :

    • Utilisez d’abord list_followed_projects pour obtenir vos projets, puis :
    • Exemple : « Récupère les échecs de compilation de my-project sur la branche main »
  2. Avec des URL CircleCI :

  3. Avec le contexte d’un projet local :

    • Fonctionne depuis votre espace de travail local en fournissant la racine de l’espace de travail, l’URL du dépôt Git distant et le nom de la branche
    • Exemple : « Trouve le dernier pipeline en échec sur ma branche actuelle »

L’outil renvoie des journaux mis en forme, notamment :

  • Noms des tâches
  • Détails d’exécution étape par étape
  • Messages d’échec et contexte
get_job_test_results

Récupère les métadonnées des tests des tâches CircleCI, ce qui vous permet d’analyser les résultats des tests sans quitter votre IDE. Cet outil peut être utilisé de trois façons :

  1. Avec un slug de projet et une branche (recommandé) :

    • Exemple : « Récupère les résultats des tests de my-project sur la branche main »
  2. Avec une URL CircleCI :

    • URL de tâche : https://app.circleci.com/pipelines/github/org/repo/123/workflows/abc-def/jobs/789
    • URL de workflow : https://app.circleci.com/pipelines/github/org/repo/123/workflows/abc-def
    • URL de pipeline : https://app.circleci.com/pipelines/github/org/repo/123
  3. Avec le contexte d’un projet local :

    • Fonctionne depuis votre espace de travail local en fournissant la racine de l’espace de travail, l’URL du dépôt Git distant et le nom de la branche

L’outil renvoie :

  • Un récapitulatif de tous les tests (nombre total, réussis, échoués)
  • Des informations détaillées sur les tests échoués : nom, classe, fichier, message d’erreur, durée
  • La liste des tests réussis avec leur durée
  • Un filtre par résultat de test

[!NOTE] Les métadonnées des tests doivent être configurées dans votre configuration CircleCI. Consultez Collecter les données de test pour les instructions de configuration.

get_latest_pipeline_status Récupère l’état du dernier pipeline pour une branche donnée. Cet outil peut être utilisé de trois façons :
  1. Avec le slug du projet et la branche (recommandé) :

    • Exemple : « Obtenir l’état du dernier pipeline de my-project sur la branche main »
  2. Avec l’URL du projet CircleCI :

  3. Avec le contexte du projet local :

    • Fonctionne depuis votre espace de travail local en fournissant la racine de l’espace de travail, l’URL du dépôt git et le nom de la branche

Exemple de sortie :

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

Récupère la liste des artefacts produits par un job CircleCI. Cet outil peut être utilisé de trois façons :

  1. Avec le slug du projet et la branche (recommandé) :

    • Utilisez d’abord list_followed_projects pour obtenir vos projets, puis :
    • Exemple : « Lister les artefacts de my-project sur la branche main »
  2. Avec une URL CircleCI :

    • URL du job : https://app.circleci.com/pipelines/gh/organization/project/123/workflows/abc-def/jobs/789
    • URL du workflow : https://app.circleci.com/pipelines/gh/organization/project/123/workflows/abc-def
    • URL du pipeline : https://app.circleci.com/pipelines/gh/organization/project/123
  3. Avec le contexte du projet local :

    • Fonctionne depuis votre espace de travail local en fournissant la racine de l’espace de travail, l’URL du dépôt git et le nom de la branche

Utile pour :

  • Trouver les URL de téléchargement des artefacts de build (binaires, rapports, journaux)
  • Vérifier quels artefacts ont été produits par une exécution de pipeline
list_component_versions

Répertorie toutes les versions d’un composant CircleCI spécifique dans un environnement. Inclut l’état du déploiement, les informations sur le commit et les horodatages.

L’outil vous invitera à sélectionner le composant et l’environnement s’ils ne sont pas indiqués.

Utile pour :

  • Identifier la version actuellement en production
  • Sélectionner les versions cibles pour les opérations de restauration
  • Obtenir les détails du déploiement (pipeline, workflow, job)
list_followed_projects

Répertorie tous les projets CircleCI suivis par l’utilisateur.

  • Affiche tous les projets auxquels vous avez accès avec leur projectSlug
  • Exemple : « Lister mes projets CircleCI »

Exemple de sortie :

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

[!NOTE] Le projectSlug (et non le nom du projet) est requis par de nombreux autres outils CircleCI.

rerun_workflow

Relance un workflow depuis son début ou à partir du job ayant échoué.

Renvoie l’ID du workflow nouvellement créé et un lien permettant de le suivre.

run_pipeline

Déclenche l’exécution d’un pipeline. Cet outil peut être utilisé de trois façons :

  1. Avec le slug du projet et la branche (recommandé) :

    • Exemple : « Exécuter le pipeline de my-project sur la branche main »
  2. Avec une URL CircleCI :

  3. Avec le contexte du projet local :

    • Fonctionne depuis votre espace de travail local en fournissant la racine de l’espace de travail, l’URL du dépôt git et le nom de la branche

L’outil renvoie un lien permettant de suivre l’exécution du pipeline.

run_rollback_pipeline

Déclenche une restauration pour un projet CircleCI. L’outil vous guide de manière interactive à travers les étapes suivantes :

  1. Sélection du projet — répertorie les projets suivis parmi lesquels choisir
  2. Sélection de l’environnement — répertorie les environnements disponibles (sélection automatique s’il n’y en a qu’un)
  3. Sélection du composant — répertorie les composants disponibles (sélection automatique s’il n’y en a qu’un)
  4. Sélection de la version — affiche les versions disponibles ; vous sélectionnez la cible de la restauration
  5. Détection du mode de restauration — vérifie si un pipeline de restauration est configuré
  6. Exécution de la restauration — deux options :
    • Restauration par pipeline : déclenche le pipeline de restauration
    • Relance du workflow : relance un workflow précédent à l’aide de son ID
  7. Confirmation — récapitule et demande confirmation avant l’exécution

Dépannage

Solutions rapides

Problèmes les plus courants :

  1. Vider les caches des packages :

    npx clear-npx-cache
    npm cache clean --force
    
  2. Forcer l’utilisation de la dernière version : ajoutez @latest à votre configuration :

    "args": ["-y", "@circleci/mcp-server-circleci@latest"]
    
  3. Redémarrez complètement votre IDE (ne vous contentez pas de recharger la fenêtre)

Problèmes d’authentification
  • Erreurs de jeton invalide : vérifiez votre CIRCLECI_TOKEN dans Personal API Tokens
  • Erreurs d’autorisation : assurez-vous que le jeton dispose d’un accès en lecture à vos projets
  • Variables d’environnement non chargées : testez avec echo $CIRCLECI_TOKEN (Mac/Linux) ou echo %CIRCLECI_TOKEN% (Windows)
Problèmes de connexion et de réseau
  • URL de base : vérifiez que CIRCLECI_BASE_URL est https://circleci.com
  • Réseaux d’entreprise : configurez les paramètres du proxy npm si vous êtes derrière un pare-feu
  • Blocage par le pare-feu : vérifiez si un logiciel de sécurité bloque les téléchargements de packages
Configuration système requise
  • Version de Node.js : assurez-vous qu’elle satisfait ^22.23.4 || ^24.22.1 || >=26.12.1 avec node --version
  • Mettre à jour Node.js : envisagez la dernière version LTS en cas de problèmes de compatibilité
  • Gestionnaire de packages : vérifiez que npm/pnpm fonctionne : npm --version
Problèmes propres à l’IDE
  • Emplacement du fichier de configuration : vérifiez le chemin correspondant à votre système d’exploitation
  • Erreurs de syntaxe : validez la syntaxe JSON de votre fichier de configuration
  • Journaux de la console : consultez la console de développement de l’IDE pour repérer les erreurs spécifiques
  • Essayez un autre IDE : testez dans un autre éditeur pris en charge pour isoler le problème
Problèmes de processus

Processus bloqués — arrêtez les processus MCP existants :

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

# Windows:
taskkill /f /im node.exe

Conflits de ports : redémarrez votre IDE si la connexion semble bloquée.

Débogage avancé
  • Tester directement le package : npx @circleci/mcp-server-circleci@latest --help
  • Journalisation détaillée : DEBUG=* npx @circleci/mcp-server-circleci@latest
  • Solution de repli avec Docker : essayez l’installation Docker si npx échoue systématiquement

Vous avez encore besoin d’aide ?

  1. Consultez GitHub Issues pour trouver des problèmes similaires
  2. Indiquez votre système d’exploitation, votre version de Node et votre IDE lorsque vous signalez un problème
  3. Partagez les messages d’erreur pertinents de la console de l’IDE

Télémétrie

Le serveur prend en charge les métriques OpenTelemetry pour suivre l’utilisation des outils. Les métriques sont exportées sauf si vous définissez DISABLE_TELEMETRY=true. Dans les déploiements distants, les métriques utilisent le même jeton que la requête (PAT par utilisateur ou PAT partagé du serveur).

MétriqueDescription
circleci.mcp.tool.invocationsNombre d’appels d’outils
circleci.mcp.tool.duration_msDurée d’exécution en ms
circleci.mcp.tool.errorsNombre d’erreurs

Développement

Premiers pas

  1. Clonez le dépôt :

    git clone https://github.com/CircleCI-Public/mcp-server-circleci.git
    cd mcp-server-circleci
    
  2. Installez les dépendances :

    pnpm install
    
  3. Compilez le projet :

    pnpm build
    

Création du conteneur Docker

Vous pouvez créer le conteneur Docker localement à l’aide de :

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

Cela créera une image Docker étiquetée circleci:mcp-server-circleci que vous pourrez utiliser avec n’importe quel client MCP.

Mode stdio local (un seul développeur, jeton côté client) :

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

Mode distant (serveur centralisé pour une équipe) : consultez Self-Managed Remote MCP Server.

Développement avec MCP Inspector

La façon la plus simple de faire évoluer le serveur MCP consiste à utiliser MCP Inspector. Pour en savoir plus sur MCP Inspector, consultez https://modelcontextprotocol.io/docs/tools/inspector

  1. Démarrez le serveur de développement :

    pnpm watch # Keep this running in one terminal
    
  2. Dans un terminal distinct, lancez l’inspecteur :

    pnpm inspector
    
  3. Configurez l’environnement :

    • Ajoutez votre CIRCLECI_TOKEN à la section Environment Variables de l’interface de l’inspecteur
    • Le jeton doit disposer d’un accès en lecture à vos projets CircleCI
    • Vous pouvez également définir l’URL de base CircleCI (la valeur par défaut est https://circleci.com)

Tests

  • Exécutez la suite de tests :

    pnpm test
    
  • Exécutez les tests en mode surveillance pendant le développement :

    pnpm test:watch
    

Pour obtenir des consignes de contribution plus détaillées, consultez CONTRIBUTING.md