> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Serveur MCP Kameleoon
> Connectez les assistants de code IA directement à votre projet Kameleoon pour automatiser les workflows d'expériences et de feature flags.
Le serveur Kameleoon Model Context Protocol (MCP) connecte les assistants de code IA directement à votre projet Kameleoon, permettant des workflows agentiques pour les expériences et les feature flags. Au-delà de la lecture des configurations et de l'extraction du code des variations, votre assistant IA peut créer et gérer des expériences, feature flags, objectifs, segments et règles de ciblage, et exécuter le cycle de vie complet du rollout, le tout depuis votre environnement de développement. Enregistrez et authentifiez le serveur pour automatiser votre cycle de vie d'implémentation, depuis une variation gagnante jusqu'à un rollout en production sécurisé par feature flag.
## Fonctionnalités
Une fois le serveur connecté, votre agent IA peut interagir avec Kameleoon pour :
* Découvrir et inspecter les expériences, feature flags, objectifs, segments et règles de ciblage.
* Construire des expériences de bout en bout : créer, dupliquer et exécuter le cycle de vie complet (démarrer, mettre en pause, reprendre, arrêter, supprimer).
* Gérer les feature flags : créer, dupliquer, supprimer, activer/désactiver par environnement et consulter l'historique des modifications.
* Configurer la livraison des flags : ajouter des règles ciblées et d'expérimentation, des variations personnalisées et des variables typées.
* Créer et maintenir des objectifs et des segments d'audience, et associer des segments aux expériences.
* Analyser les résultats des expériences et des feature-flag-experiments, et extraire le code brut des variations (JavaScript et CSS).
* Automatiser le cycle de vie complet de l'implémentation, depuis une variation gagnante jusqu'à un rollout en production sécurisé par feature flag.
### Le workflow principal : de l'expérience gagnante à la production
Le serveur MCP Kameleoon automatise le « dernier kilomètre » de l'implémentation. Sans quitter l'IDE, vous pouvez demander à votre assistant IA d'exécuter le workflow suivant :
1. Récupérer les résultats de l'expérience et identifier la variation gagnante.
2. Extraire le code brut de la variation depuis Kameleoon.
3. Convertir le code en code natif prêt pour la production (comme des composants React) aligné sur la base de code existante.
4. Créer un feature flag dans Kameleoon.
5. Encapsuler la nouvelle implémentation derrière le feature flag.
6. Activer et valider la fonctionnalité en production.
## Utilisation des tokens et choix du forfait
Connecter le serveur MCP Kameleoon à un assistant IA ajoute une surcharge faible et constante : les schémas d'outils qui décrivent les actions disponibles. Cette surcharge reste stable quel que soit le forfait sur lequel fonctionne l'assistant.
Le coût en tokens d'un workflow provient du travail lui-même, pas de la connexion. Les facteurs suivants déterminent la consommation :
* La quantité de données qu'un workflow récupère, comme des configurations d'expérience complètes, du code de variation ou des historiques de modifications.
* La quantité de code que l'assistant génère ou convertit, par exemple lors de la transposition d'une variation gagnante en code natif d'application.
* Le nombre de sites ou de marques qu'un même workflow couvre. Dupliquer et auditer des expériences sur trois sites consomme proportionnellement plus de tokens qu'exécuter la même opération sur un seul site.
* L'ampleur avec laquelle vous délimitez un même prompt. Une vérification circonscrite à un seul site consomme bien moins qu'une demande ouverte visant à passer en revue toutes les expériences de tous les sites.
Avant d'engager votre équipe sur un forfait d'assistant IA spécifique, évaluez l'ampleur de vos workflows prévus : combien de sites ou de marques ils couvrent, à quelle fréquence vous les exécutez, et s'ils incluent des étapes de récupération massive de données ou de génération de code. Les workflows récurrents et multi-sites nécessitent un forfait offrant une capacité d'usage ou une fenêtre de contexte plus large qu'un forfait pensé pour des prompts occasionnels sur un seul site. Consultez la documentation du forfait de votre fournisseur d'assistant IA pour connaître ses limites d'usage précises et la taille de sa fenêtre de contexte.
## Outils disponibles
Le serveur expose les outils ci-dessous, regroupés par domaine. Chaque outil correspond à une action unique et bien délimitée, vous permettant de les composer en workflows plus larges (par exemple : lire les résultats, extraire le code, créer un flag, ajouter une règle, l'activer).
### Expériences
Créez, inspectez et exécutez des tests A/B (expériences Web).
| Outil | Description | Exemple de prompt |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| `experiment_list` | Rechercher des expériences par nom ou ID. Renvoie des résumés paginés (id, nom, statut, tags). | « List active experiments on site `d1alzzxd7k`. » |
| `experiment_get` | Récupérer la configuration complète d'une expérience : variations, répartition du trafic, objectifs et ciblage. | « Show the configuration for experiment `149640`. » |
| `experiment_code_get` | Extraire le JavaScript, CSS et JSON personnalisé bruts d'une variation, ainsi que le JS et CSS communs partagés de l'expérience. | « Pull the code for variation 1 of experiment `149640`. » |
| `experiment_results_get` | Récupérer les résultats statistiques : taux de conversion par variation, significativité, intervalles de confiance et gagnant. | « Summarize results for experiment `149640`. » |
| `experiment_create` | Créer une expérience en brouillon (type, URL de base, objectifs, code commun optionnel). | « Create a CLASSIC experiment `Homepage hero` on site `d1alzzxd7k`. » |
| `experiment_duplicate` | Cloner une expérience dans un nouveau brouillon, en copiant les variations, le code, les déviations et le ciblage. | « Duplicate experiment `149640`. » |
| `experiment_lifecycle_update` | Piloter le cycle de vie : démarrer, mettre en pause, reprendre, arrêter ou supprimer (arrêter et supprimer nécessitent une confirmation). | « Start experiment `149640`. » |
### Feature flags
Créez et opérez des feature flags, activez-les ou désactivez-les par environnement, et consultez leur historique et leurs résultats.
| Outil | Description | Exemple de prompt |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------ |
| `feature_flag_list` | Rechercher des feature flags par clé, nom ou ID. | « List all feature flags for site `d1alzzxd7k`. » |
| `feature_flag_get` | Récupérer la configuration complète d'un flag dans un environnement : variations, variables, objectif principal et chaîne de règles. | « Show configuration for flag `snake_game`. » |
| `feature_flag_create` | Créer un flag avec les variations `on` et `off` par défaut. | « Create a flag `ui_refresh` for site `d1alzzxd7k`. » |
| `feature_flag_duplicate` | Cloner un flag existant (la copie démarre désactivée dans chaque environnement). | « Duplicate the `new_search` flag. » |
| `feature_flag_delete` | Supprimer définitivement un flag et toute sa configuration. | « Delete the flag `ui_refresh`. » |
| `feature_flag_enable` | Activer l'interrupteur principal par environnement afin que le SDK évalue les règles. | « Enable `new_search` in production. » |
| `feature_flag_disable` | Désactiver l'interrupteur principal par environnement (les règles sont conservées). | « Disable `new_search` in staging. » |
| `feature_flag_activity_logs_get` | Lire l'historique d'audit des modifications de flags (qui a changé quoi et quand). | « Show the recent change history for our feature flags. » |
| `feature_flag_experiment_results_get` | Récupérer les résultats statistiques de la règle d'expérimentation d'un flag. | « Get the experiment results for the rule on `new_search`. » |
### Livraison des flags, variations et variables
Façonnez la manière dont un flag est livré, et définissez les variations et variables typées qu'il sert.
| Outil | Description | Exemple de prompt |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------- |
| `feature_flag_rule_targeted_create` | Ajouter une règle de livraison ciblée : servir une variation à un pourcentage du trafic, avec planification optionnelle. | « Roll `new_search` out to 20% in production. » |
| `feature_flag_rule_experimentation_create` | Ajouter une règle d'expérimentation A/B qui répartit le trafic entre les variations avec suivi statistique. | « A/B test `off` vs `on` 50/50 on `new_search`. » |
| `feature_flag_variation_create` | Ajouter une variation personnalisée (un état nommé de la fonctionnalité) à un flag. | « Add a `variant_a` variation to `new_search`. » |
| `feature_flag_variable_create` | Définir une variable typée (BOOLEAN, NUMBER, STRING, JSON, JS, CSS, ENUM) avec une valeur par défaut. | « Add a STRING variable `label` defaulting to `Search`. » |
| `feature_flag_variation_variable_set` | Surcharger la valeur d'une variable pour une variation spécifique. | « Set `label` to `Find` on `variant_a`. » |
### Objectifs
Créez et maintenez les objectifs de conversion utilisés par les expériences et les flags.
| Outil | Description | Exemple de prompt |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
| `goal_list` | Parcourir les objectifs d'un site, avec leur nombre d'utilisations dans les expériences, flags et personnalisations. | « List goals for site `d1alzzxd7k`. » |
| `goal_get` | Inspecter la configuration de type, les tags et les comptages d'utilisation d'un objectif. | « Show goal `271552`. » |
| `goal_search` | Rechercher un objectif par une sous-chaîne de son nom. | « Search goals for `checkout`. » |
| `goal_create` | Créer un objectif de tout type (URL, CLICK, SCROLL, PAGE\_VIEWS, TIME\_SPENT, CUSTOM, et plus). | « Create a URL goal that matches `/thank-you`. » |
| `goal_update` | Modifier le nom, la description, les tags, les outils de suivi ou le paramètre de conversions multiples d'un objectif. | « Rename goal `271552` to `Signup complete`. » |
| `goal_update_type` | Changer le type d'un objectif et remplacer sa configuration spécifique au type (les tags sont conservés). | « Change goal `271552` to a CLICK goal. » |
| `goal_delete` | Supprimer définitivement un objectif. | « Delete goal `271552`. » |
### Segments
Définissez et inspectez les audiences que vous ciblez.
| Outil | Description | Exemple de prompt |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
| `segment_list` | Parcourir les segments d'un site, avec leur nombre d'utilisations. | « List segments for site `d1alzzxd7k`. » |
| `segment_get` | Inspecter l'arbre de conditions d'un segment (JSON brut plus un résumé lisible). | « Show segment `200604`. » |
| `segment_create` | Créer un segment d'audience à partir d'un arbre de conditions (géolocalisation, appareil, navigateur, données personnalisées, et plus). | « Create a segment for desktop visitors in France. » |
| `segment_delete` | Supprimer un segment. L'outil bloque la suppression par défaut lorsque le segment est utilisé ; contournez ce blocage avec force. | « Delete segment `200604`. » |
### Sites et règles de ciblage
Découvrez vos projets et associez des segments à des expériences.
| Outil | Description | Exemple de prompt |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| `site_list` | Lister les sites (projets) auxquels vous avez accès, avec le code, le nom et le statut de suivi de chaque site. | « List my Kameleoon sites. » |
| `targeting_rule_list` | Lister les règles de ciblage d'un site. | « List targeting rules for site `d1alzzxd7k`. » |
| `targeting_rule_get` | Inspecter une règle de ciblage unique (segment, configuration, déclencheur et l'expérience à laquelle elle appartient). | « Show targeting rule `118605`. » |
| `targeting_rule_create` | Associer un segment à une expérience pour contrôler qui y participe. | « Target experiment `149640` to segment `200604`. » |
## Intégration Claude Code
### Étape 1 : Enregistrer le serveur
Pour enregistrer le serveur pour votre profil utilisateur (le rendant disponible dans tous les projets), ouvrez un terminal et exécutez la commande suivante :
```bash theme={null}
claude mcp add --scope user kameleoon -- npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'
```
Pour enregistrer le serveur uniquement pour le projet en cours (ce qui ajoute un fichier `.mcp.json` à votre dépôt pour le partage en équipe), exécutez :
```bash theme={null}
claude mcp add kameleoon -- npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'
```
Vérifiez que Claude a ajouté le serveur :
```bash theme={null}
claude mcp list
```
**Sortie attendue :** `kameleoon: ... - ✗ Failed to connect` (Un échec de connexion ici est normal car vous n'avez pas encore terminé l'authentification).
### Étape 2 : Terminer l'authentification OAuth
Dans le même terminal, déclenchez le flux de connexion :
```bash theme={null}
npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'
```
1. La commande ouvre automatiquement un onglet de navigateur. Si ce n'est pas le cas, copiez l'URL affichée dans le terminal et ouvrez-la manuellement.
2. Connectez-vous à votre compte Kameleoon.
3. Cliquez sur **Authorize**.
4. Lorsque le navigateur affiche un message de succès, appuyez sur `Ctrl+C` dans votre terminal.
Vérifiez la connexion :
```bash theme={null}
claude mcp list
```
**Sortie attendue :** `kameleoon: ... - ✓ Connected`
### Étape 3 : Démarrer une nouvelle session Claude Code
Claude Code rend les outils des serveurs MCP nouvellement ajoutés disponibles uniquement dans les sessions que vous démarrez après l'enregistrement du serveur. Fermez votre session de chat Claude Code en cours et ouvrez-en une nouvelle.
### Étape 4 : Vérifier la connexion
Dans une nouvelle conversation Claude Code, essayez les prompts suivants :
* « List my Kameleoon feature flags. »
* « What experiments are active on site X? »
* « Show me the status of experiment Y. »
* « Show me the code for variation 1 of experiment Z. »
### Dépannage Claude
| Symptôme | Cause | Solution |
| --------------------------------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------------ |
| Le navigateur ne s'ouvre pas. | Échec du lancement automatique. | Copiez l'URL depuis le terminal et ouvrez-la manuellement. |
| Connexion refusée sur le port 35535. | Le port est utilisé. | Exécutez `netstat -ano \| findstr :35535`, terminez le processus et réessayez. |
| Échec de la connexion après OAuth. | Le jeton n'a pas persisté. | Réexécutez la commande de l'étape 2 pour rafraîchir votre jeton. |
| Les outils ne sont pas visibles dans Claude. | La session a commencé avant l'ajout du serveur. | Démarrez une nouvelle conversation Claude Code. |
| Clé `mcpServers` rejetée dans `settings.json`. | Mauvais fichier ; Claude Code n'utilise pas cette clé. | Utilisez plutôt la commande `claude mcp add`. |
| Erreur d'authentification après une longue période. | Jeton OAuth expiré. | Réexécutez la commande de l'étape 2. |
## Intégration Antigravity
### Configuration rapide
Collez le prompt d'auto-démarrage suivant directement dans votre chat Antigravity pour vous connecter automatiquement :
```text theme={null}
Connect to the Kameleoon MCP production server. The endpoint is https://mcp.kameleoon.com/mcp, using mcp-remote@0.1.37 on port 35535 with the openid scope. Authenticate by running the npx mcp-remote command to trigger my browser, then verify the connection.
```
### Configuration manuelle
Modifiez le fichier de configuration à `~/.gemini/antigravity/mcp_config.json` et ajoutez le bloc JSON suivant :
```json theme={null}
"kameleoon": {
"command": "npx",
"args": [
"-y",
"mcp-remote@0.1.37",
"https://mcp.kameleoon.com/mcp",
"35535",
"--static-oauth-client-metadata",
"{ \"scope\": \"openid\" }"
]
}
```
## Intégration Codex
### Configuration rapide
Collez le prompt d'auto-démarrage suivant dans votre chat Codex :
```text theme={null}
Configure the Kameleoon MCP server at https://mcp.kameleoon.com/mcp. Use port 35535 for callback. Once configured, run the login command to trigger my browser and then list my feature flags.
```
### Configuration manuelle
Ajoutez le bloc suivant à `~/.codex/config.toml`. Créez le fichier s'il n'existe pas :
```toml theme={null}
[mcp_servers.kameleoon]
command = "npx"
args = ["-y", "mcp-remote@0.1.37", "https://mcp.kameleoon.com/mcp",
"35535", "--static-oauth-client-metadata",
"{ \"scope\": \"openid\" }"]
```
## Authentifier la connexion
Le serveur MCP Kameleoon utilise OAuth. Exécutez la commande suivante dans votre terminal pour démarrer le flux d'autorisation :
```bash theme={null}
npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 \
--static-oauth-client-metadata '{ "scope": "openid" }'
```
**Comportement attendu :**
1. Le navigateur ouvre automatiquement une fenêtre.
2. Cliquez sur **Authorize** sur la page de connexion Kameleoon.
3. Kameleoon complète le callback local sur le port 35535.
4. Le terminal confirme que le proxy s'est connecté avec succès.
Une connexion réussie produit un texte semblable au suivant :
```
Connected to remote server using StreamableHTTPClientTransport
Local STDIO server running
Proxy established successfully between local STDIO and remote StreamableHTTPClientTransport
```
## Vérifier les opérations des outils
Après vous être authentifié, exécutez les vérifications suivantes pour confirmer que les outils fonctionnent comme prévu :
1. **Lister les outils disponibles :** Confirmez que `tools/list` réussit et renvoie les outils Kameleoon. Assurez-vous que la sortie inclut les outils listés dans le tableau des outils, comme `experiment_code_get`, `feature_flag_list` et `feature_flag_create`.
2. **Récupérer les feature flags :** Exécutez `feature_flag_list(siteCode = "d1alzzxd7k")`. Une réponse réussie renvoie une liste de feature flags pour le site spécifié.
3. **Récupérer les résultats d'expérience :** Exécutez `experiment_results_get(experimentId = 149640)`. Une réponse réussie inclut le nom de l'expérience, le code du site, le type et le statut.
## Intégration Cursor
Cursor intègre les outils MCP directement dans la barre latérale Chat de l'IDE, ce qui les rend disponibles pendant que vous codez.
### Option 1 : Configurer via l'UI Cursor (recommandé)
1. Ouvrez les paramètres Cursor (`Cmd+Shift+J` sur macOS, `Ctrl+Shift+J` sur Windows/Linux).
2. Naviguez vers **Features > MCP Servers > + Add New MCP Server**.
3. Définissez le **Name** sur `kameleoon`.
4. Définissez le **Type** sur `command`.
5. Saisissez la chaîne suivante comme **Command** :
```bash theme={null}
npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'
```
6. Enregistrez la configuration.
### Option 2 : Configurer via mcp.json (avancé)
Ouvrez `~/.cursor/mcp.json` (créez le fichier s'il n'existe pas) et ajoutez l'entrée suivante à l'objet `mcpServers` :
```json theme={null}
{
"mcpServers": {
"kameleoon": {
"command": "bash",
"args": [
"-lc",
"npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ \"scope\": \"openid\" }'"
]
}
}
}
```
Redémarrez Cursor après avoir modifié le fichier manuellement.
## Exemples de prompts pour les workflows développeur
Une fois le serveur MCP Kameleoon connecté, utilisez des prompts comme les suivants dans votre IDE :
* « List the Kameleoon MCP tools available in this session. »
* « Show me all feature flags for site code `d1alzzxd7k`. »
* « Get the details for feature flag new\_search on site `d1alzzxd7k`. »
* « Fetch experiment results for experiment `149640` and summarize the current status. »
* « Pull the variation code for experiment `` and variation ``. »
Pour des workflows plus avancés, essayez les prompts suivants :
* « Inspect feature flag new\_search for site `d1alzzxd7k` and explain what environments and variations it currently has. »
* « Summarize experiment `149640` for an engineer. Include status, site code, winner state, and whether any variation data is available. »
* « List the active feature flags for site `d1alzzxd7k` and point out any flags that look like stale candidates. »
* « Retrieve the code for variation `` in experiment `` and explain what frontend behavior it changes. »
* « Create a new feature flag named `` with key `` for site `d1alzzxd7k`. »
* « Turn on feature flag `` in the staging environment for site `d1alzzxd7k`. »
* « Turn off feature flag `` in the production environment for site `d1alzzxd7k`. »
### Workflow avancé : Automatisation de bout en bout
Pour découvrir toutes les capacités du serveur MCP, utilisez un prompt système complet. L'exemple suivant montre comment transposer le code de la variation gagnante en composants React, ce qui est principalement destiné aux applications React. Il demande à l'agent IA de gérer l'ensemble du cycle de vie d'implémentation, depuis la récupération des résultats gagnants jusqu'à la génération de code natif prêt pour la production, encadré par un nouveau feature flag, puis de le déployer et de le valider, le tout via les outils MCP.
Collez le prompt suivant dans votre assistant IA :
```text theme={null}
You are integrating a Kameleoon A/B experiment into a production codebase by converting a Kameleoon PBX variation into maintainable native React code.
Context
- Experiment ID: 373001
- Mode: strict_winner_only (default) or manual_variation_conversion (Fallback variation: 1266752)
Rules
- Inspect the repo first and follow existing conventions (structure, styling, routing, tests, feature flags).
- Do not copy experiment code directly. Re-implement using idiomatic React (components, hooks, state).
- Do not keep experiment-specific logic (IDs, Kameleoon APIs) in production code.
- Prefer existing feature flag systems for rollout. Use the Kameleoon MCP feature-flag tools to create and gate the flag.
- Avoid DOM manipulation (no querySelector calls, MutationObserver instances, or similar direct DOM APIs).
- Do not add new dependencies unless necessary.
- Do not modify the source experiment's lifecycle (do not stop or delete it) unless explicitly asked.
- Be explicit if something is unclear.
Workflow steps
1. Get experiment results (experiment_results_get).
2. Decide integration:
- Mode A (default: strict_winner_only): Proceed only if winner.status == "clear_winner".
- Mode B (manual): Use the fallback variation provided in the context.
3. Get the variation code and the prompt that was used (experiment_code_get).
4. Convert the code to React (convert JS code to React components/hooks, and CSS code to the project styling system).
5. Create a feature flag "pbx-winning-experiment-373001" (feature_flag_create). If the implementation needs more than a simple on/off, add variations and typed variables (feature_flag_variation_create, feature_flag_variable_create, feature_flag_variation_variable_set), then gate the converted code behind the flag.
6. Roll out and validate: add a delivery rule (feature_flag_rule_targeted_create for a staged percentage rollout, or feature_flag_rule_experimentation_create to keep measuring), enable the flag in the target environment (feature_flag_enable), and confirm the final configuration with feature_flag_get.
```
## Référence des paramètres des outils
Utilisez les noms exacts des outils et des paramètres retournés par `tools/list`. Le schéma MCP en direct prend en charge les paramètres suivants.
### Expériences
| Outil | Paramètres requis | Paramètres optionnels |
| ----------------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `experiment_list` | Aucun | `siteCode`, `filterQuery`, `page`, `perPage`, `sortField`, `sortOrder` |
| `experiment_get` | `experimentId` | Aucun |
| `experiment_code_get` | `experimentId`, `variationId` | Aucun |
| `experiment_results_get` | `experimentId` | Aucun |
| `experiment_create` | `payload` (`siteCode`, `name`, `type`, `baseURL`) | `payload` : `mainGoalId`, `goals`, `tags`, `description`, `commonJavaScriptCode`, `commonCssCode`, `trafficAllocationMethod`, `collectingDataEnabled`, `multipleTestingCorrection`, `executeCodeForReference` |
| `experiment_duplicate` | `experimentId` | Aucun |
| `experiment_lifecycle_update` | `experimentId`, `status` | `confirm` (requis pour `stopped` et `deleted`), `reason` |
`experiment_create` accepte `MVT` et `SDK_HYBRID` comme valeurs valides pour `type`, mais aucune des deux ne peut réellement être créée via cet outil. `MVT` échoue toujours car l'API exige `mvtVariations` (sections et variations) à la création, et aucun outil MCP n'expose ce champ. `SDK_HYBRID` échoue toujours avec une erreur « Incorrect Experiments type », quel que soit le contenu envoyé. `AI`, `CLASSIC`, `DEVELOPER` et `PROMPT` se créent tous correctement. Pour créer un test multivariate, appelez directement l'Automation API en suivant les étapes de [Créer un test multivariate](/fr/developer-docs/apis/automation-api-rest/tutorials/experiments/create-a-multivariate-experiment).
### Feature flags
| Outil | Paramètres requis | Paramètres optionnels |
| ------------------------------------- | ---------------------------------------------------------- | ---------------------------------------------------------------------- |
| `feature_flag_list` | Aucun | `siteCode`, `filterQuery`, `page`, `perPage`, `sortField`, `sortOrder` |
| `feature_flag_get` | `featureKey`, `siteCode` | `environmentKey` (`*` pour tous les environnements) |
| `feature_flag_create` | `siteCode`, `featureKey`, `name` | `description` |
| `feature_flag_duplicate` | `featureKey`, `siteCode` | Aucun |
| `feature_flag_delete` | `featureKey`, `siteCode` | Aucun |
| `feature_flag_enable` | `featureKey`, `siteCode`, `environmentKey` | Aucun |
| `feature_flag_disable` | `featureKey`, `siteCode`, `environmentKey` | Aucun |
| `feature_flag_activity_logs_get` | Aucun | `type`, `sortKey` (`timestamp`), `sortOrder`, `page`, `perPage` |
| `feature_flag_experiment_results_get` | `featureKey`, `siteCode`, `environmentKey`, `experimentId` | Aucun |
### Livraison des flags, variations et variables
| Outil | Paramètres requis | Paramètres optionnels |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ | --------------------- |
| `feature_flag_rule_targeted_create` | `siteCode`, `featureKey`, `environmentKey`, `variationKey`, `exposition`, `releaseDateTime`, `timeZone` | `ruleName` |
| `feature_flag_rule_experimentation_create` | `siteCode`, `featureKey`, `environmentKey`, `controlVariationKey`, `trafficAllocations`, `exposition`, `releaseDateTime`, `timeZone` | `ruleName` |
| `feature_flag_variation_create` | `siteCode`, `featureKey`, `variationKey`, `variationName` | Aucun |
| `feature_flag_variable_create` | `siteCode`, `featureKey`, `variableKey`, `variableType`, `defaultValue` | Aucun |
| `feature_flag_variation_variable_set` | `siteCode`, `featureKey`, `variationKey`, `variableKey`, `value` | Aucun |
### Objectifs
| Outil | Paramètres requis | Paramètres optionnels |
| ------------------ | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `goal_list` | Aucun | `siteCode`, `page`, `perPage` |
| `goal_get` | `goalId` | Aucun |
| `goal_search` | `query` | `siteCode`, `page`, `perPage` |
| `goal_create` | `payload` (`name`, `siteCode`, `type`, `hasMultipleConversions`) | `payload` : paramètres spécifiques au type (`matchString`, `matchType`, `scrollType`, `scrollValue`, `timeSeconds`, `pageViews`, `url`, `jsCode`), `tags`, `description`, `status`, `trackingTools` |
| `goal_update` | `goalId` | `name`, `description`, `tags`, `trackingTools`, `hasMultipleConversions` |
| `goal_update_type` | `goalId`, `type` | paramètres spécifiques au type |
| `goal_delete` | `goalId` | Aucun |
### Segments
| Outil | Paramètres requis | Paramètres optionnels |
| ---------------- | ------------------ | -------------------------------------- |
| `segment_list` | Aucun | `siteCode`, `query`, `page`, `perPage` |
| `segment_get` | `segmentId` | Aucun |
| `segment_create` | `name`, `siteCode` | `conditionDataTree`, `description` |
| `segment_delete` | `segmentId` | `force` |
### Sites et règles de ciblage
| Outil | Paramètres requis | Paramètres optionnels |
| ----------------------- | -------------------------------------------------- | ------------------------------------------------------------------------------- |
| `site_list` | Aucun | Aucun |
| `targeting_rule_list` | Aucun | `siteCode`, `page`, `perPage` |
| `targeting_rule_get` | `targetingRuleId` | Aucun |
| `targeting_rule_create` | `segmentConfiguration`, `siteCode`, `experimentId` | `segmentId`, `triggerConfiguration`, `triggerId`, `targetingConfigurationParam` |
**Valeurs d'énumération acceptées :** `experiment_lifecycle_update.status` est `started`, `resumed`, `paused`, `stopped` ou `deleted`. Le `type` d'expérience est `AI`, `CLASSIC`, `DEVELOPER`, `MVT`, `PROMPT` ou `SDK_HYBRID`. Le `type` d'objectif est `CLICK`, `CUSTOM`, `SCROLL`, `PAGE_VIEWS`, `URL`, `TIME_SPENT`, `RETENTION_RATE`, `WAREHOUSE` ou `RATIO_METRICS`. `variableType` est `BOOLEAN`, `NUMBER`, `STRING`, `JSON`, `JS`, `CSS` ou `ENUM`. `trafficAllocations` est une chaîne `variationKey:percentage` séparée par des virgules dont la somme est 100 (par exemple `off:50,on:50`). `releaseDateTime` est une date-heure locale ISO-8601 sans décalage (par exemple `2026-07-01T09:00:00`) et `timeZone` est une zone IANA (par exemple `Europe/Paris` ou `UTC`).
Pour des requêtes spécifiques à un environnement, passez `environmentKey = "production"` ou `environmentKey = "staging"` quand ces valeurs sont prises en charge.
### Conseils de prompting
* Incluez le code du site lorsque vous travaillez avec des feature flags.
* Incluez l'ID d'expérience lorsque vous interrogez des expériences ou leurs résultats.
* Incluez à la fois `experimentId` et `variationId` lorsque vous demandez le code d'une variation.
* Nommez explicitement l'environnement cible lorsque vous demandez à l'agent d'activer ou de désactiver un feature flag.
* Demandez un résumé en langage clair si vous voulez que votre agent IA interprète la réponse MCP plutôt que de simplement récupérer les données brutes.
## Dépannage général
### Le port 35535 est déjà utilisé
Si l'authentification échoue avec une erreur `EADDRINUSE`, un autre processus écoute déjà sur le port de callback OAuth.
* **Cause :** Un processus `mcp-remote` obsolète reste actif depuis une tentative d'authentification précédente.
* **Solution :** Arrêtez le processus obsolète qui utilise le port 35535, puis relancez la commande OAuth.
### Le serveur MCP n'apparaît pas dans le chat Codex
Codex peut ne pas recharger à chaud les serveurs MCP nouvellement ajoutés dans un thread déjà en cours d'exécution.
* **Solution :** Rafraîchissez Codex ou démarrez une nouvelle session après avoir mis à jour `config.toml`.
### Le flux du navigateur ne se termine pas
Si la fenêtre du navigateur OAuth s'ouvre mais que l'autorisation ne se termine pas :
* Confirmez que vous avez cliqué sur le bouton **Authorize** sur la page de connexion Kameleoon.
* Vérifiez que les paramètres de votre navigateur ou de votre système ne bloquent pas les callbacks `localhost`.
* Ouvrez manuellement l'URL de callback si votre navigateur ne parvient pas à la lancer automatiquement.
### Les agents headless ou distants ne parviennent pas à s'authentifier
Les agents distants ou headless (comme Codex hébergé dans le cloud) ne peuvent pas effectuer l'étape d'autorisation basée sur le navigateur.
* **Solution :** Utilisez à la place une version desktop de votre outil.
### Commande npx introuvable
Si la commande échoue avec une erreur « not found », assurez-vous que `npx` est disponible sur le chemin de votre système. Les versions de Node.js 8.2 et ultérieures incluent `npx` par défaut.