Skip to main content
Changing an experiment or feature flag usually means switching from your editor to the Kameleoon app. With the MCP server, your AI assistant reads and changes your Kameleoon project from the place where you write code.

Set up the server where you build

Select your AI coding assistant to get a ready-to-paste setup prompt.
Kai, Kameleoon’s in-app AI assistant, includes these same tools natively, with no separate connection step. Use the setup prompts for your AI coding assistant when you want it to act on your Kameleoon project from your IDE instead.
If you want to use these tools from Claude or ChatGPT chat (web or desktop) rather than an IDE, see Connect Kameleoon to Claude and ChatGPT.
Step-by-step setup for each client is on Set up MCP clients.

What you can do

After you connect the server, your AI agent can interact with Kameleoon to:
  • Discover and inspect experiments, feature flags, goals, segments, triggers, and targeting rules.
  • Build experiments end to end: create, duplicate, edit their settings and traffic split, add variations with their own code, and run the full lifecycle (start, pause, resume, stop, delete).
  • Manage feature flags: create, duplicate, delete, toggle per environment, and review the change history.
  • Configure flag delivery: add targeted and experimentation rules, custom variations, and typed variables.
  • Create and maintain goals, audience segments, and triggers, and set an experiment’s segment and trigger.
  • Analyze experiment and feature-flag-experiment results, and pull raw variation code (JavaScript and CSS).
  • Automate the full implementation lifecycle, from a winning variation to a gated production rollout.

Tool reference

Tools group by the area they act on. Each page lists its area’s tools with their parameters and sample prompts. Each tool maps to a single, well-scoped action, so you can compose them into larger workflows (for example: read results, pull code, create a flag, add a rule, enable it).

All tools

This table lists all 60 tools in one place, sorted by name. The Area column links to the page with each tool’s parameters and sample prompts.
To use the newest tools and tool settings, such as the results breakdowns and filters or the extra segment condition types, reconnect the Kameleoon MCP server in your client. Until you reconnect, the client keeps the tool list it loaded earlier and doesn’t show the new settings.

Confirm changes that affect live traffic

Tools that change live traffic show a preview of what will change, and apply the change only after you confirm:
  • feature_flag_enable, feature_flag_disable, and feature_flag_delete: always.
  • feature_flag_rule_targeted_create, feature_flag_rule_progressive_create, and feature_flag_rule_experimentation_create: when the flag is already enabled in the target environment.
  • experiment_update, experiment_integrations_update, experiment_variation_create, experiment_variation_update, and targeting_rule_update: when the experiment isn’t a draft.
  • experiment_traffic_allocation_set: for a scheduled or paused experiment.
  • segment_update and trigger_update: when the conditions change and anything other than a draft experiment uses the segment or trigger, or, for a segment, another segment references it. Renaming never needs confirmation.
  • experiment_lifecycle_update: for stopped and deleted.
segment_delete and trigger_delete refuse to delete an item that’s in use unless you set force. You can’t change the traffic split of a running experiment through the MCP server. Change it in the Kameleoon app. If a feature flag rule tool times out or returns a gateway error, the tool may still have created the rule. Check with feature_flag_get before you retry, or the retry adds a duplicate rule.

Data that takes time to prepare

Health checks and goal impacts depend on data that Kameleoon prepares in the background. A tool can answer that Kameleoon is still preparing the data (a readiness of PREPARING or PARTIAL on goal impacts). Ask again after the readiness.retryAfterSeconds value.

Token usage and plan considerations

Connecting the Kameleoon MCP server to an AI assistant adds a small, fixed overhead: the tool schemas that describe the available actions. This overhead stays flat regardless of which plan the assistant runs on. The token cost of a workflow comes from the work itself, not from the connection. The following factors drive usage:
  • The amount of data a workflow retrieves, such as full experiment configurations, variation code, or activity logs.
  • The amount of code the assistant generates or converts, for example when transposing a winning variation into native app code.
  • The number of sites or brands a single workflow touches. Duplicating and auditing experiments across three sites consumes proportionally more tokens than running the same operation on one site.
  • How broadly you scope a single prompt. A narrow, single-site check consumes far less than an open-ended request to review every experiment across every site.
Before you commit a team to a specific AI assistant plan, scope your expected workflows: how many sites or brands they span, how often you run them, and whether they include large data-retrieval or code-generation steps. Recurring, multi-site workflows need a plan with a larger usage allowance or context window than a plan sized for occasional, single-site prompts. Check your AI assistant provider’s plan documentation for its specific usage limits and context window size.

Rate limits

The MCP server has its own rate limits, applied per user, per tool, per minute. Results and analytics tools allow 10 calls per minute, write tools allow 20 to 60 calls per minute, and the list and get tools for segments, triggers, and targeting rules allow 100 calls per minute. A call over the limit returns a rate-limit error with a retryAfterSeconds value. Every MCP call also goes through the Automation API gateway. The Automation API limits of 50 requests per 10 seconds and 1,000 requests per hour apply to each user, meaning your customer account and username together, not to each access token. MCP requests have their own limit, separate from the limits that apply to each of your own Automation API apps. One tool call usually makes 1 to 3 API requests, and results calls make more. Normal conversational use stays well below both limits, but bulk scripts that loop over hundreds of experiments through the MCP server can reach the gateway limit.