Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@FFS MCP Server check if account 123456 has the 'call-recording' flag enabled"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP (Model Context Protocol) Server for managing FFS (Feature Flag Service).
🔐 ffs_get_user_info: Get AccountId and ExtensionId from RingCentral credentials
🔍 ffs_search_flag: Search for FFS flags by keyword
📋 ffs_get_flag_options: Get all available options for a Flag
✅ ffs_check_account: Check account status in a Flag
✏️ ffs_update_account: Update account's Flag value
Related MCP server: @shipeasy/mcp
The server requires the following environment variables:
Variable | Description | Required |
| FFS API base URL | ✅ |
| RingCentral API URL | ✅ |
| Base64 encoded client credentials | ✅ |
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"ffs": {
"command": "npx",
"args": ["@xcodeyang/ffs-mcp-server"],
"env": {
"FFS_BASE_URL": "http://your-ffs-server:8080",
"FFS_RC_API_URL": "https://your-rc-api-server",
"FFS_RC_CLIENT_CREDENTIALS": "your-base64-credentials"
}
}
}
}{
"augment.advanced": {
"mcpServers": [
{
"name": "ffs",
"command": "npx",
"args": ["@xcodeyang/ffs-mcp-server"],
"env": {
"FFS_BASE_URL": "http://your-ffs-server:8080",
"FFS_RC_API_URL": "https://your-rc-api-server",
"FFS_RC_CLIENT_CREDENTIALS": "your-base64-credentials"
}
}
]
}
}# Build first
npm run build
# Publish to RingCentral Nexus registry
npm publishGet AccountId and ExtensionId from RingCentral credentials.
Input:
username: RingCentral user email
password: RingCentral password
Output:
accountId: Company-level ID (affects all users in the company)
extensionId: User-level ID (affects only this user)
Search for FFS flags by keyword.
Input:
keyword: Search keyword or complete Flag ID
Get all available options for a Flag.
Input:
flagId: Complete FFS Flag ID
Output:
List of options with valueId (needed for updates)
Check account status in a Flag.
Input:
flagId: Complete FFS Flag ID
id: AccountId or ExtensionId
Update account's Flag value using MCP Auto Condition.
Input:
flagId: Complete FFS Flag ID
id: AccountId or ExtensionId
targetValueId: Value ID from ffs_get_flag_options
# Run in development mode
npm run dev
# Build
npm run build
# Test tools
npx tsx test-tools.tsCheck the current status of an AccountId or ExtensionId in a Flag.
| Name | Required | Description | Default |
|---|---|---|---|
| flagId | Yes | Complete FFS Flag ID | |
| id | Yes | AccountId or ExtensionId to check |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool checks status but doesn't explain what 'status' entails (e.g., enabled/disabled, active/inactive), whether it's a read-only operation, if it requires authentication, or any rate limits. This leaves significant gaps in understanding the tool's behavior beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy to parse quickly, and every part of the sentence contributes essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 2 parameters with full schema coverage and no output schema, the description adequately covers the basic purpose. However, it lacks details on what 'status' means in the return value, which is crucial since there's no output schema. For a status-checking tool with no annotations, more context on the expected output or behavioral traits would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters ('flagId' and 'id') with clear descriptions. The description adds minimal value by mentioning 'AccountId or ExtensionId' for the 'id' parameter, but doesn't provide additional context like format examples or constraints beyond what the schema states, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Check'), the target ('status of an AccountId or ExtensionId'), and the context ('in a Flag'). It specifies what resource is being operated on, though it doesn't explicitly differentiate from sibling tools like 'ffs_get_user_info' or 'ffs_search_flag' which might also retrieve status information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'ffs_get_user_info' or 'ffs_search_flag'. It lacks context about prerequisites, such as whether the flag must exist or if the ID needs to be valid, and doesn't mention any exclusions or specific scenarios for its use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all available options (values) for a Flag. Shows Value IDs needed for updates.
| Name | Required | Description | Default |
|---|---|---|---|
| flagId | Yes | Complete FFS Flag ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), but doesn't mention any behavioral traits such as permissions required, rate limits, error handling, or what the output format looks like (e.g., list of values). This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose. It's front-loaded and wastes no words, though it could be slightly more structured by separating usage hints into a second sentence. Overall, it's appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations, no output schema, and a simple input schema, the description is incomplete. It doesn't explain what the return values look like (e.g., a list of options with IDs and labels), any dependencies, or error cases. For a tool that fetches data, more context on output behavior is needed to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'flagId' documented as 'Complete FFS Flag ID'. The description adds minimal value beyond this by implying the parameter is used to fetch options for a specific flag, but doesn't provide additional context like format examples or constraints. Baseline 3 is appropriate given the high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'all available options (values) for a Flag', making the purpose understandable. However, it doesn't explicitly differentiate this from sibling tools like 'ffs_search_flag' or 'ffs_update_account', which might also involve flags, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'Value IDs needed for updates', which hints at a use case for preparing updates, but doesn't specify when to choose this over other tools like 'ffs_search_flag' or what prerequisites exist. This leaves usage context largely implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get AccountId and ExtensionId from RingCentral credentials. Use ExtensionId for individual user, AccountId for entire company.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | RingCentral user email, e.g., user@example.com | |
| password | Yes | RingCentral password |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the core behavior (retrieving IDs from credentials) but lacks details on authentication requirements, error handling, rate limits, or response format. It adds some context about credential usage but misses broader behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded and highly concise with two clear sentences: one stating the purpose and another providing usage guidance. Every word earns its place without redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (2 parameters, no output schema, no annotations), the description is reasonably complete for its purpose. It explains what the tool does and how to use the outputs, though it could benefit from mentioning response format or error cases to be fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (username and password) fully. The description doesn't add any parameter-specific details beyond what the schema provides, such as format examples or constraints, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Get AccountId and ExtensionId') and resources ('from RingCentral credentials'), distinguishing it from siblings like ffs_check_account or ffs_update_account by focusing on credential-based ID retrieval rather than account checking or updating.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit usage guidance by specifying when to use the returned IDs: 'Use ExtensionId for individual user, AccountId for entire company.' This helps differentiate from alternatives by clarifying the context for each output, though it doesn't name specific sibling tools for comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for FFS flags by keyword. Returns matching flags with their IDs and types.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Search keyword or complete Flag ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool searches and returns data, implying a read-only operation, but doesn't cover critical aspects like authentication needs, rate limits, error handling, or pagination. For a search tool with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Search for FFS flags by keyword') and adds necessary detail about returns. There is no wasted verbiage or redundancy, making it appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain the return format in detail (e.g., structure of 'matching flags'), error conditions, or behavioral constraints. For a search tool with no structured output documentation, more context is needed to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'keyword' parameter fully documented in the schema. The description adds minimal value by restating that it searches 'by keyword' and mentions 'complete Flag ID,' but this is already implied in the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for FFS flags by keyword.' It specifies the verb ('Search') and resource ('FFS flags'), and mentions the return format ('matching flags with their IDs and types'). However, it doesn't explicitly differentiate this search tool from its siblings (e.g., ffs_get_flag_options), which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, exclusions, or comparisons with sibling tools like ffs_get_flag_options or ffs_check_account. The agent must infer usage from the tool name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update an AccountId or ExtensionId to use a specific Flag value. Uses MCP Auto Condition for management.
| Name | Required | Description | Default |
|---|---|---|---|
| flagId | Yes | Complete FFS Flag ID | |
| id | Yes | AccountId or ExtensionId to update | |
| targetValueId | Yes | Target Value ID from ffs_get_flag_options |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates an update operation, implying mutation, but doesn't specify permissions required, whether changes are reversible, error handling, or rate limits. The mention of 'MCP Auto Condition for management' adds some context but is vague, failing to fully compensate for the lack of annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences that efficiently convey the tool's purpose and mechanism. It avoids unnecessary details and is front-loaded with the core action. However, the second sentence about 'MCP Auto Condition' could be more specific to enhance clarity without adding length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an update operation with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., side effects, permissions), response format, or error conditions. While the schema covers parameters well, the overall context for safe and effective use is incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (flagId, id, targetValueId) with clear descriptions. The description adds minimal value by implying the parameters are used for updating a flag value, but it doesn't provide additional syntax, format details, or usage examples beyond what the schema offers, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and the target ('an AccountId or ExtensionId'), specifying what gets updated ('to use a specific Flag value'). It distinguishes from siblings like ffs_check_account (which likely checks rather than updates) and ffs_get_flag_options (which likely retrieves options). However, it doesn't explicitly differentiate from ffs_search_flag or ffs_get_user_info, keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'Uses MCP Auto Condition for management,' which provides some context about the mechanism, but it doesn't offer explicit guidance on when to use this tool versus alternatives like ffs_check_account or ffs_search_flag. No prerequisites, exclusions, or clear scenarios are stated, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0ffs_check_accountffs_get_flag_optionsffs_get_user_infoffs_search_flagffs_update_accountEach tool has a clearly distinct purpose: checking account status, getting flag options, retrieving user info, searching flags, and updating accounts. There is no overlap in functionality, and the descriptions make the boundaries explicit, preventing agent misselection.
All tools follow a consistent 'ffs_verb_noun' pattern with snake_case, such as ffs_check_account and ffs_update_account. This predictability makes the tool set easy to navigate and understand at a glance.
With 5 tools, the server is well-scoped for managing FFS flags and accounts. Each tool serves a specific, necessary function without redundancy, fitting typical expectations for a focused utility server.
The tool set covers core CRUD-like operations for FFS management: checking, searching, getting info, and updating. A minor gap exists in not having a tool to create or delete flags, but the available tools support key workflows without dead ends.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for Statsig API - interact with Statsig's feature flags, experiments, and analytics
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
The Fireflies MCP Server enables AI tools to connect directly to meeting data from Fireflies.ai, providing access to meeting transcripts, summaries, action items, and insights without switching platforms. It includes capabilities for querying cross-meeting data for analysis (such as sales insights or product feedback), and a separate Documentation MCP Server that allows searching the Fireflies knowledge base for API references, guides, and code examples.
The Remote MCP server acts as a standardized bridge between LLM applications (like Claude, ChatGPT, and Cursor) and external services, enabling AI agents to access external tools and resources. Its primary capability is providing a centralized search tool to discover other MCP servers and their respective tools. Unlike local implementations, it runs remotely with OAuth authentication and permission controls for security.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ZhipingYang/ffs-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
