Skip to main content
Glama
Mming-Lab
by Mming-Lab

build_hyperboloid

Construct hyperboloid structures like cooling towers or hourglasses in Minecraft Bedrock by specifying base and waist radii, height, and center coordinates. Customize material, hollow/solid design, and axis orientation.

Instructions

Build HYPERBOLOID: cooling tower, hourglass, nuclear tower. Requires: centerX,centerY,centerZ,baseRadius,waistRadius,height. Optional: axis

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
actionNoBuild action to performbuild
axisNoHyperboloid axis direction: x (east-west), y (up-down), z (north-south)y
baseRadiusYesRadius at the base in blocks. Small: 5-8, Medium: 10-15, Large: 20-30
centerXYesCenter X coordinate (east-west position of hyperboloid base center)
centerYYesCenter Y coordinate (height/vertical position of hyperboloid base, typically 64-100)
centerZYesCenter Z coordinate (north-south position of hyperboloid base center)
heightYesTotal height of the hyperboloid in blocks. Small: 10-15, Medium: 20-30, Large: 40-60
hollowNoMake it hollow (true) for tower shell, or solid (false) for full hyperboloid
materialNoBlock type to build with (e.g. stone, glass, wool, concrete, etc.)minecraft:stone
waistRadiusYesRadius at the narrowest point (waist) in blocks. Should be smaller than baseRadius

