community-ff-mcp

Server Quality Checklist

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

Latest release: v0.4.3
Disambiguation4/5
Tools are mostly distinct, with clear separation between listing, reading, searching, and updating. Some overlap exists among the many settings getters and between get_editing_guide and get_yaml_docs, but descriptions are specific enough to avoid major confusion.
Naming Consistency5/5
All tools use consistent snake_case verb_noun naming with uniform prefixes like list_, get_, find_, validate_, update_, sync_, and search_. The pattern is predictable and makes the toolset easy to navigate.
Tool Count3/5
At 25 tools, this is on the heavy side and right at the borderline for what feels reasonable. Each tool covers a specific FlutterFlow feature or settings section, so the count is justifiable, but it is still at the upper edge of appropriateness.
Completeness4/5
The tool set covers the full read/update workflow for YAML, including validation, documentation, and reference. Missing explicit tools like list_components or project creation/deletion, but these can be worked around via file listing and YAML updates, so gaps are minor.
Average 4.2/5 across 25 of 25 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 1 commit in the last 12 weeks
- Last stable release on February 22, 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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses a key behavioral trait: 'Validation catches syntax errors but not semantic mistakes.' However, it omits important details such as what happens on validation failure, whether it returns a report or throws an error, and confirmation that it does not modify anything. This is a gap for a validation 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?
The description is three sentences long, front-loaded with the primary purpose, and every sentence earns its place. It delivers the core action, when to use it, and a limitation without any redundancy or filler.
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?
The description explains why and when to use the tool and its limitation, but since there is no output schema, it should describe what the tool returns or how validation results are conveyed. This missing information leaves the description somewhat incomplete for an agent needing to handle outcomes.
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%, so the parameters are already well-documented in the schema. The description adds context about the overall workflow but does not provide per-parameter elaboration beyond schema descriptions. Baseline 3 is appropriate.
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's function: 'Validate YAML content before pushing changes to a FlutterFlow project.' It uses a specific verb (validate) and resource (YAML content), and explicitly distinguishes itself from sibling tools like update_project_yaml by instructing 'Always call this before update_project_yaml.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context and a direct usage instruction: call before update_project_yaml. It also offers a complementary tip to consult get_editing_guide or get_yaml_docs before writing YAML. However, it does not explicitly mention when not to use the tool or name alternatives, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the cache-based behavior, absence of API calls, and the need for a prior sync, which is valuable beyond a simple 'get' statement. It doesn't cover error cases or stale data, but the key behavioral traits are clearly stated.
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 short sentences, all informative, with the main purpose front-loaded. No redundant or vague text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter read operation, the description fully covers what the tool does and the prerequisite. Although there is no output schema, the list of included sections gives a clear sense of the return content. It could mention the return format, but it isn't essential.
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 has 100% coverage with a clear description for projectId. The tool description adds nothing about the parameter, so the baseline of 3 applies; no deduction or bonus.
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 retrieves 'General settings' and enumerates the specific content (App Details, App Assets, Nav Bar & App Bar), which is a specific verb+resource. It distinguishes from siblings by referencing the FlutterFlow 'General' settings section, though it doesn't explicitly name alternative tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context: 'Cache-based, no API calls' and instructs to 'Run sync_project first,' implying the prerequisite and typical use case. It doesn't specify when not to use it or mention alternatives, but the guidance is sufficient for a read-only cache tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so all behavior must be disclosed. The description states 'Cache-only, no API calls' and instructs to run sync_project first, which tells the agent about side effects and data source. It doesn't mention error handling or return format, which is a minor gap.
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?
Two sentences, front-loaded with the core purpose. The second sentence provides essential usage constraints without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main purpose, cache behavior, and prerequisite. It lacks return format, but without an output schema and with a simple query tool, this is acceptable. The schema fully documents parameters.
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 coverage is 100%, so all three parameters have descriptions in the schema. The tool description mentions 'parameter pass details' in the output but does not add extra meaning for the input parameters themselves, so baseline 3 is appropriate.
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 uses the specific verb 'Find' and identifies the resource 'all pages and components where a given component is used', which clearly distinguishes it from sibling tools like get_component_summary. It also mentions 'parameter pass details', giving a precise scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states the prerequisite 'Run sync_project first' and the cache-only constraint, giving clear context for when it should be used. It does not explicitly name alternatives, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the cache-only behavior (no API calls) and describes what the output contains (source page, trigger, disabled status, passed parameters). This is useful beyond the schema, though it doesn't cover potential edge cases like missing page or error handling.
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 only two sentences long, front-loaded with the main purpose, followed by a critical usage note. Every word earns its place, with no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a cache-only lookup tool with no output schema, the description covers the essential context: what it does, what it returns, and the required prerequisite (sync_project). It could mention parameter requirements, but the schema covers those. Overall, it is complete enough for the tool's complexity.
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 100%, so all three parameters already have descriptions. The tool description adds no additional parameter-level details beyond referring to 'a given page' which maps to pageName. The baseline 3 is appropriate since the schema does the heavy lifting.
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 verb and resource: 'Find all actions that navigate to a given page' with specific details on output (source page, trigger, disabled status, passed parameters). This distinguishes it from sibling tools like list_pages or find_component_usages that serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context by stating 'Cache-only, no API calls' and 'Run sync_project first', which sets expectations for when to invoke it. While it doesn't name alternative tools, the prerequisite and cache behavior give clear situational guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full transparency burden. It discloses that the tool reads from a local cache, makes no API calls, and requires sync_project as a prerequisite if data isn't cached. However, it doesn't specify the exact behavior when data is absent (e.g., error vs. empty result), leaving minor ambiguity.
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 two sentences, with the core purpose in the first sentence and a necessary precondition in the second. No redundant wording; every word contributes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple and the description covers purpose, data scope, and the cache prerequisite, while also listing the output fields. It lacks detail on failure behavior when not cached, but given the lack of an output schema, the field enumeration is helpful. Overall the description is sufficient for an agent to select and invoke the 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?
Schema description coverage is 100%, so both 'projectId' and 'name' are already well-documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, hence a baseline score of 3.
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 specifies it retrieves API endpoint definitions from a local cache, listing included fields (method, URL, variables, headers, response fields). It also distinguishes itself by stating 'No API calls', setting it apart from siblings like sync_project or get_project_yaml.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance to run sync_project first if not cached, implying when this tool is appropriate (local cached data) and the prerequisite. It doesn't explicitly name alternatives, but the mention of sync_project serves as a clear usage context. A small gap is no explicit 'when not to use' beyond the no-API-calls note.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fills the burden by disclosing cache-based behavior and no API calls, which implies a read-only, fast operation. It could further state that data may be stale until sync_project is run, but the current disclosure is valuable and context-rich.
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 concise and front-loaded, stating the tool name and key categories immediately. It uses two efficient sentences, with no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides sufficient context for a simple getter: what it returns (settings areas), how it behaves (cache-based, no API), and prerequisite (sync_project). While it lacks explicit return format details, the listed categories give a clear picture, and no output schema exists to rely on.
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?
There is only one parameter (projectId) and its schema description provides complete coverage. The tool description adds no extra semantics beyond the schema, so the baseline of 3 applies.
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 gets App Settings and enumerates specific areas (Authentication, Push Notifications, Mobile Deployment, Web Deployment), making the scope unambiguous. It also references the FlutterFlow 'App Settings' section, which distinguishes it from sibling tools like get_general_settings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to run sync_project first, which is a clear prerequisite. It implies usage when app settings are needed, but does not list alternatives or exclusions relative to other get_* tools, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses key behavior: reads from local cache, performs no API calls, and requires a prior sync step. This gives the agent important context about side effects and dependencies, though it does not describe error handling or return structure.
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 two sentences, front-loaded with the main purpose and then key constraints. Every sentence adds value without any filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one parameter and no output schema. The description covers the core function, cache behavior, and prerequisite. It could elaborate on what 'app state variables' encompass, but overall it is sufficient for an agent to select and invoke correctly.
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%, with the only parameter 'projectId' fully described in the schema. The description itself adds no extra parameter-specific details, so the baseline of 3 applies.
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 verb 'Get' and specifies the resource: 'app state variables, constants, and environment settings'. It also distinguishes from siblings by noting 'local cache' and 'No API calls', making the tool's scope immediate and explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides a clear prerequisite: 'Run sync_project first if not cached', which guides when to use this tool. It also implicitly differentiates from network-based tools by stating 'No API calls'. However, it does not explicitly mention alternative tools for when cached data is insufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool reads from local cache, makes no API calls, and resolves nested component references in a specific format. It doesn't explicitly state whether it's read-only or what happens on missing cache, but 'No API calls' and 'from local cache' strongly imply a non-mutating operation, which is meaningful behavioral context.
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 two sentences, front-loaded with the core purpose, then adds relevant details about output format and caching. Every clause earns its place; there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description compensates by outlining what the summary includes (widget tree, actions, params) and the nested reference format. It covers the key operational context (local cache, sync prerequisite). Minor omissions like error behavior are not critical for this simple read-from-cache tool, so it is nearly complete.
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 coverage is 100% and each parameter already has a clear description (e.g., componentId and componentName with usage notes). The tool description does not introduce new parameter-level meaning beyond what the schema provides, so it meets the baseline for well-documented parameters but adds no extra semantic value.
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 opens with 'Get a readable summary of a FlutterFlow component from local cache' – a specific verb, resource, and source. It clearly distinguishes from siblings by targeting components (not pages), and lists summary contents (widget tree, actions, params). This provides an unambiguous purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states the prerequisite explicitly: 'Run sync_project first if not cached.' It also sets expectations by noting 'No API calls' and that data comes from local cache. While it doesn't name alternative tools like get_page_summary, the context clearly implies component-specific use, and the prerequisite guidance is actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool is cache-based, performs no API calls, and that sync_project may be needed first. These are important behavioral traits. It does not mention side effects or error handling, but the disclosure is adequate for a read-only local operation.
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 two sentences, front-loaded with the main purpose, followed by a key usage prerequisite. Every word contributes value, with no wasted text, and the structure makes it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, but the description explains what the output will include (signatures, arguments, return types, optional source code) and provides context about the cache and sync_project prerequisite. It is comprehensive for a retrieval tool, though it does not describe error cases or empty results. Overall, it is well-rounded for the tool's complexity.
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 covers 100% of parameters with descriptions, so the baseline is 3. The description adds context about the output content (signatures, arguments, return types, optionally Dart source) which indirectly relates to includeCode, but it does not provide per-parameter semantics beyond the schema. Thus, it meets the baseline without adding significant parameter-level value.
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 specifies the verb 'Get' and enumerates the resource types: custom actions, functions, widgets, AI agents, app action components, and custom files. It also states the source (local cache) and what is returned (signatures, arguments, return types, optionally Dart source), making it easy to distinguish from sibling tools like list_pages or get_page_by_name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit context: it reads from local cache, makes no API calls, and instructs to run sync_project first if not cached. This gives clear usage direction and a prerequisite, though it does not explicitly name alternatives or state when not to use it, leaving some room for interpretation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It transparently discloses that the tool makes no API calls and reads from a local cache, and warns about the sync_project prerequisite. However, it does not describe error behavior if data is not cached or the exact return format, which would enhance transparency.
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 exactly two sentences: the first declares the purpose, the second states the prerequisite. Every word earns its place, with no redundancy or filler, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple local-cache read tool, the description is reasonably complete. It clarifies the local nature, the sync prerequisite, and the data types covered. It lacks detail on return values or failure behavior when data isn't cached, but given the tool's simplicity, these are not critical gaps.
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%, so the schema already fully documents all parameters. The description restates the type filter (structs, enums, collections, supabase) but adds no new semantic details beyond what the schema provides. This meets the baseline for high schema coverage.
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's purpose with a specific verb ('Get') and enumerates the exact resources: data structs, enums, Firestore collections, and Supabase tables. It also specifies the source as 'local cache', distinguishing it from API-based sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage context by instructing 'Run sync_project first if not cached', which is a clear prerequisite. It implies when to use the tool (after syncing) but does not explicitly state when not to use it or name alternative tools. The phrase 'No API calls' provides context that this is for cached data access.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the output (workflow steps, schemas, rules) and implies the tool is a guide rather than a mutator, but it does not explicitly state whether it is read-only, requires authentication, or has any limitations. This is adequate but not rich.
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 two sentences, front-loaded with the core purpose, then provides timing, usage examples, and expected output. Every word earns its place with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a guidance tool with only two parameters and no output schema, the description effectively covers what to do, when to call, and what to expect in return. It could mention prerequisites like project sync or error handling, but it is largely complete for its complexity.
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 coverage is 100%, and the description adds value by elaborating on the 'task' parameter with concrete examples and explaining the purpose. The projectId parameter is already well-described in the schema, so the description goes beyond the baseline by making the task parameter's usage clear.
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 provides recommended workflows and documentation for FlutterFlow editing tasks. It uses a specific verb ('Get') and resource ('recommended workflow and relevant documentation'), and the focus on guidance before modification distinguishes it from sibling tools that perform direct actions like listing pages or updating YAML.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Call this BEFORE modifying any YAML', providing clear timing guidance. It also gives concrete examples of tasks to describe, implying when to use it. However, it does not explicitly mention alternatives or situations where this tool should not be used, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool resolves names to scaffold IDs, returns the full page YAML, and uses case-insensitive matching. These are meaningful behavioral traits beyond a simple 'fetch'. It does not cover failure modes (e.g., page not found), but for a fetch operation with no side effects, this is acceptable and adds good context.
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 two sentences, front-loaded with the main action and outcome. It includes an example of page names and key behavioral details (case-insensitivity, returns full YAML) without any redundant or unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, so the description must convey what is returned; it does so by stating 'returns the full page YAML'. It also explains the resolution process and matching behavior. It could mention error handling or the structure of the YAML, but for a simple get/read operation with simple parameters, this is sufficiently complete.
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%: both pageName and projectId are described in the schema. The description adds slight extra context (e.g., 'human-readable name', 'resolves to scaffold ID'), but this largely mirrors the schema's parameter descriptions. Since the schema already documents the parameters fully, the description does not significantly enhance parameter understanding.
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 fetches a FlutterFlow page by its human-readable name, resolves it to a scaffold ID, and returns the full page YAML. This distinguishes it from siblings like list_pages (which lists pages) and get_page_summary (which likely returns a summary rather than full YAML).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: when you have a human-readable page name and need the full YAML. It also notes case-insensitive matching, which is useful. However, it does not explicitly mention alternatives or exclusions (e.g., 'Use get_page_summary for summaries'), so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden. It discloses important behavioral traits: cache-based, no API calls, and the need to run sync_project first. This gives the agent a clear operational understanding beyond the tool name.
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 concise sentences, front-loaded with the purpose, followed by relevant clarifying context (mirroring section and caching behavior). Every sentence earns its place with zero redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 param, no output schema, no annotations), the description provides a good overview of what settings are included and how it behaves (cache, sync requirement). It could be more explicit about the exact response shape, but the listed categories suffice for a get-operation 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?
The only parameter projectId is fully described in the schema (100% coverage), so the description doesn't need to repeat it. The description adds no extra semantic detail about the ID format or usage, which aligns with the baseline 3 for high schema coverage.
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?
Clearly states the action 'Get Project Setup settings' and enumerates the specific categories (Firebase services, Languages, etc.), distinguishing it from sibling get_* tools by referencing the FlutterFlow 'Project Setup' section.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context: it is cache-based and requires running sync_project first. This implies when to use (after syncing) and the operational mode. However, it does not explicitly name alternatives or exclusions, so it's a 4 rather than 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the cache read nature, the prerequisite, and the return behavior for both parameter states. It does not cover error cases, but for a simple read tool this is adequate.
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?
Two concise, front-loaded sentences with no redundant information. Every clause contributes meaningful usage guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool without an output schema, the description covers the prerequisite, the selection behavior, and the return mode. It could mention alternative YAML-reading tools for fuller context, but this is not a critical gap.
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 fully describes both parameters (100% coverage), so the description adds little beyond what is already structured. The description restates the fileName behavior but does not introduce new semantic details.
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 action ('Read YAML files'), the resource ('local project cache'), and the two possible outcomes (single file or list of keys). It is distinct from sibling tools like sync_project or update_project_yaml.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly requires sync_project to be run first, which is a clear prerequisite. It also explains when fileName should be omitted, though it does not name alternative read tools explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behaviors: it reads from local cache, makes no API calls, and requires sync_project beforehand. Since no annotations are provided, this carries the transparency burden; it doesn't state what happens if data is absent (e.g., error vs empty result), but is otherwise strong.
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, information-dense set of three sentences: purpose, behavior, prerequisite. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description hints at return content (theme sections) and covers source, network behavior, and prerequisite. It lacks explicit error handling or return format details, but for a simple getter it's near-complete.
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 fully describes both parameters, including the 'section' enum and 'projectId'. The description echoes the categories but adds minimal value; the phrase 'widget defaults' clarifies that the 'widgets' enum means widget defaults, but overall the schema does the heavy lifting.
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 uses a specific verb ('Get') and names the exact resources (theme colors, typography, breakpoints, widget defaults), clearly distinguishing it from sibling tools like get_app_settings. It also specifies the data source ('local cache').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states a clear prerequisite ('Run sync_project first if not cached') and notes it makes no API calls, implying it's the lightweight cache read path. It doesn't explicitly name alternatives or exclusion conditions, but gives enough context for when to use it.
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?
With no annotations, the description carries the burden. It discloses that it returns full doc content and explains the two modes. However, it doesn't address edge cases like empty results, mutual exclusivity enforcement, or whether both parameters can be provided. For a simple read-only tool, this is acceptable but not thorough.
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 two sentences, front-loaded with purpose, and every sentence adds value. Examples are embedded efficiently without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool and lack of output schema, the description covers the essentials: what it does, how to invoke it, and what it returns. It could mention what happens if neither parameter is supplied, but this is a minor gap for a doc retrieval tool.
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 coverage is 100%, but the description adds meaningful semantics by explaining the relationship between 'topic' and 'file' (using 'or'), providing concrete examples for each, and clarifying they are alternative modes. This goes beyond the schema's parameter descriptions.
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's function: 'Search and retrieve FlutterFlow YAML reference documentation.' The verb is specific, the resource is well-defined, and it distinguishes itself from sibling tools that deal with project files and pages rather than documentation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: use 'topic' for keyword search or 'file' for fetching specific docs. It doesn't explicitly name alternatives, but the distinction from siblings is evident. No exclusions are mentioned, but the guidance is adequate for a doc-lookup tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the operation is a read-only listing ('List all pages') and specifies the kind of data returned. While it doesn't mention pagination or response format, the tool's simplicity mitigates the omission, and the described behavior is clear and consistent.
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 two sentences with zero filler. The first sentence states purpose and output; the second provides a usage hint. It's front-loaded and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read-only list tool without an output schema, the description provides sufficient context: what it returns, why to use it, and when in the workflow. Minor gaps like response shape or edge cases are not critical for selection and invocation, making it nearly complete.
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 covers 100% of the single parameter (projectId) with a clear description. The tool description does not add additional meaning to the parameter, but none is needed given the schema's completeness. Baseline of 3 is appropriate.
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 lists all pages in a FlutterFlow project, with specific output details (human-readable names, scaffold IDs, folder assignments). The verb 'List' and resource 'all pages' are specific, and the mention 'Use this FIRST' distinguishes it from sibling tools like get_page_by_name and get_project_yaml.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises using this tool first to discover pages before fetching their YAML, giving a clear workflow context. It stops short of naming alternative tools or providing when-not-to-use cases, but the instruction is actionable and implies the tool's role in the overall process.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It clarifies that the tool returns file names only, not contents, and explains the prefix filtering behavior. However, it does not disclose potential limitations such as pagination, sorting, or error behavior, but for a simple read-only list this is acceptable.
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 two concise sentences, leading with the core action and then the optional filter. No extraneous detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with good schema coverage and no output schema, the description is nearly complete. It omits details like return ordering or whether file extensions are included, but these are minor and the core behavior is clearly stated.
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 already provides descriptions for both parameters (100% coverage), including the prefix filter with examples. The description adds little beyond restating the prefix filter, so the schema carries the semantic weight. Baseline 3 is appropriate.
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 uses the specific verb 'List' and names the resource 'YAML file names in a FlutterFlow project.' It also mentions an optional prefix filter, which differentiates it from siblings like list_pages (which likely lists only pages) and search_project_files (which searches content).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly states the tool lists all YAML file names and supports an optional prefix filter, giving enough context for when to use it. However, it does not explicitly mention alternatives or when not to use it, e.g., if looking for page-specific listings, so it falls short of explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses an important behavioral trait not evident from the schema: the result set may be incomplete (shared/team projects can be missing). This is critical for an agent to know. It also provides a workaround. No annotations are present, so the description carries the full burden and does it well.
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 two sentences with no fluff. It leads with the primary action and follows with a critical caveat, earning its place entirely.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with one optional parameter and no output schema, the description adequately covers purpose and key limitations. It could mention return format but that is not necessary for basic usage.
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 already fully describes the only parameter (project_type) with 100% coverage, so the description adds no additional meaning. This meets the baseline for adequate parameter semantics.
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's purpose: to list FlutterFlow projects for the authenticated user. The verb 'list' and resource 'projects' are specific, and this is distinct from sibling tools like list_pages or list_project_files, which list sub-resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides useful usage context by warning that shared/team projects may be missing and advising how to obtain a missing project ID from the FlutterFlow editor. This implies when to use the tool and offers a fallback, though it doesn't explicitly contrast with alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that it is cache-only and makes no API calls, which implies read-only behavior. It also states the prerequisite 'Run sync_project first.' It does not disclose error handling or what happens on empty results, but covers the essential behavioral traits for a search 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?
The description is four short sentences, front-loaded with purpose. Each sentence contributes: what it does, what it returns, cache behavior, and prerequisite. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool with no output schema or annotations, the description is largely complete: it covers purpose, modes, return value, cache-only nature, and prerequisite. It falls slightly short of a 5 by not mentioning result limits or error/empty-response behavior, but these are not critical for 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?
Schema coverage is 100%, so the baseline is 3. The description adds little beyond the schema: 'keyword, prefix, or regex' essentially restates the mode enum, and the downstream use with get_project_yaml is contextual rather than parameter-specific. It does not enrich parameter meanings materially.
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 opens with a specific verb and resource: 'Search cached project file keys by keyword, prefix, or regex.' This clearly identifies the operation and differentiates it from sibling tools like list_project_files (which lists all keys) and get_project_yaml (which fetches content). The mention of search modes further clarifies scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear contextual guidance: it is cache-only, requires 'Run sync_project first,' and returns keys for use with get_project_yaml. This implies when to use it and the prerequisite, but it does not explicitly state when not to use it or compare against alternatives like list_project_files, stopping short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It reveals that the tool downloads all YAML files, may use bulk or batched fallback, and that force=true re-syncs an already cached project—important caveats. It doesn't cover potential side effects like cache overwriting, but the core behavior is well disclosed.
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 two sentences, front-loaded with the main purpose, and every clause adds value. No redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description provides adequate high-level context: what it does, how it works (downloads all YAML), and the force option. It is slightly incomplete regarding the lifecycle of the local cache or how to verify sync success, but not critically so.
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 coverage is 100% for both parameters: projectId and force. The description adds no new semantic meaning beyond the schema; it only restates the force behavior ('Use force=true to re-sync an already cached project') which matches the schema description. Baseline of 3 is appropriate.
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 action ('Sync an entire FlutterFlow project to the local cache') with a specific verb and resource. It distinguishes itself from sibling tools by emphasizing the whole-project cache download, not just fetching individual files or listings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context: use for 'fast offline reads' and to re-sync with 'force=true'. Though it doesn't explicitly name alternatives or when-not-to-use, the context is sufficient to identify appropriate usage compared to more targeted file-fetching tools like get_project_yaml.
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 the full burden. It includes an IMPORTANT warning about validating first, implying potential risks of updating without validation. However, it does not disclose specific consequences, side effects, or reversibility beyond that. Some behavior is inferred but not fully detailed.
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 only two sentences, with the primary purpose front-loaded and then key warnings. Every sentence adds value; no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (map-of-content parameter, no output schema, no annotations), the description appropriately directs users to validate first and consult get_editing_guide for full workflow and schema documentation. This is likely sufficient for an AI agent to invoke correctly, though it could explicitly state output expectations or failure modes. Overall quite complete.
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 already provides 100% coverage with descriptions for both projectId and fileKeyToContent. The description does not add additional parameter semantics beyond what the schema states, such as the multi-line YAML format requirement mentioned in the schema itself. Therefore, baseline 3 is appropriate.
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's function: 'Push YAML changes to a FlutterFlow project.' This distinguishes it from reading tools like get_project_yaml and validation tools like validate_yaml. The verb 'push' implies writing/updating, which matches the name.
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?
The description explicitly directs users to call validate_yaml first and get_editing_guide before writing, giving clear when-to-use and sequence guidance. It names the alternative tools that should be used in conjunction, which is exemplary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden and discloses that it is cache-based, makes no API calls, and requires a prior sync. This sets clear expectations for data freshness and side effects. It doesn't explicitly state it's read-only or what happens if cache is missing, but the disclosed traits are valuable.
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 extremely concise and front-loaded: the first phrase gives the action and resource, the second adds providers and the mirrored section, and the final sentence covers behavior and prerequisite. Every sentence earns its place with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple getter with one parameter and no output schema, the description is remarkably complete. It explains what is returned, which UI section it mirrors, that it uses cached data, and what precondition must be met. This is sufficient for an agent to select and invoke the tool correctly.
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 only parameter (projectId) is fully described in the schema with 100% coverage, so the description does not need to add parameter details. The tool description adds no extra parameter-level meaning beyond what's in the schema, matching the baseline for good schema coverage.
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 explicitly states the tool retrieves In-App Purchases & Subscriptions settings, names the specific providers (Stripe, Braintree, RevenueCat, Razorpay), and references a specific FlutterFlow section. This clearly distinguishes it from sibling settings tools like get_integrations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear context by mapping to the FlutterFlow section and provides an actionable prerequisite ('Run sync_project first') plus states it is cache-based. However, it doesn't explicitly mention when to avoid using this tool or discuss alternatives, so it stops short of full explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It transparently discloses that the tool is cache-based and makes no API calls, which is crucial for understanding data freshness and side effects. It stops short of explaining error behavior when the cache is missing or stale, which would enhance transparency further.
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 compact and well-structured: a clear action verb with resource, a provider list, and a critical usage note. Every sentence adds value without redundancy, achieving high information density in just two sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description sufficiently covers what the tool returns (integration settings for the listed providers), the caching mechanism, and the prerequisite sync step. For a tool with a single parameter and simple purpose, this is adequate and complete context.
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 already describes the only parameter (projectId) with 100% coverage, so the description does not need to add much. It provides no additional semantic detail about the parameter, but the baseline of 3 applies since the schema handles the documentation.
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 identifies the tool's function: 'Get Integrations settings' and enumerates the specific providers (Supabase, SQLite, GitHub, etc.). It distinguishes itself from sibling tools like get_general_settings or get_app_settings by explicitly mirroring the FlutterFlow Integrations section.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear prerequisite: 'Run sync_project first.' It also notes the tool is 'cache-based, no API calls,' implying it is a lightweight, non-fetching operation. However, it does not explicitly state when to avoid this tool or mention alternatives, so it doesn't meet the 5-criterion of explicit when/when-not/alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool reads from local cache, performs no API calls, and resolves component references to [ComponentName] (ComponentId). However, it does not specify what happens if the page is not cached (e.g., error versus empty result), leaving a minor transparency gap.
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 three sentences, front-loaded with the core purpose, and every sentence adds value: what it does, a key behavior (component resolution), and a prerequisite/alternative. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, cache behavior, contents, and related tools, which is strong for a tool with no annotations and no output schema. It falls short of a 5 by not describing the expected return format or error behavior when a page is missing from cache, which would make it fully self-contained.
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%, and the schema already explains the either/or relationship between pageName and scaffoldId. The description adds no additional parameter-level detail, only mentions component IDs in output, which is not a parameter. Baseline 3 is appropriate.
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's function: 'Get a readable summary of a FlutterFlow page from local cache' and enumerates the contents (widget tree, actions, params, state). It also distinguishes itself from siblings by explicitly pointing to get_component_summary for component drill-down and mentioning sync_project as a prerequisite.
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?
The description provides explicit usage context: it is a local-cache read ('No API calls'), requires sync_project if not cached, and directs users to get_component_summary for component-level details. This gives clear when-to-use guidance and a concrete alternative for further drilling.
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:

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

Score Badge

Copy to your README.md:

[![ff-mcp MCP server](https://glama.ai/mcp/servers/mohn93/ff-mcp/badges/score.svg)](https://glama.ai/mcp/servers/mohn93/ff-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/mohn93/ff-mcp'

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