Kameleoon MCP Server - Kameleoon Documentation

Der Kameleoon Model Context Protocol (MCP) Server verbindet KI-Coding-Assistenten direkt mit Ihrem Kameleoon-Projekt und ermöglicht agentische Workflows für Experimente und Feature Flags. Über das Lesen von Konfigurationen und das Abrufen von Variationscode hinaus kann Ihr KI-Assistent Experimente, Feature Flags, Ziele, Segmente und Targeting-Regeln erstellen und verwalten sowie den vollständigen Rollout-Lebenszyklus ausführen, alles aus Ihrer Entwicklungsumgebung heraus. Registrieren und authentifizieren Sie den Server, um Ihren Implementierungslebenszyklus zu automatisieren, von einer gewinnenden Variation bis zu einem kontrollierten Produktions-Rollout.

Funktionen

Nachdem Sie den Server verbunden haben, kann Ihr KI-Agent mit Kameleoon interagieren, um:

Experimente, Feature Flags, Ziele, Segmente und Targeting-Regeln zu entdecken und zu inspizieren.
Experimente von Anfang bis Ende zu erstellen: erstellen, duplizieren und den vollständigen Lebenszyklus auszuführen (starten, pausieren, fortsetzen, stoppen, löschen).
Feature Flags zu verwalten: erstellen, duplizieren, löschen, pro Umgebung umschalten und den Änderungsverlauf einzusehen.
Die Flag-Auslieferung zu konfigurieren: gezielte Regeln und Experimentier-Regeln, benutzerdefinierte Variationen und typisierte Variablen hinzuzufügen.
Ziele und Zielgruppensegmente zu erstellen und zu pflegen sowie Segmente an Experimente zu binden.
Ergebnisse von Experimenten und Feature-Flag-Experimenten zu analysieren und den Rohcode von Variationen (JavaScript und CSS) abzurufen.
Den vollständigen Implementierungslebenszyklus zu automatisieren, von einer gewinnenden Variation bis zu einem kontrollierten Produktions-Rollout.

Der primäre Workflow: Vom gewinnenden Experiment zur Produktion

Der Kameleoon MCP Server automatisiert die „letzte Meile” der Implementierung. Ohne die IDE zu verlassen, können Sie Ihren KI-Assistenten anweisen, den folgenden Workflow auszuführen:

Experimentergebnisse abrufen und die gewinnende Variation identifizieren.
Den Rohcode der Variation aus Kameleoon extrahieren.
Den Code in nativen, produktionsreifen Code (wie React-Komponenten) umwandeln, der mit der vorhandenen Codebasis übereinstimmt.
Ein Feature Flag in Kameleoon erstellen.
Die neue Implementierung hinter dem Feature Flag kapseln.
Die Funktion in der Produktion aktivieren und validieren.

Token-Verbrauch und Überlegungen zur Plan-Wahl

Das Verbinden des Kameleoon MCP Servers mit einem KI-Assistenten erzeugt einen kleinen, festen Overhead: die Tool-Schemas, die die verfügbaren Aktionen beschreiben. Dieser Overhead bleibt unabhängig vom Plan des Assistenten konstant. Die Token-Kosten eines Workflows entstehen durch die eigentliche Arbeit, nicht durch die Verbindung selbst. Die folgenden Faktoren bestimmen den Verbrauch:

Die Datenmenge, die ein Workflow abruft, etwa vollständige Experiment-Konfigurationen, Variationscode oder Änderungsprotokolle.
Die Codemenge, die der Assistent generiert oder umwandelt, zum Beispiel beim Übertragen einer gewinnenden Variation in nativen Anwendungscode.
Die Anzahl der Sites oder Marken, die ein einzelner Workflow umfasst. Das Duplizieren und Prüfen von Experimenten über drei Sites hinweg verbraucht proportional mehr Token als derselbe Vorgang auf einer einzelnen Site.
Wie breit Sie einen einzelnen Prompt anlegen. Eine eng gefasste Prüfung auf einer einzelnen Site verbraucht deutlich weniger als eine offene Anfrage, jedes Experiment auf jeder Site zu überprüfen.

