Mcp Configure

LaunchDarkly MCP Server Configuration (onboarding)

Configures the LaunchDarkly hosted MCP server so flag management skills and onboarding can use MCP tools. Uses OAuth for authentication — no API keys needed for the hosted server.

This skill is nested under LaunchDarkly onboarding; the parent skill's Step 4 hands off here. Hosted MCP is the default. For federal/EU or other cases where hosted is unavailable, use the Local server via `npx` section in MCP Config Templates and local MCP server docs.

Prerequisites

• A LaunchDarkly account (sign up at the resolved signup URL — see Source Attribution in the parent skill; default: https://app.launchdarkly.com/signup?source=agent)
• An MCP-compatible coding agent

Hosted MCP Servers

LaunchDarkly provides two hosted MCP servers. For onboarding, only the feature management server is required.

Workflow

Step 1: Detect the Agent

If the parent onboarding skill already identified the agent, use that context. Otherwise infer from agent-specific directories, config files, and the tools available to you at runtime. Do not ask the user — pick the strongest match.

Step 2: Try Quick Install

The fastest path is the quick install link. Present it to the user:

Feature management: https://mcp.launchdarkly.com/mcp/fm/install

AI Configs (optional): https://mcp.launchdarkly.com/mcp/aiconfigs/install

Important: tell the user what to expect after clicking the link. The install link may open in the browser, but the authorization or "add server" prompt typically appears back in the coding environment (the editor or host app where the agent runs), not in the browser. Immediately after presenting the link, include guidance like:

• After clicking the link, watch your coding environment (the editor where this conversation is running) for an approval dialog, an "add MCP server" prompt, or a tools/integrations panel notification.
• The browser may start the OAuth flow, but you'll likely need to confirm or approve the server in the editor itself.
• If no prompt appears: check the editor's MCP, integrations, or tools settings area to see if the server was added but needs to be enabled. If it's not there at all, fall back to manual setup (Step 3 below).

If the quick install link doesn't work (agent doesn't support it, or user prefers manual setup), proceed to Step 3.

Step 3: Manual Configuration

Locate the MCP config file for the detected agent and add the hosted server entry. See MCP Config Templates for the exact JSON per agent.

Only add the feature management server for onboarding. Add the AI Configs server only if the user explicitly needs it.

Step 4: Agent-Specific Authorization

After writing the config, some agents need extra steps. Do not send users through long manual menu paths only—use MCP UI links (HTTPS docs + command: shortcuts for VS Code / Cursor).

Cursor:

1. Open MCP in Cursor using the Cursor MCP doc link and in-app shortcuts (e.g. Settings search via command: link when clickable). 2. Toggle on LaunchDarkly feature management (or the name from your config). 3. Click Connect to authorize with the LaunchDarkly account.

VS Code (when applicable):

• Use VS Code MCP doc + `mcp.json` / Settings links; trust or start the server if prompted.

Claude Code:

• Authorization happens automatically on first MCP tool call via OAuth prompt. File-based setup: Claude Code MCP doc.

GitHub Copilot:

• Click Save after adding the MCP configuration in repo settings. Use the GitHub Copilot MCP doc for the exact Settings path on github.com.

Step 5: Restart and Auto-Verify

MCP tools are only available to the agent after a restart or refresh — newly added MCP servers do not appear mid-session.

1. Tell the user to enable the server and restart. Before restarting, they need to make sure the MCP server is toggled on and authorized in their editor's MCP settings (e.g. in Cursor: toggle on the LaunchDarkly server and click Connect). Then restart or refresh the agent — be specific about how: "Restart Cursor" / "reload Claude Code" / "refresh the Copilot agent" depending on what you detected in Step 1. After the user restarts, the conversation will resume in a new turn. 2. On the next turn, probe silently. Call a lightweight MCP tool (e.g. list-feature-flags with the user's project key). Do not ask the user whether MCP is working — just try it.

