How to Connect LaunchDarkly to Meta Muse via MCP

💡 No install? Use cloud.anythingmcp.com directly. Sign in, click Connectors → LaunchDarkly, paste your credentials, mint an MCP API key and you're done. No Docker, no git clone, no local server.

LaunchDarkly + Meta Muse

LaunchDarkly feature management from any AI agent: projects and environments, flags with their state and evaluation status, segments, metrics and experiments, the audit log, members and teams. Create flags and segments, turn flags on or off and change targeting with semantic patches.

Prerequisites

See the full setup instructions baked into the connector (visible in the in-app store when you select the connector). The required environment variables for this connector are:

LAUNCHDARKLY_API_TOKEN

Step 1 — Get credentials

Setting up takes about 2 minutes. You need a LaunchDarkly account.

1. In LaunchDarkly open Organization settings, Authorization (https://app.launchdarkly.com/settings/authorization) and create an access token. For reading choose the Reader role; to toggle and change flags Writer, or a custom role limited to the projects and environments the AI may change. A service token is not tied to a person.
2. Copy the token (api-..., shown only once) into LAUNCHDARKLY_API_TOKEN and run launchdarkly_get_caller_identity: it shows the account, the token's name and kind, the member it belongs to and its scopes. SDK keys (sdk-...) and mobile keys (mob-...) do not work here.
3. On the EU instance or the federal one, change the connector base URL to https://app.eu.launchdarkly.com or https://app.launchdarkly.us.

Finding flags: launchdarkly_list_projects, launchdarkly_get_project, launchdarkly_list_environments and launchdarkly_get_environment show the structure. launchdarkly_list_flags with env: production and a filter such as filter: query:checkout shows each flag with whether it is on and what it serves; without env the answer has no on or off state. launchdarkly_get_flag gives variations, targets, rules, fallthrough, off variation and prerequisites per environment.

Cleaning up: launchdarkly_list_flag_statuses and launchdarkly_get_flag_status say whether a flag is new, active, inactive (not evaluated for 7 days) or launched (serving one variation to everyone), and when it was last requested. Inactive and launched flags are candidates for removal from code.

Releasing: launchdarkly_create_flag creates a flag, by default a boolean one that is off in every environment. launchdarkly_toggle_flag turns it on or off in one environment. launchdarkly_update_flag changes targeting, rollouts, settings and lifecycle (deprecate, archive, restore); with dry_run: true it returns the flag as it would be, without saving. Segments: launchdarkly_list_segments, launchdarkly_get_segment, launchdarkly_create_segment (creates an empty one) and launchdarkly_update_segment for targets and rules.

Experiments, audit and people: launchdarkly_list_metrics, launchdarkly_get_metric, launchdarkly_list_experiments and launchdarkly_get_experiment read metrics and experiment iterations with treatments, traffic allocation and status. launchdarkly_list_audit_log (for example spec: proj/default:env/production:flag/new-checkout) and launchdarkly_get_audit_log_entry show who changed what, with the full change and its comment. launchdarkly_list_members, launchdarkly_get_member, launchdarkly_list_teams and launchdarkly_get_team read members, roles and teams.

Before writing: toggling a flag or changing its targeting in production changes what live users get within seconds. The AI confirms project, environment and flag with you first and adds a comment, which some environments require. Environments with approvals answer 405; the change then needs an approval request in the LaunchDarkly app.

Switched off at install: launchdarkly_delete_flag. Deleting removes the flag from every environment of the project and cannot be undone, while archiving with archiveFlag in launchdarkly_update_flag can be restored. A workspace admin turns it on when the team needs it.

Semantic patch: launchdarkly_toggle_flag, launchdarkly_update_flag and launchdarkly_update_segment send instructions such as {"kind": "addTargets", "contextKind": "user", "values": ["key-1"], "variationId": "<_id>"}. Variation, rule and clause ids are the _id fields from launchdarkly_get_flag or launchdarkly_get_segment. Rollout weights are in thousandths of a percent (100000 = 100%).

Data formats: project, environment, flag and segment keys are what the AI passes on; member and audit log ids are 24-character hex strings. Dates are Unix milliseconds (creationDate, lastModified, date). In a flag, environments.<key>.on says whether targeting is on and _summary.variations what is served. SDK and mobile keys of the environments are left out of every answer.

Paging: lists take limit and offset (flags up to 100 per page) and return totalCount and _links.next while more pages exist. The audit log returns at most 20 entries per call; the AI pages back with before set to the date of the last entry.

Common errors: 401 means a wrong or deleted token, 403 a token whose role does not allow the call, 404 an unknown key, 400 or 409 an invalid patch or a conflicting change (the message names the problem), 405 a change that needs approval, 429 the rate limit (wait for the time in X-Ratelimit-Reset).

The connector does not create or change projects and environments, does not manage members, teams or roles, does not delete segments, does not create experiments and does not file approval requests.

Step 2 — Install the adapter

curl -fsSL https://raw.githubusercontent.com/HelpCode-ai/anythingmcp/main/docker-compose.quickstart.yml -o docker-compose.yml
printf 'JWT_SECRET=%s\nENCRYPTION_KEY=%s\n' "$(openssl rand -hex 32)" "$(openssl rand -hex 32)" > .env
docker compose up -d

Step 3 — Add the connector in Muse

Your server URL: in AnythingMCP, open MCP Servers → the server this connector is on, and copy its URL (https://cloud.anythingmcp.com/mcp/…). Use it wherever this guide shows YOUR_SERVER_ID.

Muse adds remote MCP servers as custom connectors and signs in to them with OAuth.

1. In Muse, open Settings → Connectors and choose Add custom connector.
2. Paste the MCP server URL https://cloud.anythingmcp.com/mcp/YOUR_SERVER_ID.
3. Muse opens the AnythingMCP sign-in page: sign in and approve access.
4. In a chat, ask Muse for something that needs the LaunchDarkly tools.

You can also set it up from a chat, on the web, in the iOS and Android apps or in WhatsApp. Send Muse this message:

Create a Custom Connector for a new remote MCP server, then connect to it:
Name: AnythingMCP
Transport: remote streamable HTTP
URL: https://cloud.anythingmcp.com/mcp/YOUR_SERVER_ID
Auth: OAuth

Self-hosting? Use your instance's public HTTPS address instead of https://cloud.anythingmcp.com. Muse connects from Meta's cloud, so localhost does not work.

Available tools

Example prompts

• "Is the new-checkout flag on in production, and what does it serve to whom?"
• "Which flags in the default project have been inactive in production for at least 7 days?"
• "Turn on dark-mode in the test environment with the comment QA run. Do a dry run first and show me the result."
• "Add the user key beta-tester-17 to the beta-users segment in production."
• "Who changed the targeting of new-checkout in production this week, and what exactly changed?"

FAQ

Where is Muse available? Meta currently offers Muse in the US and Canada, on the web, in the iOS and Android apps and in WhatsApp.

Does Meta review this connector? No. Meta doesn't review custom connectors. Muse sees only the tools you switched on for this MCP server in AnythingMCP, and you can disconnect it anytime under Settings → Connectors.

Next steps

• Connector landing page
• Connect to Claude
• Connect to ChatGPT
• Connect to Cursor
• Connect to Gemini
• Connect to Microsoft Copilot