Bevor Sie sich als Team auf einen bestimmten KI-Assistenten-Plan festlegen, grenzen Sie Ihre erwarteten Workflows ein: wie viele Sites oder Marken sie betreffen, wie oft Sie sie ausführen und ob sie umfangreiche Datenabrufe oder Codegenerierung umfassen. Wiederkehrende Workflows über mehrere Sites hinweg benötigen einen Plan mit einem größeren Nutzungskontingent oder Kontextfenster als ein Plan, der für gelegentliche Prompts auf einer einzelnen Site ausgelegt ist. Prüfen Sie die Plan-Dokumentation Ihres KI-Assistenten-Anbieters auf die jeweiligen Nutzungsgrenzen und die Größe des Kontextfensters.

Verfügbare Tools

Der Server stellt die unten aufgeführten Tools bereit, gruppiert nach Bereich. Jedes Tool entspricht einer einzelnen, klar abgegrenzten Aktion, sodass Sie sie zu größeren Workflows zusammensetzen können (zum Beispiel: Ergebnisse lesen, Code abrufen, ein Flag erstellen, eine Regel hinzufügen, aktivieren).

Experimente

A/B-Tests (Web-Experimente) erstellen, inspizieren und ausführen.

Tool	Beschreibung	Beispiel-Prompt
`experiment_list`	Experimente nach Name oder ID finden. Gibt paginierte Zusammenfassungen zurück (id, name, status und tags).	„List active experiments on site `d1alzzxd7k`.”
`experiment_get`	Vollständige Konfiguration eines Experiments abrufen: Variationen, Traffic-Aufteilung, Ziele und Targeting.	„Show the configuration for experiment `149640`.”
`experiment_code_get`	Rohen JavaScript-, CSS- und benutzerdefinierten JSON-Code einer Variation abrufen, plus den gemeinsamen JS- und CSS-Code des Experiments.	„Pull the code for variation 1 of experiment `149640`.”
`experiment_results_get`	Statistische Ergebnisse abrufen: Konversionsraten pro Variation, Signifikanz, Konfidenzintervalle und den Gewinner.	„Summarize results for experiment `149640`.”
`experiment_create`	Ein Entwurfs-Experiment erstellen (Typ, Basis-URL, Ziele, optionaler gemeinsamer Code).	„Create a CLASSIC experiment `Homepage hero` on site `d1alzzxd7k`.”
`experiment_duplicate`	Ein Experiment in einen neuen Entwurf klonen und dabei Variationen, Code, Abweichungen und Targeting kopieren.	„Duplicate experiment `149640`.”
`experiment_lifecycle_update`	Den Lebenszyklus steuern: starten, pausieren, fortsetzen, stoppen oder löschen (Stoppen und Löschen erfordern eine Bestätigung).	„Start experiment `149640`.”

Feature Flags

Feature Flags erstellen und betreiben, sie pro Umgebung umschalten sowie deren Verlauf und Ergebnisse einsehen.

Tool	Beschreibung	Beispiel-Prompt
`feature_flag_list`	Feature Flags nach Schlüssel, Name oder ID finden.	„List all feature flags for site `d1alzzxd7k`.”
`feature_flag_get`	Vollständige Konfiguration eines Flags in einer Umgebung abrufen: Variationen, Variablen, primäres Ziel und Regelkette.	„Show configuration for flag `snake_game`.”
`feature_flag_create`	Ein Flag mit standardmäßigen `on`- und `off`-Variationen erstellen.	„Create a flag `ui_refresh` for site `d1alzzxd7k`.”
`feature_flag_duplicate`	Ein bestehendes Flag klonen (die Kopie startet in jeder Umgebung deaktiviert).	„Duplicate the `new_search` flag.”
`feature_flag_delete`	Ein Flag und seine gesamte Konfiguration dauerhaft löschen.	„Delete the flag `ui_refresh`.”
`feature_flag_enable`	Den Hauptschalter pro Umgebung einschalten, sodass das SDK die Regeln auswertet.	„Enable `new_search` in production.”
`feature_flag_disable`	Den Hauptschalter pro Umgebung ausschalten (Regeln bleiben erhalten).	„Disable `new_search` in staging.”
`feature_flag_activity_logs_get`	Den Audit-Trail der Flag-Änderungen einsehen (wer hat was wann geändert).	„Show the recent change history for our feature flags.”
`feature_flag_experiment_results_get`	Statistische Ergebnisse für die Experimentier-Regel eines Flags abrufen.	„Get the experiment results for the rule on `new_search`.”

