flywheel-gear-dev-mcp
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@flywheel-gear-dev-mcpShow me the gear manifest schema requirements"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Flywheel Gear Development MCP Server
Give Claude expert knowledge of Flywheel gear development while you code.
The Problem
Developing gears for Flywheel means wrestling with documentation scattered across 10+ sources—many deprecated, conflicting, or redundant. You're constantly switching between browser tabs, searching for the right API reference, and wondering if what you're reading is still current.
Related MCP server: LangChain & LlamaIndex Coding Assistant
The Solution
This MCP (Model Context Protocol) server gives Claude Code direct access to all of the Flywheel and DICOM documentation on command. Now when you ask Claude "What's the correct way to write a DICOM secondary?", it can reference the actual current specs—no hallucination or without loading all of the DICOM standard docs into memory and clogging up your context.
What's MCP? It's a protocol that lets Claude Code access external tools and data. This server runs locally on your machine (started and stopped by claude only in the directory that you are developing a Flywheel gear) and feeds fresh Flywheel docs to Claude on demand.
Who is this for? Flywheel developers using Claude Code CLI to build gears.
Quick Start
# 1. Clone and install the MCP server
git clone https://github.com/wzkariampuzha/flywheel-gear-dev-mcp.git
cd flywheel-gear-dev-mcp
uv sync
# 2. Navigate to your gear project
cd /path/to/your/gear-project
# 3. Add the MCP server
claude mcp add flywheel-gear-dev \
--scope local \
-- uv run --directory /full/path/to/flywheel-gear-dev-mcp flywheel-gear-mcp
# 4. Start Claude Code and ask:
# "Show me the gear manifest schema requirements"Configuration
Two ways to configure the server in your gear project:
Option 1: CLI (Recommended)
From your gear project directory:
claude mcp add flywheel-gear-dev \
--scope local \
-- uv run --directory /absolute/path/to/flywheel-gear-dev-mcp flywheel-gear-mcpOption 2: .mcp.json file
Create .mcp.json in your gear project:
{
"mcpServers": {
"flywheel-gear-dev": {
"command": "uv",
"args": ["run", "--directory", "/absolute/path/to/flywheel-gear-dev-mcp", "flywheel-gear-mcp"]
}
}
}Usage
Starting the server
The server is automatically started by Claude Code when you launch a session.
Using the tools in Claude Code
Once configured, you can ask Claude to use the documentation tools:
"Can you get the fw-gear documentation?"
"Show me the DICOM standard data dictionary"
"What are the gear manifest schema requirements?"Features
Fresh documentation on startup: Fetches latest docs every time the server starts
10 curated documentation sources: Flywheel gear libraries, APIs, DICOM standard, and guides that you can add/remove/edit in config
Deprecation filtering: Automatically removes deprecated content to keep LLMs focused on current APIs
Available tools
get_fw_gear_docs- fw-gear library documentationget_fw_classification_docs- fw-classification libraryget_fw_file_docs- fw-file libraryget_flywheel_api_docs- Flywheel platform Python APIget_dicom_standard- DICOM standard (filtered to data dictionary and transfer syntaxes)get_file_types_guide- Flywheel file types guideget_bids_guide- BIDS in Flywheel guideget_batch_gears_guide- Batch gear execution guideget_gear_specs- Gear specificationsget_manifest_schema- Gear manifest JSON schemalist_available_docs- List all cached documentation sources
Customizing documentation sources
Edit config.yaml to add, remove, or modify documentation sources:
documentation_sources:
- tool_name: get_my_custom_docs
display_name: "My Custom Documentation"
description: "Description here"
urls:
- https://example.com/docs
type: html # or xml, json, gitlab_repo
strip_deprecated: trueSupported types
html- HTML documentation (auto-converts to markdown)xml- XML documentation (for DICOM standard)json- JSON schemasgitlab_repo- GitLab repository markdown files
How It Works
One-time setup: Install the MCP server code once, configure it in your gear projects
Automatic startup: When you run
claudein your gear project, Claude Code automatically starts this MCP server in the backgroundOn-demand docs: When Claude needs Flywheel documentation, it calls this server via MCP protocol
Fresh data: The server fetches latest docs from URLs on first request, caches them for the session
Automatic shutdown: Server stops when you exit Claude Code
The server runs locally—no data leaves your machine.
Troubleshooting
Server won't start
Check Python version: Requires Python 3.13+
Check dependencies: Run
uv syncagainCheck log files: Review
logs/flywheel-gear-mcp.logfor detailed error messages
Documentation not loading
Check network: Ensure you can access Flywheel documentation URLs
Check logs: Review
logs/flywheel-gear-mcp.logor run with verbose flag:flywheel-gear-mcp --verboseTest URLs: Verify URLs in
config.yamlare accessible
Tools not appearing in Claude Code
Restart Claude Code after configuration changes
Check config.json syntax: Ensure valid JSON
Check server status: Look for MCP server errors in Claude Code logs
Contributing
Contributions welcome! Please open an issue or PR.
Available Tools
11 toolsget_batch_gears_guideB
Guide to running gears as batch jobs
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. 'Guide to...' combined with the get_ prefix and the all-doc sibling setimplicitly signals a read-only documentation retrieval with no side effects, but the description never states what the returned guide contains (format, scope, or level of detail), and there are no annotations to cover the safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is seven words, front-loaded with the resource type, and contains zero waste. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless doc-retrieval tool the invocation is trivial and the topic is clear, which makes this minimally viable. However, it is incomplete relative to context: there is no statement of what the response looks like, no scope of coverage, and no differentiation from get_fw_gear_docs or get_gear_specs, which are near-neighbors an agent must disambiguate among.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters; the rubric assigns a baseline of 4 in this case. The schema is trivially fully covered (empty properties), so there is nothing for the description to add about inputs. The topic phrase in the description carries as much semantic weight as needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies a specific resource ('Guide') and a specific topic ('running gears as batch jobs'), so an agent can tell what content it delivers. It is not a tautology and the topic distinguishes it from siblings like get_dicom_standard or get_bids_guide, though it does not explicitly contrast with get_fw_gear_docs or get_gear_specs, which are close neighbors.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance, no exclusions, and no mention of alternatives, despite ten doc-retrieval siblings. The topic weakly implies usage (when a user asks about batch-gear execution), but the description never says 'use this instead of get_fw_gear_docs when you need batch specifics', leaving selection to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_bids_guideB
Guide to using BIDS (Brain Imaging Data Structure) in Flywheel
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of explaining what happens when the tool is called. It only says it is a 'Guide,' which suggests informational content, but it does not disclose whether the tool returns a text explanation, a link, a formatted document, or some other artifact. The behavioral profile is therefore largely opaque.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly worded sentence with no filler or redundancy. It front-loads the core topic ('BIDS') and the context ('in Flywheel'), making it immediately scannable for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter informational tool, the description identifies the subject and scope adequately. However, with no annotations and no output schema, an agent still lacks clarity about what invoking the tool actually returns and how this guide differs from sibling documentation options. It is minimally viable but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no properties and no required parameters, so the description has no parameter semantics to explain. With zero parameters, the baseline score of 4 applies because there is no schema/description gap for parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a guide to BIDS specifically within Flywheel, which distinguishes it from the sibling documentation tools that target different topics. However, it uses the noun 'Guide' rather than a strong action verb, so it is clear but slightly less definitive than a purpose statement like 'Returns documentation about BIDS usage in Flywheel.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when the user needs guidance on using BIDS in Flywheel. It does not explicitly contrast this tool with sibling docs tools or state when not to use it, so the usage context is inferable but not directly articulated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_dicom_standardA
DICOM standard documentation (filtered to data dictionary and transfer syntaxes)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the burden. It discloses the filtering behavior (only data dictionary and transfer syntaxes), which is useful, but it does not specify the return format, whether the content is static/updated, or any more detailed retrieval behavior. For a zero-parameter read-only docs tool, this is acceptable but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single compact sentence with no filler. The main subject and filtering constraint are front-loaded, making it quick for an agent to parse and act on.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the zero-parameter input and lack of output schema, the description is nearly sufficient. It states the content area and scope, though it could be even more helpful by briefly noting common use cases, such as looking up DICOM tag definitions or transfer syntax UIDs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no parameter ambiguity and the baseline is 4. The description adds value by clarifying exactly what subset of DICOM documentation is returned, complementing the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource (DICOM standard documentation) and narrows the scope to data dictionary and transfer syntaxes. This makes it easy to distinguish from sibling documentation tools such as get_fw_gear_docs or get_bids_guide.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use is implied by the tool name and description: retrieve DICOM standard documentation restricted to specific topics. However, it does not explicitly state when to prefer this over sibling documentation tools or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_file_types_guideA
Guide to supported file types in Flywheel
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 identifies the topic but does not state what kind of content is returned, whether it is static reference material, or any requirements or side effects. For a simple docs tool this is a minor gap, but it is still a disclosure gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with no filler. It front-loads the subject and stays appropriately minimal for a simple documentation tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter documentation tool, the description provides enough context to select and invoke it. The main omission is any indication of the output format or level of detail, but this does not seriously impede correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description adds relevant context by specifying that the guide concerns supported file types, which is all the extra meaning needed for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a clear resource — 'supported file types in Flywheel' — and states that the tool is a guide. This differentiates it from sibling doc tools like get_bids_guide and get_dicom_standard by subject matter, even though it lacks an explicit action verb.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied: an agent should use this when seeking information about supported file types in Flywheel. However, it does not explicitly mention when not to use it or name alternatives, though the domain-specific title makes the intended context fairly obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_flywheel_api_docsB
Flywheel platform Python SDK documentation
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the full behavioral burden. It only states that the tool provides SDK documentation, disclosing neither the return format, content depth, nor whether it returns raw docs, links, or summaries.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise noun phrase with no filler, and the resource is front-loaded. It is efficient but so terse that it borders on under-specification, preventing a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-input documentation retriever, the description is enough to select the tool but does not specify what the agent will receive. Since there is no output schema, the missing detail about return content leves a notable gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and full schema coverage, so there are no parameter semantics to explain. A score of 4 reflects the zero-param baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the specific resource — Flywheel platform Python SDK documentation — and pairs with the tool name to make clear it retrieves SDK docs. It avoids confusion with gear- and classification-focused siblings, though it doesn't explicitly differentiate itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives such as get_fw_gear_docs or get_fw_classification_docs. The only implied signal is the resource type in the description, with no explicit usage context or exclusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fw_classification_docsC
Flywheel classification library for DICOM metadata
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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, but it states no behavior at all. It does not describe return format, read-only behavior, required permissions, or any caveats about the documentation content.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded noun phrase with no filler words. It is compact and easy to scan, though it is terse enough that it sacrifices some clarity about what the tool actually does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given eleven sibling documentation tools, no output schema, and no annotations, this description is too thin to let an agent reliably select it or anticipate its response. It provides a topic label but no information about the document's content, format, or relationship to the other guides.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is empty and there are zero parameters, so there is no parameter-level ambiguity for the description to resolve. This matches the baseline for a no-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific resource—'Flywheel classification library'—and scopes it to DICOM metadata, which helps distinguish it from siblings like get_dicom_standard or get_gear_specs. It lacks an explicit verb such as 'returns' or 'lists', so it falls short of the clearest possible purpose statement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus the many sibling documentation tools. An agent can only guess from the topic phrase; no alternative tools, exclusions, or recommended conditions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fw_file_docsC
Flywheel file library for medical imaging file handling
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 provides no statement of what the tool returns, what content is included, whether it performs a lookup, or any limitations. The vague phrase 'file library for medical imaging file handling' does not disclose the actual behavior of the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, but the brevity is under-specification rather than effective conciseness. The phrase is front-loaded but conveys almost no actionable meaning, so it does not earn its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although the tool has no parameters or output schema, it is one of many documentation-related tools. The description fails to state what the file docs contain, what format they take, or how they differ from get_file_types_guide, get_dicom_standard, or get_flywheel_api_docs. An agent cannot reliably decide when to invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters and 100% schema coverage, so the description does not need to explain any parameters. With 0 params, the baseline is 4. The description adds no parameter detail, but none is needed given the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is a noun phrase ('Flywheel file library...') with no verb stating what the tool does. It never explicitly says it retrieves documentation, and 'file library' could be mistaken for a storage location rather than a documentation lookup. It also does not distinguish itself from siblings like get_fw_gear_docs or get_file_types_guide.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to use this tool versus the many sibling documentation tools. It does not mention that this is for file-handling docs specifically, nor does it direct agents to alternatives for gear docs, classification docs, or DICOM standards. The agent must rely 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.
get_fw_gear_docsC
Flywheel gear Python library for building gears
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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, but it offers only a static noun phrase with no mention of what happens on invocation, return format, side effects, or idempotency. An agent cannot tell whether this is a read-only retrieval, a link generator, or something else.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief with no wasted words, but this is under-specification rather than well-crafted conciseness. It is a fragment that is not front-loaded with the key piece of information—the action the tool performs—mirroring the 'Process' calibration case scored 2.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite being a simple tool with no params, no annotations, and no output schema, the description should at least state the operation and what kind of documentation it returns. It gives no basis for disambiguation among 10 sibling documentation tools, so an agent cannot reliability select or invoke this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters in the schema, so there is nothing the description needs to clarify about input semantics. Per the rubric baseline for 0-param tools, a 4 is appropriate even though the description adds no parameter-level value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is a noun phrase, 'Flywheel gear Python library for building gears,' with no action verb stating what the tool does (e.g., retrieve, list, return). It mostly restates the subject implied by the name 'get_fw_gear_docs,' making it closer to a tautology than a functional explanation. It also fails to specify the deliverable—is it documentation text, an index, or library source?
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance whatsoever about when to use this tool versus alternatives. With sibling doc-fetching tools like get_fw_classification_docs, get_fw_file_docs, and get_flywheel_api_docs, nothing here helps an agent decide which one to choose for a given question.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_gear_specsC
Flywheel gear specification and essential components
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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, but it is only a content fragment. It does not state whether the operation retrieves data, what the output looks like, whether it is read-only, or what side effects—if any—exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short, but it is under-specified rather than concise. A bare noun phrase provides no sentence structure, front-loading, or useful ordering of information for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description should at minimum state what is returned and why it might be chosen. 'Gear specification and essential components' hints at content but not format, scope, or relationship to the sibling documentation tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty input schema, so there are no parameter semantics for the description to add. Per the guidance, zero parameters warrant a baseline of 4, and there is no semantic gap to penalize.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is a noun phrase—'Flywheel gear specification and essential components'—that largely restates the tool name 'get_gear_specs'. It lacks a verb and does not explain what the tool actually does for the agent, while also not distinguishing it from siblings like get_fw_gear_docs or get_batch_gears_guide.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. The description never mentions a use case, prerequisites, or exclusions, leaving the agent to guess which documentation tool to select.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_manifest_schemaB
JSON schema for gear manifest.json files
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 only states what the schema is for, not what the tool does operationally (e.g., returns a static schema, fetches a remote resource, or validates input). Safety, side effects, and output format are all unexplained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with no filler. It front-loads the essential fact and every word earns its place, which is ideal for a simple one-line definition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, low-complexity tool, the one-liner is mostly sufficient. It would benefit from a little more context about what 'manifest.json' means in the Flywheel gear context and whether the schema is static or fetched, but nothing critical is missing for basic invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is nothing that needs explanation. Per the baseline for zero-parameter tools, a score of 4 is appropriate; the description does not need to add parameter detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's resource: the JSON schema for gear manifest.json files. It lacks an explicit verb like 'returns' or 'retrieves', so it reads as a noun phrase, but the resource is specific and distinct from the sibling docs tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as get_gear_specs or other documentation getters. There is no mention of context, exclusions, or related tools, leaving the agent to infer usage entirely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_available_docsA
List all available Flywheel documentation sources with metadata
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. It states the tool returns a list of documentation sources with metadata, which is reasonably transparent for a read-only listing operation. However, it doesn't disclose whether authentication is required, what metadata fields are included, or how the list is ordered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that immediately states the action, resource, and output qualifier. No filler or redundant phrasing, and it is front-loaded with the key purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, parameterless listing tool with no output schema, the description conveys the essential function: enumerating documentation sources with metadata. It is slightly incomplete because it doesn't mention what metadata is included or how the list relates to the sibling getter tools, but these are minor for an overview-oriented tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the schema description coverage is 100%, meaning the schema already fully documents the absence of arguments. The description adds no parameter-specific detail because none is needed; a baseline of 4 is appropriate for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('available Flywheel documentation sources') with an explicit qualifier about metadata. This clearly distinguishes it from the sibling tools, which focus on retrieving specific documentation types (e.g., get_fw_gear_docs, get_bids_guide).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for discovering available documentation sources, which contrasts with the sibling getters. However, it does not explicitly state when to use this tool versus the alternatives, such as 'use this first to see what docs exist' or 'use get_* for a specific doc.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool targets a distinct documentation topic, so agents can generally tell them apart. Minor overlap exists between gear-building docs, gear specs, and manifest schema, but the descriptions clarify the different focuses.
All tools use a get_ verb and topic-based names, which is predictable. However, suffixes vary between docs, guide, standard, schema, and specs, and prefixes inconsistently use fw, flywheel, or nothing.
Eleven tools is well-scoped for a documentation-focused server, covering distinct sources without redundancy. Each tool earns its place, and list_available_docs adds useful discovery without bloat.
The set covers major Flywheel gear development areas including the SDK, gear library, file handling, BIDS, DICOM, manifest schema, and batch workflows. A generic search or fetch-all tool would strengthen the surface, but list_available_docs mitigates the main gap.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Give Claude only the Google Drive files you choose. Every action logged.
Provide your AI coding tools with token-efficient access to up-to-date technical documentation for…
Persistent, governed institutional memory for Claude Code — specs, decisions, learnings.
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
Related MCP Servers
- FlicenseAqualityDmaintenanceProvides access to 600+ documentation libraries from DevDocs.io including Python, JavaScript, React, Django, and more. Enables searching, browsing, and retrieving documentation content directly through Claude Desktop.55
- FlicenseNot gradedqualityDmaintenanceProvides real-time retrieval of official documentation for LangChain, LlamaIndex, and OpenAI. It enables context-aware coding by fetching the latest API references and guides directly into Claude via the Model Context Protocol.
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants like Claude to search and retrieve technical documentation from a local DevDocs instance for hundreds of programming languages and frameworks.1MIT
- AlicenseNot gradedqualityDmaintenanceEnables Claude Code to index and semantically search through PDFs, code, and documents with exact citations and zero hallucinations.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/wzkariampuzha/flywheel-gear-dev-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server