• Success (normal response, even an empty flag list): MCP is live. Note it in the onboarding log and continue.
• Failure (tool not found, auth error, timeout): fall back to ldcli/API. Note the fallback in the onboarding log. Do not block the rest of onboarding — Steps 5-6 must still be completable without MCP.

3. If the probe fails, briefly tell the user MCP isn't available yet and that you'll use ldcli/API instead. Offer a one-liner they can try later to re-enable MCP (e.g. "You can set up MCP anytime by clicking [quick install link] and restarting"). 4. If the failure looks like a config issue (wrong file path, missing OAuth, server not enabled), mention the likely cause so the user can fix it on their own time — but do not block progress.

For local `npx` server verification, see MCP Config Templates — Verify (local server).

Local MCP: Access Token Setup

When the user needs the local `npx` server (federal/EU or other cases where hosted MCP is unavailable), the server requires a LAUNCHDARKLY_ACCESS_TOKEN. This is a sensitive credential.

First, tell the user how to create a token if they don't already have one:

Create an API access token at app.launchdarkly.com/settings/authorization/tokens/new. Give it a descriptive name (e.g. "MCP server") and at minimum the Reader role. Copy the token — you won't be able to see it again after leaving the page.

Then ask how they want to add the token to the MCP config:

D4-LOCAL -- BLOCKING: Call your structured question tool now.

• question: "The local MCP server needs an API access token to authenticate with LaunchDarkly. You can create one at app.launchdarkly.com/settings/authorization/tokens/new. Once you have the token, how would you like to add it to your MCP config? We recommend adding it yourself — there is a non-zero risk when an AI agent handles secrets, as tokens may persist in conversation history, logs, or model context."
• options:
• "I'll add the token to the config myself — just tell me which file and variable"
• "I have the token ready — go ahead and help me wire up the config"
• STOP. Do not write the question as text. Do not write any token value to a config file before the user selects an option.

If the user adds the token themselves: 1. Tell them the config file path for their agent (see MCP Config Templates) 2. Tell them to set LAUNCHDARKLY_ACCESS_TOKEN as the value — either as an environment variable or directly in the config file 3. Remind them to add the config file to .gitignore if the token is inline 4. Wait for them to confirm, then proceed to Step 5 (Restart and Auto-Verify)

If the user wants agent-assisted setup: 1. Ensure the config file is in .gitignore before writing 2. Write the config per MCP Config Templates 3. Remind the user that the token will be visible in the config file and conversation history 4. Proceed to Step 5 (Restart and Auto-Verify)

Edge Cases

• User already has MCP configured: Verify by checking for existing LD MCP entries in the config. If present and working, skip configuration.
• User has the old npx-based local server: Migrate them. Remove the old npx @launchdarkly/mcp-server entry and any LD_ACCESS_TOKEN env vars. Replace with the hosted server config.
• Federal or EU instances: The hosted MCP server is not available for federal or EU environments. Use local MCP server docs and the Local server via `npx` section in MCP Config Templates. Follow the Local MCP: Access Token Setup flow for token handling.
• Agent not in known list: Provide the generic pattern: the user needs to add an MCP server entry pointing to https://mcp.launchdarkly.com/mcp/fm using whatever format their agent expects.
• User opts out of MCP during onboarding: Document that choice and continue with the parent skill's ldcli/API fallbacks for environments and flags; do not block SDK work.

What NOT to Do

• Don't configure the old npx-based local server by default. Prefer the hosted server for standard regions.
• Don't ask for or store API keys for the hosted server. The hosted server uses OAuth.
• Don't add both servers by default. Only add AI Configs if the user asks for it.
• Don't handle the access token for local MCP without asking the user first via the D4-LOCAL decision point.

References

• MCP UI links — HTTPS + command: links to open MCP settings (Cursor, VS Code, Claude Code, Windsurf, GitHub)
• MCP Config Templates — hosted OAuth JSON per agent; Local server via `npx` fallback; migration from old local server
• Official MCP docs — full hosted setup guide