Flag-Auslieferung, Variationen und Variablen

Gestalten Sie, wie ein Flag ausgeliefert wird, und definieren Sie die Variationen und typisierten Variablen, die es bereitstellt.

Tool	Beschreibung	Beispiel-Prompt
`feature_flag_rule_targeted_create`	Eine gezielte Auslieferungsregel hinzufügen: Eine Variation an einen Prozentsatz des Traffics ausliefern, mit optionaler Terminierung.	„Roll `new_search` out to 20% in production.”
`feature_flag_rule_experimentation_create`	Eine A/B-Experimentier-Regel hinzufügen, die den Traffic mit statistischer Erfassung auf Variationen aufteilt.	„A/B test `off` vs `on` 50/50 on `new_search`.”
`feature_flag_variation_create`	Einem Flag eine benutzerdefinierte Variation (einen benannten Zustand der Funktion) hinzufügen.	„Add a `variant_a` variation to `new_search`.”
`feature_flag_variable_create`	Eine typisierte Variable (BOOLEAN, NUMBER, STRING, JSON, JS, CSS, ENUM) mit einem Standardwert definieren.	„Add a STRING variable `label` defaulting to `Search`.”
`feature_flag_variation_variable_set`	Den Wert einer Variablen für eine bestimmte Variation überschreiben.	„Set `label` to `Find` on `variant_a`.”

Ziele

Die Konversionsziele erstellen und pflegen, die von Experimenten und Flags verwendet werden.

Tool	Beschreibung	Beispiel-Prompt
`goal_list`	Ziele einer Website durchsuchen, mit Nutzungszahlen über Experimente, Flags und Personalisierungen.	„List goals for site `d1alzzxd7k`.”
`goal_get`	Die Typkonfiguration, Tags und Nutzungszahlen eines Ziels inspizieren.	„Show goal `271552`.”
`goal_search`	Ein Ziel über einen Teilstring seines Namens finden.	„Search goals for `checkout`.”
`goal_create`	Ein Ziel beliebigen Typs erstellen (URL, CLICK, SCROLL, PAGE_VIEWS, TIME_SPENT, CUSTOM und mehr).	„Create a URL goal that matches `/thank-you`.”
`goal_update`	Name, Beschreibung, Tags, Tracking-Tools oder die Einstellung für mehrfache Konversionen eines Ziels bearbeiten.	„Rename goal `271552` to `Signup complete`.”
`goal_update_type`	Den Typ eines Ziels wechseln und seine typspezifische Konfiguration ersetzen (Tags bleiben erhalten).	„Change goal `271552` to a CLICK goal.”
`goal_delete`	Ein Ziel dauerhaft löschen.	„Delete goal `271552`.”

Segmente

Die Zielgruppen, die Sie ansprechen, definieren und inspizieren.

Tool	Beschreibung	Beispiel-Prompt
`segment_list`	Segmente einer Website durchsuchen, mit Nutzungszahlen.	„List segments for site `d1alzzxd7k`.”
`segment_get`	Den Bedingungsbaum eines Segments inspizieren (rohes JSON plus eine menschenlesbare Zusammenfassung).	„Show segment `200604`.”
`segment_create`	Ein Zielgruppensegment aus einem Bedingungsbaum erstellen (Geolokalisierung, Gerät, Browser, benutzerdefinierte Daten und mehr).	„Create a segment for desktop visitors in France.”
`segment_delete`	Ein Segment löschen. Standardmäßig blockiert, wenn das Segment verwendet wird (mit force überschreiben).	„Delete segment `200604`.”

Sites und Targeting-Regeln

Ihre Projekte entdecken und Segmente an Experimente binden.

