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

# Kameleoon MCP Server

> Verbinden Sie KI-Coding-Assistenten direkt mit Ihrem Kameleoon-Projekt, um Workflows für Experimente und Feature Flags zu automatisieren.

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:

1. Experimentergebnisse abrufen und die gewinnende Variation identifizieren.
2. Den Rohcode der Variation aus Kameleoon extrahieren.
3. Den Code in nativen, produktionsreifen Code (wie React-Komponenten) umwandeln, der mit der vorhandenen Codebasis übereinstimmt.
4. Ein Feature Flag in Kameleoon erstellen.
5. Die neue Implementierung hinter dem Feature Flag kapseln.
6. 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:

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

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:

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

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

```bash theme={null}
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:

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

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

Überprüfen Sie die Verbindung:

```bash theme={null}
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:

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

### Manuelle Konfiguration

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

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

## Codex-Integration

### Schnellkonfiguration

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

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

### Manuelle Konfiguration

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

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

## Die Verbindung authentifizieren

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

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

**Erwartetes Verhalten:**

1. Der Browser öffnet automatisch ein Fenster.
2. Klicken Sie auf der Kameleoon-Anmeldeseite auf **Authorize**.
3. Kameleoon schließt den lokalen Callback auf Port 35535 ab.
4. 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:

1. **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`.
2. **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.
3. **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)

1. Öffnen Sie die Cursor-Einstellungen (`Cmd+Shift+J` unter macOS, `Ctrl+Shift+J` unter Windows/Linux).
2. Navigieren Sie zu **Features > MCP Servers > + Add New MCP Server**.
3. Setzen Sie den **Name** auf `kameleoon`.
4. Setzen Sie den **Type** auf `command`.
5. Geben Sie die folgende Zeichenfolge als **Command** ein:
   ```bash theme={null}
   npx -y mcp-remote@0.1.37 https://mcp.kameleoon.com/mcp 35535 --static-oauth-client-metadata '{ "scope": "openid" }'
   ```
6. 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:

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

<Note>
  Starten Sie Cursor neu, nachdem Sie die Datei manuell bearbeitet haben.
</Note>

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

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

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

<Note>
  `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](/de/developer-docs/apis/automation-api-rest/tutorials/experiments/create-a-multivariate-experiment).
</Note>

### 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`).

<Tip>
  Für umgebungsspezifische Abfragen übergeben Sie `environmentKey = "production"` oder `environmentKey = "staging"`, wo `environmentKey` unterstützt wird.
</Tip>

### 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`.