MCP Config Templates

Per-agent JSON snippets for configuring the LaunchDarkly hosted MCP server. All configurations use OAuth -- no API keys required.

Source: https://launchdarkly.com/docs/home/getting-started/mcp-hosted

Cursor

Config file: .cursor/mcp.json in the project root.

Feature management only

{
  "mcpServers": {
    "LaunchDarkly feature management": {
      "url": "https://mcp.launchdarkly.com/mcp/fm",
      "headers": {}
    }
  }
}

Both servers

{
  "mcpServers": {
    "LaunchDarkly feature management": {
      "url": "https://mcp.launchdarkly.com/mcp/fm",
      "headers": {}
    },
    "LaunchDarkly AI Configs": {
      "url": "https://mcp.launchdarkly.com/mcp/aiconfigs",
      "headers": {}
    }
  }
}

After adding the config: enable the servers and complete OAuth in Cursor's MCP UI. Use MCP UI links — Cursor (HTTPS doc + optional command: links); do not rely only on nested Settings menu paths.

Claude Code

Config file: .mcp.json in the project root, or ~/.claude.json for global config.

Feature management only

{
  "mcpServers": {
    "LaunchDarkly feature management": {
      "type": "http",
      "url": "https://mcp.launchdarkly.com/mcp/fm"
    }
  }
}

Both servers

{
  "mcpServers": {
    "LaunchDarkly feature management": {
      "type": "http",
      "url": "https://mcp.launchdarkly.com/mcp/fm"
    },
    "LaunchDarkly AI Configs": {
      "type": "http",
      "url": "https://mcp.launchdarkly.com/mcp/aiconfigs"
    }
  }
}

Authorization happens automatically via OAuth prompt on first MCP tool call.

GitHub Copilot

Configured via the GitHub web UI, not a local config file.

1. Navigate to the target repository on GitHub 2. Go to Settings > Code and automation > Copilot > Coding agent 3. In the MCP configuration section, add:

{
  "mcpServers": {
    "LaunchDarkly feature management": {
      "url": "https://mcp.launchdarkly.com/mcp/fm",
      "headers": {}
    }
  }
}

4. Click Save

Windsurf

Windsurf uses a similar MCP configuration format. Add to the agent's MCP config:

{
  "mcpServers": {
    "LaunchDarkly feature management": {
      "url": "https://mcp.launchdarkly.com/mcp/fm"
    }
  }
}

Consult Windsurf's documentation for the exact config file location.

Migrating from the Old Local Server

If the user has the old npx-based server configured, replace it:

Remove this:

{
  "mcpServers": {
    "LaunchDarkly": {
      "command": "npx",
      "args": [
        "-y", "--package", "@launchdarkly/mcp-server",
        "--", "mcp", "start",
        "--api-key", "api-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
      ]
    }
  }
}

Replace with the hosted config for the relevant agent (see sections above).

Also remove any LD_ACCESS_TOKEN or LAUNCHDARKLY_API_KEY environment variables that were used for the local server. The hosted server handles authentication via OAuth.

Local server via npx

Use the local MCP server when hosted MCP is not available — for example, EU or Federal environments — or when your setup requires it. See local MCP server docs. This path uses `LAUNCHDARKLY_ACCESS_TOKEN` (API access token) instead of OAuth.

Security: Protect tokens in MCP config files

Most editors (Cursor, VS Code, Claude Desktop) require literal tokens in MCP config — they don't expand ${VAR} syntax. To prevent accidental commits:

1. Add MCP config files to `.gitignore`:

   .cursor/mcp.json
   .vscode/mcp.json

2. Or use user-level config (outside the repo) where the editor supports it

Exception: Claude Code supports ${LAUNCHDARKLY_ACCESS_TOKEN} env var syntax — use it when available.

Claude Code (project .mcp.json)

{
  "mcpServers": {
    "launchdarkly": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@launchdarkly/mcp-server"],
      "env": {
        "LAUNCHDARKLY_ACCESS_TOKEN": "${LAUNCHDARKLY_ACCESS_TOKEN}"
      }
    }
  }
}