Tool	Beschreibung	Beispiel-Prompt
`site_list`	Die Sites (Projekte) auflisten, auf die Sie Zugriff haben, mit Code, Name und Tracking-Status jeder Site.	„List my Kameleoon sites.”
`targeting_rule_list`	Targeting-Regeln einer Site auflisten.	„List targeting rules for site `d1alzzxd7k`.”
`targeting_rule_get`	Eine einzelne Targeting-Regel inspizieren (Segment, Konfiguration, Trigger und zugehöriges Experiment).	„Show targeting rule `118605`.”
`targeting_rule_create`	Ein Segment an ein Experiment binden, um zu steuern, wer teilnimmt.	„Target experiment `149640` to segment `200604`.”

Claude Code-Integration

Schritt 1: Den Server registrieren

Um den Server für Ihr Benutzerprofil zu registrieren (sodass er in allen Projekten verfügbar ist), öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus:

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

Um den Server nur für das aktuelle Projekt zu registrieren (was Ihrem Repository eine .mcp.json-Datei für das Teilen im Team hinzufügt), führen Sie aus:

claude mcp add kameleoon -- npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'

Überprüfen Sie, ob Claude den Server hinzugefügt hat:

claude mcp list

Erwartete Ausgabe: kameleoon: ... - ✗ Failed to connect (Eine fehlgeschlagene Verbindung ist hier normal, da Sie die Authentifizierung noch nicht abgeschlossen haben.)

Schritt 2: OAuth-Authentifizierung abschließen

Lösen Sie im selben Terminal den Anmeldevorgang aus:

npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'

Der Befehl öffnet automatisch einen Browser-Tab. Falls nicht, kopieren Sie die im Terminal ausgegebene URL und öffnen Sie sie manuell.
Melden Sie sich bei Ihrem Kameleoon-Konto an.
Klicken Sie auf Authorize.
Wenn der Browser eine Erfolgsmeldung anzeigt, drücken Sie Ctrl+C in Ihrem Terminal.

Überprüfen Sie die Verbindung:

claude mcp list

Erwartete Ausgabe: kameleoon: ... - ✓ Connected

Schritt 3: Eine neue Claude Code-Sitzung starten

Claude Code stellt Tools von neu hinzugefügten MCP-Servern nur in Sitzungen zur Verfügung, die Sie nach der Registrierung des Servers starten. Schließen Sie Ihr aktuelles Claude Code-Chatfenster und öffnen Sie ein neues.

Schritt 4: Die Verbindung überprüfen

Probieren Sie in einer neuen Claude Code-Unterhaltung die folgenden Prompts aus:

„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.”

Claude-Fehlerbehebung

Symptom	Ursache	Lösung
Der Browser öffnet sich nicht.	Auto-Start fehlgeschlagen.	Kopieren Sie die URL aus dem Terminal und öffnen Sie sie manuell.
Verbindung auf Port 35535 verweigert.	Port wird verwendet.	Führen Sie `netstat -ano \| findstr :35535` aus, beenden Sie den Prozess und versuchen Sie es erneut.
Verbindung nach OAuth fehlgeschlagen.	Token wurde nicht beibehalten.	Führen Sie den Befehl aus Schritt 2 erneut aus, um Ihr Token zu aktualisieren.
Tools sind in Claude nicht sichtbar.	Die Sitzung wurde vor dem Hinzufügen des Servers gestartet.	Starten Sie eine neue Claude Code-Unterhaltung.
Schlüssel `mcpServers` in `settings.json` abgelehnt.	Falsche Datei; Claude Code verwendet diesen Schlüssel nicht.	Verwenden Sie stattdessen den Befehl `claude mcp add`.
Authentifizierungsfehler nach langer Zeit.	OAuth-Token abgelaufen.	Führen Sie den Befehl aus Schritt 2 erneut aus.

Antigravity-Integration

Schnellkonfiguration

Fügen Sie den folgenden Self-Starter-Prompt direkt in Ihren Antigravity-Chat ein, um sich automatisch zu verbinden:

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.

Manuelle Konfiguration

Bearbeiten Sie die Konfigurationsdatei unter ~/.gemini/antigravity/mcp_config.json und fügen Sie den folgenden JSON-Block hinzu:

"kameleoon": {
  "command": "npx",
  "args": [
    "-y",
    "mcp-remote@0.1.37",
    "https://mcp.kameleoon.com/mcp",
    "35535",
    "--static-oauth-client-metadata",
    "{ \"scope\": \"openid\" }"
  ]
}

Codex-Integration

Schnellkonfiguration

Fügen Sie den folgenden Self-Starter-Prompt in Ihren Codex-Chat ein:

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.

Manuelle Konfiguration

Fügen Sie den folgenden Block zu ~/.codex/config.toml hinzu. Erstellen Sie die Datei, falls sie nicht existiert:

[mcp_servers.kameleoon]
command = "npx"
args = ["-y", "mcp-remote@0.1.37", "https://mcp.kameleoon.com/mcp",
        "35535", "--static-oauth-client-metadata",
        "{ \"scope\": \"openid\" }"]

Die Verbindung authentifizieren

Der Kameleoon MCP Server verwendet OAuth. Führen Sie den folgenden Befehl in Ihrem Terminal aus, um den Autorisierungsfluss zu starten:

npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 \
  --static-oauth-client-metadata '{ "scope": "openid" }'

Erwartetes Verhalten:

Der Browser öffnet automatisch ein Fenster.
Klicken Sie auf der Kameleoon-Anmeldeseite auf Authorize.
Kameleoon schließt den lokalen Callback auf Port 35535 ab.
Das Terminal bestätigt, dass sich der Proxy erfolgreich verbunden hat.

Eine erfolgreiche Verbindung gibt Text wie den folgenden aus:

Connected to remote server using StreamableHTTPClientTransport
Local STDIO server running
Proxy established successfully between local STDIO and remote StreamableHTTPClientTransport

Tool-Operationen überprüfen

Nach der Authentifizierung führen Sie die folgenden Prüfungen aus, um zu bestätigen, dass die Tools wie erwartet funktionieren:

Verfügbare Tools auflisten: Bestätigen Sie, dass tools/list erfolgreich ist und die Kameleoon-Tools zurückgibt. Stellen Sie sicher, dass die Ausgabe die in der Tool-Tabelle aufgeführten Tools enthält, wie experiment_code_get, feature_flag_list und feature_flag_create.
Feature Flags abrufen: Führen Sie feature_flag_list(siteCode = "d1alzzxd7k") aus. Eine erfolgreiche Antwort gibt eine Liste der Feature Flags für die angegebene Website zurück.
Experimentergebnisse abrufen: Führen Sie experiment_results_get(experimentId = 149640) aus. Eine erfolgreiche Antwort enthält den Experimentnamen, den Sitecode, den Typ und den Status.

Cursor-Integration

Cursor integriert MCP-Tools direkt in die IDE-Chat-Seitenleiste, wodurch sie während des Codierens verfügbar sind.

Option 1: Über die Cursor-UI konfigurieren (empfohlen)

Öffnen Sie die Cursor-Einstellungen (Cmd+Shift+J unter macOS, Ctrl+Shift+J unter Windows/Linux).
Navigieren Sie zu Features > MCP Servers > + Add New MCP Server.
Setzen Sie den Name auf kameleoon.
Setzen Sie den Type auf command.

Geben Sie die folgende Zeichenfolge als Command ein:

npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'

Speichern Sie die Konfiguration.

Option 2: Über mcp.json konfigurieren (fortgeschritten)

Öffnen Sie ~/.cursor/mcp.json (erstellen Sie die Datei, falls sie nicht existiert) und fügen Sie den folgenden Eintrag zum Objekt mcpServers hinzu:

{
  "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\" }'"
      ]
    }
  }
}

Starten Sie Cursor neu, nachdem Sie die Datei manuell bearbeitet haben.

Beispiel-Prompts für Entwickler-Workflows

Nachdem Sie den Kameleoon MCP Server verbunden haben, verwenden Sie Prompts wie die folgenden in Ihrer 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 <experimentId> and variation <variationId>.”

Für fortgeschrittenere Workflows versuchen Sie die folgenden Prompts:

„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 <variationId> in experiment <experimentId> and explain what frontend behavior it changes.”
„Create a new feature flag named <name> with key <featureKey> for site d1alzzxd7k.”
„Turn on feature flag <featureKey> in the staging environment for site d1alzzxd7k.”
„Turn off feature flag <featureKey> in the production environment for site d1alzzxd7k.”

