Integrate Unleash with GitHub Copilot

The Unleash MCP server connects GitHub Copilot to your Unleash instance, enabling AI-assisted feature flag management directly in your IDE. You can evaluate code changes, create flags, automatically wrap changes in feature flags, manage rollouts, and clean up flags without leaving your editor.

GitHub Copilot supports MCP in several environments:

• Visual Studio Code with full MCP support available in versions 1.102+.
• JetBrains IDEs with IntelliJ IDEA, PyCharm, WebStorm, and others AI Assistant.
• Visual Studio with the GitHub Copilot extension.
• Neovim with community plugins like mcphub.nvim.
• Copilot CLI, a command-line interface.
• On GitHub.com, a web-based Copilot (no MCP support).

Prerequisites

Before you begin, make sure you have the following:

• Node.js 18 or later: the MCP server is distributed as an npm package.
• A supported IDE, see environment-specific requirements here.
• An Unleash instance: cloud or self-hosted, with API access enabled.
• A personal access token (PAT) with permissions to create and manage feature flags.

Install the MCP server

The Unleash MCP server runs as a local stdio process. Configuration differs by environment, but all IDEs use the same npm package and credentials.

First, create a shared credentials file that works across all environments:

$
UNLEASH_BASE_URL={{UNLEASH_BASE_URL}}
$
UNLEASH_PAT={{UNLEASH_PAT}}
$
UNLEASH_DEFAULT_PROJECT={{UNLEASH_DEFAULT_PROJECT}}

Configure your IDE

1
{
2
  "servers": {
3
    "unleash-mcp": {
4
      "name": "Unleash MCP",
5
      "type": "stdio",
6
      "command": "npx",
7
      "args": ["-y", "@unleash/mcp@latest", "--log-level", "error"],
8
      "envFile": "~/.unleash/mcp.env"
9
    }
10
  }
11
}

Verify the installation

After configuring your IDE, verify that the Unleash MCP tools are available (full list below).

Try one of the following prompts (or the prompt patterns below):

1. Show me the available tools of the Unleash MCP server.
2. Use the Unleash MCP server to get the flag state of `your-flag-name`
3. Use the Unleash MCP server to wrap the current change in a feature flag

Tool reference

The Unleash MCP server exposes nine tools. The following table summarizes each tool and when to use it.

Workflows

This section describes common workflows for using the Unleash MCP server with GitHub Copilot.

Evaluate and wrap a risky change

Use this workflow when you’re implementing a change that might affect production stability, such as a payment integration, authentication flow, or external API call.

Evaluate whether the Stripe payment integration should be behind a feature flag.
The change modifies the checkout service and handles credit card processing.

Create a release flag for the Stripe payment integration.

Wrap the Stripe checkout handler with the stripe-payment-integration flag.
This is a Node.js Express application.

1
const { isEnabled } = require('unleash-client');
2
3
app.post('/checkout', async (req, res) => {
4
  const context = { userId: req.user.id };
5
6
  if (isEnabled('stripe-payment-integration', context)) {
7
    // New Stripe payment flow
8
    const result = await stripeService.processPayment(req.body);
9
    return res.json(result);
10
  } else {
11
    // Existing payment flow
12
    const result = await legacyPaymentService.process(req.body);
13
    return res.json(result);
14
  }
15
});

Manage rollouts across environments

Use this workflow to enable a flag in staging for testing while keeping it disabled in production.

What is the current state and rollout strategies for stripe-payment-integration?

Clean up after rollout

Use this workflow when a feature has been fully rolled out and the flag is no longer needed.

Clean up the stripe-payment-integration flag. The feature is fully rolled out.

Copilot calls cleanup_flag and returns:

• All files and line numbers where the flag is used.
• Which code path to preserve (the “enabled” branch).
• Suggestions for tests to run after removal.

Review the list, remove the conditional branches, and delete the flag from Unleash.

Define custom instructions

You can configure project-level instructions to make feature flag evaluation automatic. When custom instructions are present, Copilot considers them on every interaction.

Create a file at .github/copilot-instructions.md in your repository:

1
## Feature flag policy
2
3
When implementing new features or modifying high-risk code paths:
4
5
1. Always use the `evaluate_change` tool to assess whether the change needs a feature flag
6
2. Prefer reusing existing flags over creating new ones (use `detect_flag`)
7
3. Follow kebab-case naming: `domain-action-variant`
8
4. All payment, authentication, and external API changes MUST be flagged
9
5. Use `wrap_change` to generate framework-appropriate guard code
10
11
Default project: `checkout-team`

With these instructions in place, when a developer asks Copilot to “add Stripe payments,” Copilot automatically evaluates, detects, creates, and wraps without explicit prompting.

Prompt patterns

The following prompt patterns help you use the MCP tools effectively.

Evaluate whether the [description of change] should be behind a feature flag.
The change modifies [component/service].

Before creating a new flag for [feature], check if a similar flag already exists
and suggest reusing it if appropriate.

Enable [flagName] in the staging environment.

What is the current state and rollout strategies for [flagName]?

Clean up the [flagName] flag now that the feature has fully shipped.

Clean up the [flagName] flag after the A/B testing experiment, only keep [variant].

Troubleshooting

Best practices

Follow these guidelines for effective feature flag management with AI assistants.

Architecture

The following diagram shows how the Unleash MCP server fits into your development workflow.

┌────────────────────────────────────────────────────────────┐
│                     Developer workflow                     │
├────────────────────────────────────────────────────────────┤
│                                                            │
│   ┌──────────────┐           ┌──────────────────┐          │
│   │   Your IDE   │     MCP   │   Unleash MCP    │          │
│   │  + Copilot   │◄─────────►│  server (local)  │          │
│   └──────────────┘    stdio  └────────┬─────────┘          │
│                                       │                    │
│   VS Code, JetBrains,                 │ HTTPS              │
│   Visual Studio, Neovim               │                    │
│                               ┌───────▼───────────┐        │
│                               │ Unleash Admin API │        │
│                               └───────┬───────────┘        │
│                                       │                    │
├───────────────────────────────────────│────────────────────┤
│                    Runtime evaluation                      │
├───────────────────────────────────────│────────────────────┤
│                                       │                    │
│   ┌──────────────────┐          ┌─────▼─────────────┐      │
│   │ Your application │◄────────►│ Unleash SDK / Edge│      │
│   └──────────────────┘  Feature └───────────────────┘      │
│                          flags                             │
│                                                            │
└────────────────────────────────────────────────────────────┘

Key points:

• The MCP server runs locally on your machine as a stdio process.
• It communicates with the Unleash Admin API using your PAT.
• Feature flag evaluations happen locally in your application via SDKs or Unleash Edge.
• No user data is sent to the Unleash server during flag evaluation.

Related resources

• Unleash MCP server on GitHub
• GitHub Copilot meets progressive delivery
• How to automate feature flags in GitHub Copilot
• Impact Metrics
• Unleash architecture overview
• Visual Studio Code MCP server documentation