GrowthBook MCP Server

Official

by growthbook

Overview Schema Related Servers Score Discussions

TypeScript

Remote

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, such as create_feature_flag vs. create_force_rule, but there is some overlap between get_feature_flags and get_single_feature_flag, which could cause confusion if an agent needs to fetch a specific flag versus all flags. The descriptions help clarify, but the boundary is not perfectly clear.
Naming Consistency4/5
The naming follows a consistent verb_noun pattern (e.g., create_feature_flag, get_experiments) with minor deviations like generate_flag_types (which uses 'generate' instead of 'get') and search_growthbook_docs (which includes 'growthbook' in the name). Overall, it is mostly predictable and readable.
Tool Count5/5
With 14 tools, the count is well-scoped for a GrowthBook MCP server, covering key operations like creating flags, rules, connections, and fetching various resources. Each tool appears to earn its place without feeling excessive or insufficient for the domain.
Completeness4/5
The tool set provides good coverage for core GrowthBook operations, including CRUD-like actions for features, experiments, and connections, but there are minor gaps such as missing update or delete tools for flags or experiments, which agents might need to work around. The inclusion of search_growthbook_docs adds helpful context.
Average 2.9/5 across 14 of 14 tools scored. Lowest: 1.8/5.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 6 community issues answered or closed in the last 6 months
- 10 commits in the last 12 weeks
- Last stable release on August 11, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
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. 'Get all attributes' doesn't reveal anything about permissions, rate limits, pagination, response format, or whether this is a read-only operation. It fails to provide essential context needed for safe and effective tool invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
While technically concise with just three words, this is a case of under-specification rather than effective brevity. The description doesn't provide enough information to be useful. Every sentence should earn its place, but here the single phrase fails to convey meaningful context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
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 completely inadequate. It doesn't explain what 'attributes' are, what system they belong to, what format they're returned in, or any behavioral characteristics. For a tool with no structured metadata, this minimal description leaves critical gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description doesn't need to compensate for any parameter gaps. While it doesn't add any parameter-specific information beyond what the schema provides, this is acceptable for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get all attributes' is a tautology that essentially restates the tool name 'get_attributes'. It doesn't specify what type of attributes, from what system, or what scope 'all' refers to. While it indicates a retrieval action, it lacks the specificity needed to distinguish it from sibling tools like 'get_feature_flags' or 'get_environments'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
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. There's no mention of context, prerequisites, or comparison to sibling tools like 'get_feature_flags' or 'get_experiments'. Without any usage instructions, an agent would have to guess based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. The description states it's for creation/adding/wrapping, implying a write operation, but doesn't specify what happens after creation (e.g., where the flag is stored, whether it's immediately active, if it requires permissions, or what the response looks like). For a tool with 8 parameters and no annotations, this leaves significant gaps in understanding the tool's behavior and effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence with no wasted words. However, the use of multiple verbs ('Create, add, or wrap') slightly reduces clarity without adding value, and it could be more front-loaded with a clearer primary action. Overall, it's efficient but not perfectly structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 parameters, 4 required, no output schema, and no annotations), the description is inadequate. It doesn't explain the outcome of the creation (e.g., what is returned, where the flag is stored), doesn't differentiate from siblings, and provides minimal behavioral context. For a creation tool with significant parameters, this leaves too many gaps for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all parameters are documented in the schema itself (e.g., 'id' as a unique key name, 'fileExtension' with specific enum values). The description adds no additional meaning about parameters beyond what's in the schema—it doesn't explain how parameters relate to each other or provide usage context. With high schema coverage, the baseline is 3 even without param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create, add, or wrap an element with a feature flag' uses multiple verbs (create, add, wrap) which creates ambiguity about the exact action. It mentions 'feature flag' as the resource but doesn't specify what kind of element is being wrapped or where this creation happens (e.g., in code, in a configuration system). Compared to siblings like 'create_force_rule' or 'create_sdk_connection', it's not clearly differentiated beyond the general domain of feature flags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. There are sibling tools like 'generate_flag_types', 'get_feature_flags', and 'get_single_feature_flag' that might be related, but the description doesn't indicate whether this is for initial creation versus updates, or when to use it versus other creation tools. No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions that users need the key and explains its purpose, which adds some context. However, it doesn't describe important behaviors like whether this is a read-only operation, if it requires authentication, how results are returned (e.g., pagination), or any rate limits. For a tool with no 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with three sentences, but the structure could be improved. The first sentence states the purpose clearly, but the following sentences focus on explaining SDK connections and the key's purpose rather than front-loading critical usage information. Some sentences feel tangential rather than essential for tool selection.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 parameters, no annotations, no output schema), the description is incomplete. It explains what SDK connections are but misses crucial details: parameter meanings, behavioral traits (like read-only status), output format, and differentiation from siblings. For a tool that retrieves potentially sensitive connection data, this leaves too many unanswered questions for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate for undocumented parameters. The description mentions nothing about the three parameters (limit, offset, project) or their purposes. It doesn't explain what 'project' filters, how pagination works with limit/offset, or default values. With zero parameter information in the description, it fails to compensate for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get all SDK connections' (verb+resource). It explains that SDK connections are 'how GrowthBook connects to an app' and mentions the key's purpose, which provides useful context. However, it doesn't explicitly differentiate this from sibling tools like 'create_sdk_connection' or 'get_projects', 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.
Usage Guidelines2/5
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 when this tool is appropriate compared to other get_* tools (like get_feature_flags or get_projects) or when to use create_sdk_connection instead. The mention of the key's purpose is informative but doesn't constitute usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'fetches' implies a read operation, it doesn't mention pagination behavior (implied by limit/offset parameters), authentication requirements, rate limits, or what format the experiments are returned in. The description is too minimal for a tool with parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a simple fetch operation and front-loads the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 parameters, 0% schema description coverage, no annotations, and no output schema, the description is inadequate. It doesn't explain the tool's behavior, parameter meanings, or return format. The description should provide more context about what 'all experiments' means given the pagination parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for 3 parameters, the description provides no information about what 'limit', 'offset', or 'project' mean. It doesn't explain that 'limit' controls pagination size, 'offset' controls pagination starting point, or 'project' filters results. The description fails to compensate for the schema's lack of parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('fetches') and resource ('experiments from the GrowthBook API'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its sibling 'get_experiment' (singular), which appears to fetch a single experiment rather than all experiments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 the sibling 'get_experiment' tool for fetching individual experiments, nor does it explain when filtering by project might be appropriate versus fetching all experiments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 that flags are returned in creation order, which adds useful context, but lacks critical details such as whether this is a read-only operation, authentication requirements, rate limits, error handling, or response format. For a tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded and efficiently uses two sentences with zero waste. The first sentence states the core purpose, and the second adds behavioral context about ordering, making it appropriately sized and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 parameters with 0% schema coverage, no annotations, and no output schema), the description is incomplete. It covers the basic action and result ordering but omits parameter explanations, authentication needs, error handling, and output details, leaving significant gaps for the agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions no parameters at all, failing to explain the purpose of 'limit', 'offset', or 'project'. This leaves the agent guessing about their roles, such as pagination or filtering, which is inadequate given the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('fetches') and resource ('all feature flags from the GrowthBook API'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from its sibling 'get_single_feature_flag', which handles individual flags versus this tool's collection retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'get_single_feature_flag' for individual flags or 'search_growthbook_docs' for documentation. It mentions the ordering of results but doesn't specify use cases, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions the return value (clientKey) and its purpose, but lacks details on permissions, side effects, error conditions, or rate limits. For a creation tool with zero annotation coverage, this leaves significant gaps in understanding its operational behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: one stating the action and resource, and another explaining the return value. It's front-loaded with the core purpose and avoids unnecessary elaboration, though it could be slightly more concise by integrating the return value into the first sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic purpose and return value context but lacks completeness for a creation tool. It doesn't cover error handling, authentication needs, or system impacts. While it meets minimum viability, there are clear gaps in contextual information needed for reliable tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, providing clear documentation for all parameters. The description adds no additional parameter semantics beyond what's in the schema, such as explaining relationships between parameters or usage nuances. Baseline score of 3 is appropriate since the schema adequately covers parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Create' and resource 'SDK connection for a user', specifying that it returns a 'clientKey' for fetching features and experiments. It distinguishes from siblings like 'get_sdk_connections' (read vs. create) but doesn't explicitly differentiate from other creation tools like 'create_feature_flag' or 'create_force_rule'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, appropriate contexts, or comparisons with sibling tools like 'get_sdk_connections' or other creation tools. The description only states what it does, not when to choose it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 this is a read operation ('Gets'), implying it's non-destructive, but doesn't specify permissions required, rate limits, error conditions, or what data is returned. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 for a data retrieval tool. It doesn't explain what an 'experiment' entails in GrowthBook, what fields are returned, or how to interpret results. For a tool that presumably returns structured data, more context is needed to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 'experimentId' clearly documented. The description doesn't add any additional semantic context beyond what the schema provides, such as format examples or where to find experiment IDs. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Gets') and resource ('a single experiment from GrowthBook'), making the purpose unambiguous. However, it doesn't distinguish this tool from its sibling 'get_experiments' (plural), which appears to retrieve multiple experiments, leaving some ambiguity about when to use each.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 the sibling 'get_experiments' for retrieving multiple experiments or clarify if this is for detailed views versus list views. No prerequisites or context for usage are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'fetches' implies a read operation, it doesn't disclose important behavioral traits like authentication requirements, rate limits, pagination behavior (implied by limit/offset parameters but not explained), error conditions, or what 'all projects' means in terms of scope or permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized for a simple fetch operation and front-loads the essential information about what the tool does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read operation with 2 parameters, 0% schema description coverage, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'projects' are in this context, how results are structured, what authentication is required, or any limitations of the fetch operation. The agent would have significant gaps in understanding how to properly use this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for both parameters, the description provides no information about the 'limit' and 'offset' parameters. However, since there are only 2 parameters and they have default values in the schema, the baseline is 3. The description doesn't compensate for the lack of parameter documentation but doesn't make the situation worse.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('fetches') and resource ('all projects from the GrowthBook API'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'get_experiments' or 'get_feature_flags' that also fetch different resources from the same API.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. There's no mention of prerequisites, when-not-to-use scenarios, or comparisons to sibling tools like 'get_experiments' or 'get_feature_flags' that fetch different data types from the same API.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 it 'fetches' data, implying a read-only operation, but doesn't clarify authentication requirements, rate limits, error handling, or the format of the returned data. For a tool with no annotations, this leaves significant gaps in understanding how it behaves in practice.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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's front-loaded with the key action and resource, making it easy to parse. Every part of the sentence earns its place by conveying essential information succinctly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a read operation with 2 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what data is returned, how errors are handled, or dependencies like authentication. For a tool that fetches specific data, more context is needed to ensure reliable use by an agent, especially with siblings that might overlap in functionality.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%, with the 'id' parameter documented but 'project' lacking a description. The tool description mentions 'a specific feature flag', which aligns with the 'id' parameter, but doesn't add meaning beyond what the schema provides for 'id' or clarify the role of 'project'. Since coverage is moderate, the description doesn't fully compensate but doesn't worsen the gap, resulting in a baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('fetches') and resource ('a specific feature flag from the GrowthBook API'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_feature_flags' (plural) or 'get_experiment', which might retrieve similar data. The specificity of 'single' in the tool name helps, but the description could be more explicit about this distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 sibling tools like 'get_feature_flags' for listing multiple flags or 'get_experiment' for related data, nor does it specify prerequisites such as needing a project context. Without this context, an agent might struggle to choose between similar tools in the server.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 implies a read-only operation ('fetches') but does not detail aspects like pagination behavior (implied by 'limit' and 'offset' parameters), error handling, authentication needs, or rate limits. This is a significant gap for a tool with parameters and no structured safety hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence contributes to understanding the tool's function, making it appropriately sized and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 parameters, no annotations, no output schema), the description is incomplete. It lacks details on parameter usage, behavioral traits, and output format, which are crucial for an agent to invoke the tool correctly. The description alone does not provide enough context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate, but it adds no information about the parameters ('limit', 'offset', 'project'). The baseline is 3 because the schema itself defines the parameters with types and defaults, though without descriptions. The description does not enhance understanding of what these parameters mean or how they affect the fetch operation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('fetches') and resource ('all complete safe rollouts from the GrowthBook API'), specifying that these rollouts are either 'rolled-back or released'. However, it does not explicitly differentiate from sibling tools like 'get_experiments' or 'get_feature_flags', which might also retrieve related data from the same API.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, such as other 'get_' tools in the sibling list. It mentions the type of rollouts ('complete safe rollouts') but does not specify use cases, prerequisites, or exclusions, leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool searches documentation, implying a read-only operation, but doesn't disclose behavioral traits like authentication needs, rate limits, response format, or error handling. For a search tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves beyond the basic purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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. Every part of the sentence contributes essential information, earning its place with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple search with one parameter), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the search returns, how results are structured, or any behavioral constraints. For a tool with no structured data beyond the input schema, the description should provide more context to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal meaning beyond the input schema, which has 100% coverage for the single parameter 'query'. It specifies the query is for 'GrowthBook docs on how to use a feature', slightly contextualizing the parameter's purpose, but doesn't provide syntax examples, search scope details, or result limitations. With high schema coverage, the baseline is 3, and the description meets but doesn't exceed this.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search') and the target resource ('GrowthBook docs'), specifying the purpose is to find information 'on how to use a feature'. It distinguishes from siblings by focusing on documentation search rather than operations like creating flags or retrieving data. However, it doesn't explicitly differentiate from potential similar search tools (none exist in siblings), keeping it at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 searching for 'how to use a feature', but doesn't specify contexts, prerequisites, or exclusions. With siblings including various get_* tools for data retrieval, there's no indication of when documentation search is preferred over direct data access, resulting in minimal usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 'fetches all environments,' implying a read-only operation, but doesn't clarify key behaviors such as authentication requirements, rate limits, error handling, or the format of the returned data. The additional context about GrowthBook environments is informative but doesn't address operational traits needed for reliable tool invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise but could be more front-loaded. The first sentence clearly states the purpose, but the following sentences provide general background about GrowthBook environments that, while informative, may not be essential for tool selection. This extra context adds length without directly aiding in tool invocation, reducing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is somewhat complete but has gaps. It explains what the tool does and provides context about environments, which helps understanding. However, it lacks details on behavioral aspects like response format or error conditions, which are important for a tool with no structured output schema, leaving room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter documentation in the description. The description appropriately avoids discussing parameters, focusing instead on the tool's purpose and context. This meets the baseline for tools with no parameters, though it doesn't add value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Fetches all environments from the GrowthBook API.' It uses a specific verb ('fetches') and resource ('environments'), making the action explicit. However, it doesn't distinguish this tool from potential siblings like 'get_projects' or 'get_feature_flags' beyond the resource name, which keeps 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.
Usage Guidelines2/5
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 explains what environments are in GrowthBook (e.g., default production environment, per-environment flag control, project scoping), but this is background information rather than usage instructions. There's no mention of prerequisites, when this tool is appropriate, or what other tools might be better for related tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'Generate types' implies a creation or output operation, but the description doesn't disclose what 'types' refer to (e.g., TypeScript interfaces, JSON schemas), whether this is a read-only or mutating operation, what permissions are needed, or what the output format is. It lacks behavioral context 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse. Every word earns its place by conveying the essential purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and the description's vagueness about what 'types' are and the tool's behavior, this is incomplete. The agent lacks sufficient information to understand what the tool produces or how to use it effectively in context with sibling tools. It should clarify output format and usage scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate. A baseline of 4 is applied since the schema fully covers the absence of parameters, and the description doesn't need to compensate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Generate types for feature flags' clearly states the action (generate) and target resource (types for feature flags). It's specific enough to understand the tool's function, though it doesn't explicitly differentiate from sibling tools like 'get_feature_flags' or 'get_single_feature_flag' which retrieve rather than generate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 prerequisites, context, or relationships to sibling tools like 'create_feature_flag' or 'get_feature_flags'. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It describes the rule's purpose and dependencies but lacks details on permissions, rate limits, error handling, or what happens if the featureId is invalid. It adds some context but misses key behavioral traits for a creation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences front-loaded with the main purpose, followed by prerequisites and alternatives. Each sentence earns its place with no wasted words, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with 6 parameters, 67% schema coverage, and no output schema or annotations, the description is adequate but incomplete. It covers usage and purpose but lacks details on return values, error cases, or full parameter semantics, leaving gaps for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67%, and the description adds value by explaining that force rules set values based on conditions and environments, which clarifies the purpose of parameters like condition and environments beyond the schema. However, it doesn't detail parameter interactions or constraints like value matching feature type specifics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a new force rule on an existing feature, specifying it sets a feature to a specific value for specific environments based on a condition. It distinguishes from sibling create_feature_flag (which creates features) and create_experiment (for A/B tests).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is provided: use create_feature_flag first if the feature doesn't exist, and use create_experiment instead for A/B tests and experiments. This clearly defines when to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![growthbook-mcp MCP server](https://glama.ai/mcp/servers/growthbook/growthbook-mcp/badges/card.svg)](https://glama.ai/mcp/servers/growthbook/growthbook-mcp)

Score Badge

Copy to your README.md:

[![growthbook-mcp MCP server](https://glama.ai/mcp/servers/growthbook/growthbook-mcp/badges/score.svg)](https://glama.ai/mcp/servers/growthbook/growthbook-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/growthbook/growthbook-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server