Set LAUNCHDARKLY_ACCESS_TOKEN in the environment or use your agent’s secret mechanism per Claude Code MCP docs. For user-wide config, merge the same mcpServers.launchdarkly entry into ~/.claude/settings.json if appropriate.

Cursor (.cursor/mcp.json)

Add `.cursor/mcp.json` to `.gitignore` — Cursor requires a literal token value.

{
  "mcpServers": {
    "launchdarkly": {
      "command": "npx",
      "args": ["-y", "@launchdarkly/mcp-server"],
      "env": {
        "LAUNCHDARKLY_ACCESS_TOKEN": "YOUR_ACCESS_TOKEN"
      }
    }
  }
}

Claude Desktop (claude_desktop_config.json)

Claude Desktop config is user-level (not in repos), so token exposure risk is lower.

{
  "mcpServers": {
    "launchdarkly": {
      "command": "npx",
      "args": ["-y", "@launchdarkly/mcp-server"],
      "env": {
        "LAUNCHDARKLY_ACCESS_TOKEN": "YOUR_ACCESS_TOKEN"
      }
    }
  }
}

VS Code / Copilot (.vscode/mcp.json)

Add `.vscode/mcp.json` to `.gitignore` — VS Code requires a literal token value.

{
  "servers": {
    "launchdarkly": {
      "command": "npx",
      "args": ["-y", "@launchdarkly/mcp-server"],
      "env": {
        "LAUNCHDARKLY_ACCESS_TOKEN": "YOUR_ACCESS_TOKEN"
      }
    }
  }
}

Replace YOUR_ACCESS_TOKEN with the user’s LaunchDarkly API access token. After editing, restart the editor or reload MCP.

Verify (local server)

1. If you have MCP tool access, call `list-feature-flags` with the user’s projectKey (e.g. request: { "projectKey": "YOUR_PROJECT_KEY" }). A normal response confirms the server and token. 2. If MCP tools are not visible yet, have the user run `ldcli flags list` (or curl the REST API) to validate credentials independently while MCP reloads.

Open MCP settings (links instead of menu paths)

Use this reference when onboarding tells the user to enable MCP, connect OAuth, or open MCP configuration. Give clickable links—do not rely only on "Settings → … → Tools & MCP" prose.

How to use (agents)

1. Use the row for the detected client (see parent onboarding Step 2: Detect the Agent). 2. Always include the HTTPS documentation link for that client—it opens in the browser and works from any environment. 3. When the user is in VS Code or Cursor, also include the `command:` links on their own lines so they can click in the editor chat (same scheme VS Code uses for trusted markdown). If a command: link is not clickable or does nothing, fall back to the doc link or Command Palette text below. 4. Path caveat: LaunchDarkly's Cursor template uses project .cursor/mcp.json. VS Code's MCP: Open User/Workspace Configuration commands open VS Code's mcp.json locations (often under .vscode/ or the user profile)—not .cursor/mcp.json. If the user edited .cursor/mcp.json, point them at the Cursor doc link or "open .cursor/mcp.json in the editor" plus Cursor's MCP panel.

Clients

Command Palette text (fallback)

If links are not clickable:

• VS Code / Cursor: Run MCP: Open User Configuration, MCP: Open Workspace Folder Configuration, or MCP: List Servers from the Command Palette (⇧⌘P / Ctrl+Shift+P). Alternatively Preferences: Open Settings (UI) and search `mcp`.
• Cursor: See the Cursor MCP doc for the current location of the MCP tools list and OAuth Connect (labels such as Tools & MCP or MCP vary by version).

Command link encoding note

command:workbench.action.openSettings? links pass a JSON array argument (URL-encoded). Example: query mcp → ?%5B%22mcp%22%5D is ["mcp"]. Adjust the search string if the UI does not filter as expected (e.g. try "Tools MCP").