Fortgeschrittener Workflow: End-to-End-Automatisierung

Um die volle Leistungsfähigkeit des MCP-Servers zu erleben, verwenden Sie einen umfassenden System-Prompt. Das folgende Beispiel zeigt, wie Sie den Code der gewinnenden Variation in React-Komponenten umsetzen, was hauptsächlich für React-Anwendungen gedacht ist. Es weist den KI-Agenten an, den gesamten Implementierungslebenszyklus zu handhaben, vom Abrufen der gewinnenden Ergebnisse über die Generierung von produktionsreifem nativen Code, der hinter einem neuen Feature Flag liegt, bis hin zum Rollout und zur Validierung, alles über die MCP-Tools. Fügen Sie den folgenden Prompt in Ihren KI-Assistenten ein:

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.

Referenz der Tool-Parameter

Verwenden Sie die genauen Tool- und Parameternamen, die von tools/list zurückgegeben werden. Das aktive MCP-Schema unterstützt die folgenden Parameter.

Experimente

Tool	Erforderliche Parameter	Optionale Parameter
`experiment_list`	Keine	`siteCode`, `filterQuery`, `page`, `perPage`, `sortField`, `sortOrder`
`experiment_get`	`experimentId`	Keine
`experiment_code_get`	`experimentId`, `variationId`	Keine
`experiment_results_get`	`experimentId`	Keine
`experiment_create`	`payload` (`siteCode`, `name`, `type`, `baseURL`)	`payload`: `mainGoalId`, `goals`, `tags`, `description`, `commonJavaScriptCode`, `commonCssCode`, `trafficAllocationMethod`, `collectingDataEnabled`, `multipleTestingCorrection`, `executeCodeForReference`
`experiment_duplicate`	`experimentId`	Keine
`experiment_lifecycle_update`	`experimentId`, `status`	`confirm` (erforderlich für `stopped` und `deleted`), `reason`

experiment_create akzeptiert MVT und SDK_HYBRID als gültige type-Werte, aber keiner von beiden lässt sich über dieses Tool tatsächlich erstellen. MVT schlägt immer fehl, da die API bei der Erstellung mvtVariations (Sections und Variationen) erfordert und kein MCP-Tool dieses Feld bereitstellt. SDK_HYBRID schlägt immer mit einem Fehler „Incorrect Experiments type” fehl, unabhängig vom gesendeten Payload. AI, CLASSIC, DEVELOPER und PROMPT lassen sich alle erfolgreich erstellen. Um ein multivariate-Test-Experiment zu erstellen, rufen Sie die Automation API direkt auf und folgen Sie den Schritten unter Ein multivariate-Test-Experiment erstellen.

Feature Flags

Tool	Erforderliche Parameter	Optionale Parameter
`feature_flag_list`	Keine	`siteCode`, `filterQuery`, `page`, `perPage`, `sortField`, `sortOrder`
`feature_flag_get`	`featureKey`, `siteCode`	`environmentKey` (`*` für alle Umgebungen)
`feature_flag_create`	`siteCode`, `featureKey`, `name`	`description`
`feature_flag_duplicate`	`featureKey`, `siteCode`	Keine
`feature_flag_delete`	`featureKey`, `siteCode`	Keine
`feature_flag_enable`	`featureKey`, `siteCode`, `environmentKey`	Keine
`feature_flag_disable`	`featureKey`, `siteCode`, `environmentKey`	Keine
`feature_flag_activity_logs_get`	Keine	`type`, `sortKey` (`timestamp`), `sortOrder`, `page`, `perPage`
`feature_flag_experiment_results_get`	`featureKey`, `siteCode`, `environmentKey`, `experimentId`	Keine

Flag-Auslieferung, Variationen und Variablen

Tool	Erforderliche Parameter	Optionale Parameter
`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`	Keine
`feature_flag_variable_create`	`siteCode`, `featureKey`, `variableKey`, `variableType`, `defaultValue`	Keine
`feature_flag_variation_variable_set`	`siteCode`, `featureKey`, `variationKey`, `variableKey`, `value`	Keine

