Skip to main content
Glama
Eminemminem

BlenderMCP

by Eminemminem

generate_hyper3d_model_via_text

Create 3D models in Blender using text descriptions. Generate assets with built-in materials and import them directly into your scene.

Instructions

Generate 3D asset using Hyper3D by giving description of the desired asset, and import the asset into Blender. The 3D asset has built-in materials. The generated model has a normalized size, so re-scaling after generation can be useful.

Parameters:

  • text_prompt: A short description of the desired model in English.

  • bbox_condition: Optional. If given, it has to be a list of floats of length 3. Controls the ratio between [Length, Width, Height] of the model.

Returns a message indicating success or failure.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
text_promptYes
bbox_conditionNo

Implementation Reference

  • Primary handler function decorated with @mcp.tool(), defining parameters (schema), registering the tool, and implementing the core logic: processes bbox_condition, sends 'create_rodin_job' command to Blender addon, returns task UUID and subscription key or error.
    @mcp.tool()
    def generate_hyper3d_model_via_text(
        ctx: Context,
        text_prompt: str,
        bbox_condition: list[float]=None
    ) -> str:
        """
        Generate 3D asset using Hyper3D by giving description of the desired asset, and import the asset into Blender.
        The 3D asset has built-in materials.
        The generated model has a normalized size, so re-scaling after generation can be useful.
        
        Parameters:
        - text_prompt: A short description of the desired model in **English**.
        - bbox_condition: Optional. If given, it has to be a list of floats of length 3. Controls the ratio between [Length, Width, Height] of the model.
    
        Returns a message indicating success or failure.
        """
        try:
            blender = get_blender_connection()
            result = blender.send_command("create_rodin_job", {
                "text_prompt": text_prompt,
                "images": None,
                "bbox_condition": _process_bbox(bbox_condition),
            })
            succeed = result.get("submit_time", False)
            if succeed:
                return json.dumps({
                    "task_uuid": result["uuid"],
                    "subscription_key": result["jobs"]["subscription_key"],
                })
            else:
                return json.dumps(result)
        except Exception as e:
            logger.error(f"Error generating Hyper3D task: {str(e)}")
            return f"Error generating Hyper3D task: {str(e)}"
  • Supporting utility function used by the handler to normalize and validate the bbox_condition parameter into a list of integers scaled to 0-100.
    def _process_bbox(original_bbox: list[float] | list[int] | None) -> list[int] | None:
        if original_bbox is None:
            return None
        if all(isinstance(i, int) for i in original_bbox):
            return original_bbox
        if any(i<=0 for i in original_bbox):
            raise ValueError("Incorrect number range: bbox must be bigger than zero!")
        return [int(float(i) / max(original_bbox) * 100) for i in original_bbox] if original_bbox else None
  • Related helper tool to check if Hyper3D integration is enabled before using the generate tool.
    def get_hyper3d_status(ctx: Context) -> str:
        """
        Check if Hyper3D Rodin integration is enabled in Blender.
        Returns a message indicating whether Hyper3D Rodin features are available.
    
        Don't emphasize the key type in the returned message, but sliently remember it. 
        """
        try:
            blender = get_blender_connection()
            result = blender.send_command("get_hyper3d_status")
            enabled = result.get("enabled", False)
            message = result.get("message", "")
            if enabled:
                message += ""
            return message
        except Exception as e:
            logger.error(f"Error checking Hyper3D status: {str(e)}")
            return f"Error checking Hyper3D status: {str(e)}"
  • Docstring providing input schema description and usage instructions for the tool.
    """
    Generate 3D asset using Hyper3D by giving description of the desired asset, and import the asset into Blender.
    The 3D asset has built-in materials.
    The generated model has a normalized size, so re-scaling after generation can be useful.
    
    Parameters:
    - text_prompt: A short description of the desired model in **English**.
    - bbox_condition: Optional. If given, it has to be a list of floats of length 3. Controls the ratio between [Length, Width, Height] of the model.
    
    Returns a message indicating success or failure.
    """
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 key behavioral traits: the tool generates a 3D asset with built-in materials, imports it into Blender, normalizes size, and returns a success/failure message. However, it misses important details like potential rate limits, authentication needs, error handling specifics, or whether the operation is idempotent, leaving gaps for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded, starting with the core purpose. Sentences earn their place by adding useful details (e.g., built-in materials, normalized size, parameter explanations). However, minor redundancy exists (e.g., repeating '3D asset' and 'model'), and the structure could be slightly tighter by integrating parameter notes more seamlessly.

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 complexity (a generative AI tool with 2 parameters, no annotations, and no output schema), the description is moderately complete. It covers the main action, key parameters, and basic behavior, but lacks details on output format beyond 'success or failure message', error conditions, or integration specifics with Blender. For a tool with no structured support, more context on returns and limitations 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 adds meaningful semantics: 'text_prompt' is explained as 'A short description of the desired model in English,' and 'bbox_condition' as an optional list of 3 floats controlling length, width, height ratio. This clarifies usage beyond the bare schema, though it doesn't cover all potential edge cases (e.g., format details for bbox_condition).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate 3D asset using Hyper3D by giving description of the desired asset, and import the asset into Blender.' It specifies the verb (generate and import), resource (3D asset via Hyper3D), and destination (Blender). However, it doesn't explicitly differentiate from sibling tools like 'generate_hyper3d_model_via_images' or 'import_generated_asset', which would be needed for a score of 5.

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 by mentioning 'description of the desired asset' and optional bbox_condition, but it doesn't explicitly state when to use this tool versus alternatives like 'generate_hyper3d_model_via_images' or 'download_polyhaven_asset'. It provides some context (e.g., 're-scaling after generation can be useful') but lacks clear exclusions or prerequisites, such as when text-based vs. image-based generation is preferred.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

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/Eminemminem/blender-mcp'

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