MCP CAD Studio

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
The tools are mostly distinct, with clear separations between list/load, create/update, and modeling operations. The main ambiguity lies among create_model, generate_model, and import_model, all of which create models from different inputs, but descriptions clarify the input types.
Naming Consistency4/5
The vast majority of tools follow a consistent verb_noun pattern (list_models, load_model, create_model, etc.). Two deviations——studio_ui and boolean_models——break the pattern but remain readable and understandable.
Tool Count5/5
With 12 tools, the surface is well-scoped for a CAD management server, covering core CRUD, modeling operations, import/export, and a UI entry point. Each tool serves a distinct purpose and none feel superfluous.
Completeness5/5
The server offers complete lifecycle management for CAD models, from creation (parametric, template, import) through editing, transforming, boolean operations, duplication, and deletion, plus export and a visual UI. No obvious gaps exist for the stated purpose.
Average 3.6/5 across 12 of 12 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 14 commits in the last 12 weeks
- No stable releases found
- 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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate the tool is not read-only, but the description does not clarify whether the generated model is persisted to the workspace, whether it creates a new model entity, or what side effects occur besides generation. With readOnlyHint=false, the write nature is implied, but the description adds no concrete behavioral detail beyond the verb 'generate', leaving side effects underspecified.
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, concise sentence that front-loads the action and outcome. It includes the essential list of templates without unnecessary detail. The word 'useful' is slightly subjective but does not materially add bloat; the structure is optimal for a tool description of this simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of a nested parameters object, multiple template options, and no output schema, the description is incomplete. It does not explain how to choose templates, how to provide parameters, or what the return value looks like. For an agent to use this tool correctly, it would need additional clues from the schema or examples, which are absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, and the description adds no meaning to the parameters. It does not explain what 'parameters' means, which parameter applies to which template, or how 'name' and 'color' are used. The template enum is merely repeated, not enriched. The nested 'parameters' object has seven properties with no guidance, making this parameter semantics entirely inadequate.
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 states a specific action ('Generate'), a specific output ('CAD model'), and a clear scope ('from a built-in template') while listing the available template types (bracket, pipe, gear, enclosure, or bolt). This distinguishes it from sibling tools like create_model, load_model, and import_model by emphasizing a template-driven generation workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'from a built-in template' implies the tool is intended for generating models from predefined templates rather than arbitrary or imported geometry. However, it does not explicitly state when not to use this tool or mention alternatives such as create_model, load_model, or import_model, so the usage guidance remains implied rather than explicit.
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?
Annotations already indicate readOnlyHint=false and destructiveHint=false, and the description's 'Create' aligns with a write operation. It adds the context of 'editable copy' (suggesting the original is preserved and the result is a new modifiable model), but doesn't disclose details about whether the copy is deep, independent, or what side effects may occur beyond the annotations.
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?
A single, concise sentence that is front-loaded with the action and resource. Every word earns its place, and the description is appropriately sized for the simple tool.
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 tool is simple (2 flat parameters, no output schema), and annotations provide the safety profile. However, the description doesn't mention the return value or what the 'editable copy' means for reuse (e.g., does it return the new model ID?). This leaves a moderate gap for an agent invoking the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, and the description does not explain either parameter. 'modelId' can be inferred as the model to duplicate, but 'name' (the new copy's name) is not described, and no parameter-level context is provided. The description fails to compensate for the missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create an editable copy') and the resource ('a saved CAD model'). It distinguishes the duplication behavior from create_model, but does not explicitly mention alternatives or sibling tools, so it falls short of full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'saved CAD model' implies usage when an existing model needs to be copied, but no explicit when-to-use or when-not-to-use guidance is given. Alternatives like create_model or generate_model are not mentioned, leaving usage context only implied.
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?
Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is known. The description adds the 'permanently' qualifier and specifies 'saved' models, which clarifies scope. However, it does not disclose side effects (e.g., whether related data is removed), permission requirements, or if deletion is undoable—the latter being partially covered by 'permanently' but still extra context would be useful.
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, front-loaded sentence that conveys the essential purpose without any filler or repetition. Every word adds value: 'permanently' indicates irreversibility, 'saved' limits scope, and 'from this studio' clarifies the context. This is ideal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity tool with one parameter, no output schema, and clear annotations, the description is adequate but leaves gaps. It does not mention what happens after a successful deletion (e.g., return type, confirmation) or potential errors (e.g., non-existent model, insufficient permissions). The additions of 'permanently' and 'saved' help, but a bit more detail on consequences would increase completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one required parameter, modelId, with 0% schema description coverage. The tool description does not explicitly explain what modelId represents or how to provide it. While the tool name and title strongly imply modelId is the identifier, the description fails to state this directly, leaving the agent to infer from the parameter name alone. With zero coverage, the description should compensate but does not.
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: 'Permanently delete a saved CAD model from this studio.' It uses a specific verb ('delete') and resource ('saved CAD model'), and the scope ('from this studio') distinguishes it from other model management tools like update_model or duplicate_model. The word 'permanently' adds critical disambiguation from any soft-delete behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as archiving or deactivating a model. It does not mention any prerequisites, confirmed-deletion workflows, or exclusions. Sibling tools like update_model exist, but the description says nothing about how to choose between them.
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?
Annotations already declare readOnlyHint=false and destructiveHint=false, indicating a non-destructive write operation. The description adds the operation types but does not disclose additional behavioral traits such as whether the original models are unchanged, if the result is saved automatically, or any permission requirements. Minimal added value beyond annotations.
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, direct sentence that conveys the core functionality without verbose or redundant phrasing. It earns high marks for efficiency and front-loading the key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This tool has no output schema, so the description should describe what the operation returns or whether the new model is persisted. It also lacks explanations for all parameters, particularly 'name' and 'color', and does not mention the relationship to sibling tools or any side effects. Given the moderate complexity and missing schema descriptions, the description is not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It clarifies that modelIds must include two or more saved models and lists the three operation values, but it does not explain the 'name' or 'color' parameters. The 'name' likely refers to the resulting model's name and 'color' its appearance, but this is left to inference, which is insufficient for a fully self-contained tool.
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 'Create' and resource 'new model', and clearly specifies the boolean operations (union, difference, intersection) on two or more saved models. This differentiates it from siblings like create_model (which likely starts from scratch) and transform_model (which modifies a single model).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for combining existing models via boolean operations, but does not explicitly state when to use this tool over alternatives or provide exclusion criteria. There is no mention of alternative tools like transform_model for single-model edits, so guidance is limited.
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?
Annotations already cover read-only and non-destructive behavior. The description adds that the model must be 'saved' and that output is 'ASCII STL or OBJ data,' but does not clarify how the data is returned (e.g., direct binary, base64, file URL) or any error behaviors, leaving some 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 a single, front-loaded sentence of nine words. Every word contributes meaning, with no unnecessary detail or repetition.
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 tool has only two required parameters and no output schema. The description gives the essential operation and formats, but it fails to specify the exact return structure (e.g., plain text, binary, base64-encoded) which is important in the absence of an output schema. It is adequate for a simple export but not fully 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?
With schema description coverage at 0%, the description partially compensates by explaining that 'stl' means ASCII STL and that format choices are STL or OBJ. However, it does not explicitly describe the modelId parameter, leaving it to be inferred from 'saved CAD model' and the schema's UUID format.
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: 'Export a saved CAD model as ASCII STL or OBJ data.' It uses a specific verb ('Export') and resource ('saved CAD model') and differentiates from siblings like import_model and load_model by focusing on file data extraction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites beyond 'saved', or distinctions from load_model or import_model. The context is only implied, not explicit.
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?
The description adds context that the operation saves the model into the studio, which is a write action consistent with readOnlyHint=false. However, it does not disclose potential behaviors like overwriting existing names, size limits, or validation errors, and annotations already indicate the basic 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that directly states the action, input formats, data source, and destination. It contains no filler or redundant restatements of schema fields, making it efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 5 parameters, no output schema, and no parameter descriptions, the description is too brief to be complete. It does not explain what happens after saving (e.g., return value, ID), how parameters like color affect the model, or any error scenarios, leaving significant gaps for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description only clarifies two parameters: 'format' ('STL or OBJ') and 'encoding' ('text or base64'). It fails to explain the semantics of 'name', 'data', and 'color', which are otherwise left entirely to the schema's bare types and defaults.
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 ('Import'), names the resource ('STL or OBJ model'), and states the destination ('save it in the studio'). This clearly distinguishes it from siblings like load_model (loading existing) and create_model (creating from scratch).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: when you have STL/OBJ data in text or base64 and want to add it to the studio. However, it does not explicitly state when to use this tool vs alternatives, such as load_model for file-based imports or create_model for model generation.
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?
The description adds some context beyond the annotations by specifying that translation is 'incremental' and rotation is 'Euler rotation in degrees', which clarifies the nature of the transform. However, it does not disclose the effect on the model, the role of expectedRevision, or any reversibility or side effects, leaving gaps in behavioral understanding.
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, well-structured sentence that is front-loaded with the main action and resource. It contains no redundant words and conveys the core purpose efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, no output schema, and no in-schema parameter descriptions, the description is too sparse. It omits critical details about how parameters work together (e.g., can translation and rotation be combined?), the meaning of expectedRevision, and what the tool returns. This leaves an agent with insufficient information for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate for parameter meaning. It vaguely maps 'translation', 'rotation', and 'scale' to three parameters and adds nuance with 'incremental' and 'Euler degrees', but it fails to explain the array structure, the interaction between parameters, or the purpose of expectedRevision, which is entirely undocumented.
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 'Apply' and identifies the resource 'CAD model', enumerating the exact types of transformations: incremental translation, Euler rotation in degrees, or scale. This clearly distinguishes it from sibling tools like update_model or boolean_models, which 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when a CAD model needs geometric modification, but it does not explicitly state when to choose this over alternatives such as update_model or boolean_models, nor does it mention any prerequisites or exclusions. The context is evident but not elaborated.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds the scope of 'currently saved in this studio,' which clarifies it returns a live snapshot of existing models, but it does not disclose return format, ordering, or potential side effects beyond what annotations already indicate.
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, clear sentence that is front-loaded with the verb and resource. No unnecessary words or redundant details are present, making it exceptionally concise.
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 (no parameters, no output schema, clear annotations), the description is mostly sufficient. It could benefit from a brief note on what the returned list contains (e.g., names, IDs), but the current description is adequate for a zero-parameter list 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?
The tool has 0 parameters, and the schema is empty, so the baseline for parameter semantics is 4. The description correctly implies no inputs are needed, and there is no additional parameter information required.
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 ('List') and resource ('CAD models currently saved in this studio'), clearly identifying the tool's function. It distinguishes itself from sibling tools like load_model, create_model, and delete_model by focusing on the read-only enumeration of saved models.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. The description simply states what it does without context on use cases or how it relates to other model-related tools such as create_model or load_model.
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 adds context beyond the annotations by specifying that loading a model also brings its editable parametric definition and render mesh. It does not mention failure modes or permissions, but the readOnlyHint and destructiveHint annotations already cover safety, so the added detail about what is loaded is valuable and non-contradictory.
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, focused sentence that clearly states the action and the objects involved. It is efficient and well-structured, with no unnecessary words or repetition. Every part of the sentence contributes meaning.
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 tool with one parameter and no output schema, the description is mostly complete: it states the action, the resource, and the returned/loaded components (model, parametric definition, mesh). The lack of usage guidance and error behavior is a minor gap, but the annotations and simple schema cover the essential safety and input constraints, making the description sufficient.
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 single parameter modelId is not described in the text or in the schema description (0% coverage), but the description's phrase 'a saved CAD model' gives minimal semantic context that modelId identifies an existing model. The schema's format and pattern already provide validation rules, so the description adds little beyond confirming the parameter's role, which is a modest contribution.
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 loads a saved CAD model, its editable parametric definition, and render mesh. This uses a specific verb ('Load') and resource ('saved CAD model'), and the mention of parametric definition and render mesh distinguishes it from sibling tools like list_models (which likely lists metadata) or create_model (which creates new models).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives. It only states what the tool does, without mentioning context, exclusions, or alternative tools. Sibling tools like list_models and update_model exist, but the description does not explain how load_model differs in usage or when to prefer it.
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?
Annotations provide only that the tool is not read-only and not destructive. The description adds that it creates a model from a parametric shape tree and enumerates supported operations, giving the agent insight into input capabilities. However, it does not disclose side effects like name conflicts, return values, or permissions, which would be 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 a single, focused sentence that front-loads the primary action and then lists supported capabilities. Every word adds value, and it is easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the highly complex nested shape schema and lack of output schema, the description gives a helpful summary but omits important operational details such as naming constraints, return value, or error conditions. It tells the agent what the tool can do, but not enough about the results or side effects for a fully informed invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description's mention of 'primitives, extrusions, transforms, mesh input, and boolean operations' adds high-level meaning to the complex 'shape' parameter. However, it does not explain the 'name' or 'color' parameters, though their schema definitions are self-explanatory. The description partially compensates for the missing schema 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 uses the specific verb 'Create' with resource 'CAD model' and clearly states the input is a 'declarative parametric shape tree'. It lists supported features (primitives, extrusions, transforms, mesh input, boolean operations), which distinguishes it from sibling tools like list_models, update_model, or delete_model.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not mention when to use this tool versus alternatives. While 'Create' implies using it to make a new model, it does not differentiate from generate_model or import_model, nor does it state any exclusions or prerequisites. Usage is only implied by the name and title.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is safe. The description adds that it is 'interactive' and for 'visual' work, which is useful behavioral context but minimal beyond the annotations. No contradiction exists.
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 action and usage context. Each sentence earns its place, with 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?
With one optional parameter and no output schema, the description is adequate for opening a CAD Studio. It clearly conveys the tool's purpose and when to use it. It does not explain what 'open' returns or triggers, but given the simple nature and annotations, it is reasonably 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% with modelId described as 'Model to select initially.' The description adds no parameter-specific detail, so the baseline of 3 applies 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 action: 'Open the interactive CAD Studio.' It distinguishes itself from sibling tools by focusing on visual/interactive work rather than model management operations. The phrase 'view or work with a model visually' adds scope and 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 explicitly says 'Use this when the user asks to view or work with a model visually,' giving clear guidance on when to invoke it. It does not mention alternatives or exclusions, but the usability context is well-defined.
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?
Annotations indicate this is a mutating operation (readOnlyHint=false) but not destructive (destructiveHint=false). The description adds valuable context about concurrency control via expectedRevision and the 'replacing' behavior, which is not covered by annotations. It does not contradict any annotation.
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 wasted words. It front-loads the primary action and then provides a key usage tip, making it easy to scan and understand.
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?
Despite the lack of an output schema, the description does not mention what the tool returns or confirm partial vs. full update semantics (though 'replacing' implies partial). The concurrency guidance is useful, but given the tool's complexity (5 params, deep nested shape), a few more details about acceptable update combinations or response would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains expectedRevision's role in preventing concurrent overwrites and clarifies that shape is a 'parametric shape definition.' It does not detail each shape variant, but the schema provides that structure.
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 'Edit a CAD model by replacing its name, color, or parametric shape definition,' using a specific verb and resource. It distinguishes itself from sibling tools like create_model, transform_model, and delete_model by focusing on editing existing model attributes.
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 implies the tool is for editing an existing model's metadata/shape, which differentiates it from create/transform/delete. It explicitly advises 'Pass expectedRevision to prevent overwriting concurrent edits,' providing a concrete usage guideline. However, it does not explicitly mention alternatives like transform_model for geometric changes.
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:

[![mcp-cad-studio MCP server](https://glama.ai/mcp/servers/flujo-app/mcp-cad-studio/badges/card.svg)](https://glama.ai/mcp/servers/flujo-app/mcp-cad-studio)

Score Badge

Copy to your README.md:

[![mcp-cad-studio MCP server](https://glama.ai/mcp/servers/flujo-app/mcp-cad-studio/badges/score.svg)](https://glama.ai/mcp/servers/flujo-app/mcp-cad-studio)

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/flujo-app/mcp-cad-studio'

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