Ziele

Tool	Erforderliche Parameter	Optionale Parameter
`goal_list`	Keine	`siteCode`, `page`, `perPage`
`goal_get`	`goalId`	Keine
`goal_search`	`query`	`siteCode`, `page`, `perPage`
`goal_create`	`payload` (`name`, `siteCode`, `type`, `hasMultipleConversions`)	`payload`: typspezifische Parameter (`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`	typspezifische Parameter
`goal_delete`	`goalId`	Keine

Segmente

Tool	Erforderliche Parameter	Optionale Parameter
`segment_list`	Keine	`siteCode`, `query`, `page`, `perPage`
`segment_get`	`segmentId`	Keine
`segment_create`	`name`, `siteCode`	`conditionDataTree`, `description`
`segment_delete`	`segmentId`	`force`

Sites und Targeting-Regeln

Tool	Erforderliche Parameter	Optionale Parameter
`site_list`	Keine	Keine
`targeting_rule_list`	Keine	`siteCode`, `page`, `perPage`
`targeting_rule_get`	`targetingRuleId`	Keine
`targeting_rule_create`	`segmentConfiguration`, `siteCode`, `experimentId`	`segmentId`, `triggerConfiguration`, `triggerId`, `targetingConfigurationParam`

Zulässige Enum-Werte: experiment_lifecycle_update.status ist started, resumed, paused, stopped oder deleted. Experiment-type ist AI, CLASSIC, DEVELOPER, MVT, PROMPT oder SDK_HYBRID. Ziel-type ist CLICK, CUSTOM, SCROLL, PAGE_VIEWS, URL, TIME_SPENT, RETENTION_RATE, WAREHOUSE oder RATIO_METRICS. variableType ist BOOLEAN, NUMBER, STRING, JSON, JS, CSS oder ENUM. trafficAllocations ist ein durch Kommas getrennter String aus variationKey:percentage, der in Summe 100 ergibt (zum Beispiel off:50,on:50). releaseDateTime ist ein ISO-8601-Datetime-Wert in lokaler Zeit ohne Offset (zum Beispiel 2026-07-01T09:00:00), und timeZone ist eine IANA-Zeitzone (zum Beispiel Europe/Paris oder UTC).

Für umgebungsspezifische Abfragen übergeben Sie environmentKey = "production" oder environmentKey = "staging", wo environmentKey unterstützt wird.

Tipps für Prompts

Geben Sie den Sitecode an, wenn Sie mit Feature Flags arbeiten.
Geben Sie die Experiment-ID an, wenn Sie Experimente oder Experimentergebnisse abfragen.
Geben Sie sowohl experimentId als auch variationId an, wenn Sie Variationscode anfordern.
Benennen Sie die Zielumgebung explizit, wenn Sie den Agenten bitten, ein Feature Flag zu aktivieren oder zu deaktivieren.
Fordern Sie eine Zusammenfassung in einfacher Sprache an, wenn Ihr KI-Agent die MCP-Antwort interpretieren soll, anstatt nur die Rohdaten abzurufen.

Allgemeine Fehlerbehebung

Port 35535 ist bereits belegt

Falls die Authentifizierung mit einem EADDRINUSE-Fehler fehlschlägt, lauscht bereits ein anderer Prozess auf dem OAuth-Callback-Port.

Ursache: Ein veralteter mcp-remote-Prozess bleibt von einem früheren Authentifizierungsversuch aktiv.
Lösung: Beenden Sie den veralteten Prozess, der Port 35535 verwendet, und führen Sie den OAuth-Befehl erneut aus.

Der MCP-Server erscheint nicht im Codex-Chat

Codex lädt neu hinzugefügte MCP-Server möglicherweise nicht im laufenden Thread neu.

Lösung: Aktualisieren Sie Codex oder starten Sie eine neue Sitzung, nachdem Sie config.toml aktualisiert haben.

Der Browser-Flow schließt nicht ab

Falls sich das OAuth-Browserfenster öffnet, schließen Sie die Autorisierung jedoch nicht ab:

Bestätigen Sie, dass Sie auf der Kameleoon-Anmeldeseite auf die Schaltfläche Authorize geklickt haben.
Überprüfen Sie, ob Ihre Browser- oder Systemeinstellungen localhost-Callbacks nicht blockieren.
Öffnen Sie die Callback-URL manuell, falls Ihr Browser sie nicht automatisch startet.

Headless- oder Remote-Agenten können sich nicht authentifizieren

Remote- oder Headless-Agenten (wie cloudgehostetes Codex) können den browserbasierten Autorisierungsschritt nicht abschließen.

Lösung: Verwenden Sie stattdessen eine Desktop-Version Ihres Tools.

Befehl npx nicht gefunden

Falls der Befehl mit einem „not found”-Fehler fehlschlägt, stellen Sie sicher, dass npx in Ihrem System-PATH verfügbar ist. Node.js-Versionen 8.2 und neuer enthalten standardmäßig npx.

​Funktionen

​Der primäre Workflow: Vom gewinnenden Experiment zur Produktion

​Token-Verbrauch und Überlegungen zur Plan-Wahl

​Verfügbare Tools

​Experimente

​Feature Flags

​Flag-Auslieferung, Variationen und Variablen

​Ziele

​Segmente

​Sites und Targeting-Regeln

​Claude Code-Integration

​Schritt 1: Den Server registrieren

​Schritt 2: OAuth-Authentifizierung abschließen

​Schritt 3: Eine neue Claude Code-Sitzung starten

​Schritt 4: Die Verbindung überprüfen

​Claude-Fehlerbehebung

​Antigravity-Integration

​Schnellkonfiguration

​Manuelle Konfiguration

​Codex-Integration

​Schnellkonfiguration

​Manuelle Konfiguration

​Die Verbindung authentifizieren

​Tool-Operationen überprüfen

​Cursor-Integration

​Option 1: Über die Cursor-UI konfigurieren (empfohlen)

​Option 2: Über mcp.json konfigurieren (fortgeschritten)

​Beispiel-Prompts für Entwickler-Workflows

​Fortgeschrittener Workflow: End-to-End-Automatisierung

​Referenz der Tool-Parameter

​Experimente

​Feature Flags

​Flag-Auslieferung, Variationen und Variablen

​Ziele

​Segmente

​Sites und Targeting-Regeln

​Tipps für Prompts

​Allgemeine Fehlerbehebung

​Port 35535 ist bereits belegt

​Der MCP-Server erscheint nicht im Codex-Chat

​Der Browser-Flow schließt nicht ab

​Headless- oder Remote-Agenten können sich nicht authentifizieren

​Befehl npx nicht gefunden

Funktionen

Der primäre Workflow: Vom gewinnenden Experiment zur Produktion

Token-Verbrauch und Überlegungen zur Plan-Wahl

Verfügbare Tools

Experimente

Feature Flags

Flag-Auslieferung, Variationen und Variablen

Ziele

Segmente

Sites und Targeting-Regeln

Claude Code-Integration

Schritt 1: Den Server registrieren

Schritt 2: OAuth-Authentifizierung abschließen

Schritt 3: Eine neue Claude Code-Sitzung starten

Schritt 4: Die Verbindung überprüfen

Claude-Fehlerbehebung

Antigravity-Integration

Schnellkonfiguration

Manuelle Konfiguration

Codex-Integration

Schnellkonfiguration

Manuelle Konfiguration

Die Verbindung authentifizieren

Tool-Operationen überprüfen

Cursor-Integration

Option 1: Über die Cursor-UI konfigurieren (empfohlen)

Option 2: Über mcp.json konfigurieren (fortgeschritten)

Beispiel-Prompts für Entwickler-Workflows

Fortgeschrittener Workflow: End-to-End-Automatisierung

Referenz der Tool-Parameter

Experimente

Feature Flags

Flag-Auslieferung, Variationen und Variablen

Ziele

Segmente

Sites und Targeting-Regeln

Tipps für Prompts

Allgemeine Fehlerbehebung

Port 35535 ist bereits belegt

Der MCP-Server erscheint nicht im Codex-Chat

Der Browser-Flow schließt nicht ab

Headless- oder Remote-Agenten können sich nicht authentifizieren

Befehl npx nicht gefunden