Implementation Reference

  • The main execute method that implements the build_hyperboloid tool. Validates inputs, calculates hyperboloid positions using calculateHyperboloidPositions utility, and executes the build using executeBuildWithOptimization.
    async execute(args: {
        action?: string;
        centerX: number;
        centerY: number;
        centerZ: number;
        baseRadius: number;
        waistRadius: number;
        height: number;
        material?: string;
        hollow?: boolean;
        axis?: 'x' | 'y' | 'z';
    }): Promise<ToolCallResult> {
        try {
            // Socket-BE API接続確認
            if (!this.world) {
                return { success: false, message: "World not available. Ensure Minecraft is connected." };
            }
    
            const { 
                action = 'build',
                centerX, 
                centerY, 
                centerZ, 
                baseRadius, 
                waistRadius, 
                height, 
                material = 'minecraft:stone', 
                hollow = false, 
                axis = 'y' 
            } = args;
            
            // actionパラメータをサポート(現在は build のみ)
            if (action !== 'build') {
                return this.createErrorResponse(`Unknown action: ${action}. Only 'build' is supported.`);
            }
            
            // 座標の整数化
            const center = {
                x: Math.floor(centerX),
                y: Math.floor(centerY),
                z: Math.floor(centerZ)
            };
            
            // Y座標の検証
            if (center.y < -64 || center.y + height > 320) {
                return {
                    success: false,
                    message: 'Hyperboloid extends beyond valid Y coordinates (-64 to 320)'
                };
            }
            
            // パラメータの検証
            if (baseRadius < 3 || baseRadius > 50) {
                return {
                    success: false,
                    message: 'Base radius must be between 3 and 50'
                };
            }
            
            if (waistRadius < 1 || waistRadius > 30) {
                return {
                    success: false,
                    message: 'Waist radius must be between 1 and 30'
                };
            }
            
            if (waistRadius >= baseRadius) {
                return {
                    success: false,
                    message: 'Waist radius must be smaller than base radius'
                };
            }
            
            if (height < 4 || height > 100) {
                return {
                    success: false,
                    message: 'Height must be between 4 and 100'
                };
            }
            
            // ブロックIDの正規化
            let blockId = material;
            if (!blockId.includes(':')) {
                blockId = `minecraft:${blockId}`;
            }
            
            const commands: string[] = [];
            let blocksPlaced = 0;
            
            const baseRadiusInt = Math.round(baseRadius);
            const waistRadiusInt = Math.round(waistRadius);
            const heightInt = Math.round(height);
            
            // 座標変換ヘルパー関数
            const transformCoordinates = (localX: number, localY: number, localZ: number): {x: number, y: number, z: number} => {
                switch (axis) {
                    case 'x':
                        // X軸ハイパーボロイド: Y-Z平面で展開、X方向に伸びる
                        return {
                            x: center.x + localY,
                            y: center.y + localZ,
                            z: center.z + localX
                        };
                    case 'z':
                        // Z軸ハイパーボロイド: X-Y平面で展開、Z方向に伸びる
                        return {
                            x: center.x + localX,
                            y: center.y + localZ,
                            z: center.z + localY
                        };
                    case 'y':
                    default:
                        // Y軸ハイパーボロイド(デフォルト): X-Z平面で展開、Y方向に伸びる
                        return {
                            x: center.x + localX,
                            y: center.y + localY,
                            z: center.z + localZ
                        };
                }
            };
            
            // 双曲面の座標を計算
            const positions = calculateHyperboloidPositions(center, baseRadiusInt, heightInt, waistRadiusInt / baseRadiusInt, hollow);
            
            if (positions.length > BUILD_LIMITS.HYPERBOLOID) {
                return {
                    success: false,
                    message: `Too many blocks to place (maximum ${BUILD_LIMITS.HYPERBOLOID.toLocaleString()})`
                };
            }
            
            try {
                // 最適化されたビルド実行
                const result = await executeBuildWithOptimization(
                    this.world,
                    positions,
                    blockId,
                    {
                        type: 'hyperboloid',
                        center: center,
                        baseRadius: baseRadiusInt,
                        waistRadius: waistRadiusInt,
                        height: heightInt,
                        material: blockId,
                        hollow: hollow,
                        axis: axis,
                        apiUsed: 'Socket-BE'
                    }
                );
                
                if (!result.success) {
                    return this.createErrorResponse(result.message);
                }
                
                return {
                    success: true,
                    message: result.message,
                    data: result.data
                };
            } catch (buildError) {
                return this.createErrorResponse(`Building error: ${buildError instanceof Error ? buildError.message : String(buildError)}`);
            }
    
        } catch (error) {
            return {
                success: false,
                message: `Error building hyperboloid: ${error instanceof Error ? error.message : String(error)}`
            };
        }
    }
  • Input schema defining the required and optional parameters for the build_hyperboloid tool, including coordinates, radii, height, material, hollow option, and axis.
    readonly inputSchema: InputSchema = {
        type: 'object',
        properties: {
            action: {
                type: 'string',
                description: 'Build action to perform',
                enum: ['build'],
                default: 'build'
            },
            centerX: {
                type: 'number',
                description: 'Center X coordinate (east-west position of hyperboloid base center)'
            },
            centerY: {
                type: 'number',
                description: 'Center Y coordinate (height/vertical position of hyperboloid base, typically 64-100)'
            },
            centerZ: {
                type: 'number',
                description: 'Center Z coordinate (north-south position of hyperboloid base center)'
            },
            baseRadius: {
                type: 'number',
                description: 'Radius at the base in blocks. Small: 5-8, Medium: 10-15, Large: 20-30',
                minimum: 3,
                maximum: 50
            },
            waistRadius: {
                type: 'number',
                description: 'Radius at the narrowest point (waist) in blocks. Should be smaller than baseRadius',
                minimum: 1,
                maximum: 30
            },
            height: {
                type: 'number',
                description: 'Total height of the hyperboloid in blocks. Small: 10-15, Medium: 20-30, Large: 40-60',
                minimum: 4,
                maximum: 100
            },
            material: {
                type: 'string',
                description: 'Block type to build with (e.g. stone, glass, wool, concrete, etc.)',
                default: 'minecraft:stone'
            },
            hollow: {
                type: 'boolean',
                description: 'Make it hollow (true) for tower shell, or solid (false) for full hyperboloid',
                default: false
            },
            axis: {
                type: 'string',
                description: 'Hyperboloid axis direction: x (east-west), y (up-down), z (north-south)',
                enum: ['x', 'y', 'z'],
                default: 'y'
            }
        },
        required: ['centerX', 'centerY', 'centerZ', 'baseRadius', 'waistRadius', 'height']
    };
  • src/server.ts:365-365 (registration)
    Instantiation of the BuildHyperboloidTool class, added to the tools array for MCP registration.
    new BuildHyperboloidTool(), // ✅ 基本動作
  • src/server.ts:16-16 (registration)
    Import statement for the BuildHyperboloidTool class.
    import { BuildHyperboloidTool } from "./tools/advanced/building/build-hyperboloid";
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It states 'Build' which implies a write/mutation operation but doesn't mention permissions needed, whether it's destructive to existing blocks, rate limits, or what happens on success/failure. The description is minimal and lacks critical behavioral context for a construction 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 brief and front-loaded with the core purpose. However, the second sentence listing parameters feels somewhat redundant given the comprehensive schema. Overall efficient but could be more polished.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a construction tool with 10 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what gets built (blocks placed in world), success conditions, error handling, or how it differs from similar building tools. The agent would lack crucial context for proper use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description lists required parameters but adds no additional meaning beyond what's in the schema (e.g., it doesn't explain relationships between parameters or provide usage examples). Baseline 3 is appropriate when schema does the heavy lifting.

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

Purpose4/5

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

The description clearly states the verb 'Build' and resource 'HYPERBOLOID' with specific examples (cooling tower, hourglass, nuclear tower), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like build_cylinder or build_paraboloid, which would require a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like build_cylinder or build_sphere. It lists required parameters but offers no context about appropriate use cases, prerequisites, or comparisons to sibling tools.

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

Related 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/Mming-Lab/minecraft-bedrock-mcp-server'

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