# Unleash MCP

> Unleash connects your AI agent directly to your feature flag system. It lets you manage complex product rollouts—from auditing environments to checking if a specific user sees a new beta feature—all through natural conversation. You can evaluate flags, list projects, and monitor usage metrics without ever opening the Unleash UI.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** feature-flags, feature-management, deployment-strategies, rollout-control, environment-management, software-development

## Description

Managing features across different parts of your application is complicated. You need to know if 'new-dashboard-v2' should only show up for internal users or if it’s rolled out globally, depending on where the request comes from. This MCP gives your agent full control over that process.

It lets you audit your entire feature setup—listing all projects and environments configured across your infrastructure. You can verify targeting rules by listing users and segments, checking who is supposed to see what. Need to know if a flag works for the backend or only on the client side? The agent handles it. Plus, you don't have to manually report usage metrics; you can send that data straight back through your AI client, making sure everything stays synced. When you connect this MCP via Vinkius, your entire feature lifecycle becomes conversational.

## Tools

### list_environments
Retrieves a comprehensive list of all operational environments configured in Unleash.

### list_project_features
Lists every single feature flag defined within a specific project ID.

### list_projects
Fetches an exhaustive list of all projects managed by Unleash.

### list_segments
Retrieves details on every user segment configured in your feature management system.

### list_users
Provides a list of all individual users and their associated IDs within Unleash.

### get_client_features
Fetches the complete set of feature flags and strategies for server-side evaluation.

### report_client_metrics
Sends flag usage metrics data reported from a backend SDK instance.

### register_client
Registers and authenticates a new backend SDK instance for metric reporting.

### get_frontend_features
Determines which feature flags are enabled by optionally providing context like user IDs or properties.

### report_frontend_metrics
Sends flag usage metrics data reported from a frontend SDK instance.

### register_frontend
Registers and authenticates a new frontend SDK instance for metric reporting.

## Prompt Examples

**Prompt:** 
```
List all Unleash projects and their descriptions.
```

**Response:** 
```
I've retrieved the projects. You have 3 projects: 'Default' (Main project), 'Mobile-App' (Flags for iOS/Android), and 'Beta-Testing' (Experimental features).
```

**Prompt:** 
```
What feature flags are enabled for user 'user_88' in the frontend?
```

**Response:** 
```
Evaluating flags for 'user_88'... The following flags are enabled: 'new-dashboard-v2', 'dark-mode-beta', and 'premium-checkout'. Flags like 'experimental-chat' remain disabled for this user context.
```

**Prompt:** 
```
Show me all feature flags in the 'Mobile-App' project.
```

**Response:** 
```
In the 'Mobile-App' project, I found 4 flags: 'biometric-login' (Enabled), 'offline-mode' (Disabled), 'push-notifications-v3' (Enabled), and 'legacy-sync' (Disabled).
```

## Capabilities

### Audit Infrastructure Layout
List every project, environment, and segment defined in your Unleash system to understand the full scope of your feature management.

### Determine Feature Visibility by Context
Evaluate which features are enabled for a specific user, or based on client properties, simulating how your application will render flags in real time.

### Manage and Inspect Flag Statuses
Get comprehensive details on all feature flags within a project, verifying their current rollout status and strategy configurations.

### Track Usage Metrics
Report flag usage data from both backend SDKs and frontend clients directly through the agent's tools.

## Use Cases

### Checking Rollout Scope for a Beta Feature
A PM needs to confirm if the 'new-dashboard-v2' feature is visible only to internal users. They ask their agent, and it uses `get_frontend_features` to check the flag status using specific user properties, providing an instant yes/no answer without needing a sandbox environment.

### Auditing Multi-Environment Configuration
An SRE suspects a staging environment is configured incorrectly. They use `list_environments` and then `list_projects` to quickly map out the entire infrastructure layout, identifying which project belongs to which deployment stage.

### Verifying Backend Feature Availability
A developer needs to know if a certain feature is enabled for the backend API. They ask their agent, and it invokes `get_client_features`, returning the full server-side flag status list immediately.

### Tracking Live User Behavior
The team needs to track how often users interact with a new checkout flow. An engineer uses `register_frontend` first, then calls `report_frontend_metrics`, ensuring the usage data flows back into their analytics dashboard.

## Benefits

- Stop relying on guesswork. You can check the exact status of a feature flag for a specific user context using the `get_frontend_features` tool, verifying visibility before code deployment.
- Gain total infrastructure oversight by running `list_projects`, `list_environments`, and `list_segments` directly through your agent—all without leaving your chat interface.
- Automate metric reporting. Instead of manually compiling usage data, you can use `report_client_metrics` or `report_frontend_metrics` to feed live analytics back into the system.
- Simplify user validation. The agent lets you call `list_users` and `list_segments`, allowing you to quickly verify targeting rules for complex rollouts.
- Speed up development cycles. You can use `get_client_features` to audit the entire feature set on the server side, making sure all flags are accounted for before a major release.

## How It Works

The bottom line is you gain an API-driven conversational interface to manage complex, mission-critical feature rollouts without writing code or navigating web UIs.

1. Subscribe to this MCP, then enter your Unleash API URL and the required API Token (whether it’s for Admin, Client, or Frontend access).
2. Your AI client authenticates with the platform, giving your agent full read/write control over feature flag data.
3. You simply ask your agent questions—like 'What flags are active for user 123?'—and get immediate answers backed by your Unleash source of truth.

## Frequently Asked Questions

**How do I check if a feature flag works on the backend with Unleash (Feature Toggles) MCP?**
You use the `get_client_features` tool. This fetches all feature flags and strategies specifically for server-side evaluation, giving you the definitive backend status.

**Can I list user data using Unleash (Feature Toggles) MCP?**
Yes, use the `list_users` tool. It fetches a comprehensive list of all users configured in your feature management system so you can verify targeting rules.

**What if I need to track usage data from my mobile app? Should I use Unleash (Feature Toggles) MCP?**
Yes. You should register the client using `register_client` and then send usage metrics with `report_client_metrics` to ensure your backend SDK is reporting accurately.

**Is Unleash (Feature Toggles) MCP better than just checking flags in the UI?**
Absolutely. The agent allows you to chain together multiple checks—like listing projects, then checking flag status for a segment—in one go, which is impossible manually.

**How do I ensure my frontend metrics are tracked correctly with Unleash (Feature Toggles) MCP?**
First, use `register_frontend` to authenticate the web instance. Then, pass usage data via `report_frontend_metrics` for accurate front-end tracking.