Skip to main content
Glama

create_3d_model_from_image

Convert a 2D image into a 3D model using Tripo AI technology. Start the conversion process by providing an image file, then monitor task status to retrieve the completed 3D model.

Instructions

Create a 3D model from an image using the Tripo API.

IMPORTANT: This tool initiates a 3D model generation task but does NOT wait for completion.
After calling this tool, you MUST repeatedly call the get_task_status tool with the returned
task_id until the task status is SUCCESS or a terminal error state.

Typical workflow:
1. Call create_3d_model_from_image to start the task
2. Get the task_id from the response
3. Call get_task_status with the task_id
4. If status is not SUCCESS, wait a moment and call get_task_status again
5. Repeat until status is SUCCESS or a terminal error state
6. When status is SUCCESS, use the pbr_model_url from the response

Args:
    image: The local path or url to the image file.
    face_limit: The maximum number of faces in the model.
    auto_size: Whether to automatically size the model.

Returns:
    A dictionary containing the task ID and instructions for checking the status.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
imageYes
face_limitNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The @mcp.tool()-decorated asynchronous handler function implementing the 'create_3d_model_from_image' tool. It uses the Tripo API to start a 3D model generation task from an image, returns a task_id, and instructs to poll status with another tool.
    @mcp.tool()
    async def create_3d_model_from_image(
        image: str, face_limit: int = -1
    ) -> Dict[str, Any]:
        """
        Create a 3D model from an image using the Tripo API.
    
        IMPORTANT: This tool initiates a 3D model generation task but does NOT wait for completion.
        After calling this tool, you MUST repeatedly call the get_task_status tool with the returned
        task_id until the task status is SUCCESS or a terminal error state.
    
        Typical workflow:
        1. Call create_3d_model_from_image to start the task
        2. Get the task_id from the response
        3. Call get_task_status with the task_id
        4. If status is not SUCCESS, wait a moment and call get_task_status again
        5. Repeat until status is SUCCESS or a terminal error state
        6. When status is SUCCESS, use the pbr_model_url from the response
    
        Args:
            image: The local path or url to the image file.
            face_limit: The maximum number of faces in the model.
            auto_size: Whether to automatically size the model.
    
        Returns:
            A dictionary containing the task ID and instructions for checking the status.
        """
        # Get the API key from environment variable
        # api_key = os.environ.get("TRIPO_API_KEY")
        get_blender_connection()
        api_key = _tripo_apikey
        if not api_key:
            raise ValueError(
                "It may take some more time to correctly re-enter the tripo function. You can first check the scene and then try the tripo function again later"
            )
    
        # Create the Tripo client
        async with TripoClient(api_key=api_key) as client:
            # Create a text-to-model task
            task_id = await client.image_to_model(
                image=image,
                face_limit=face_limit,
            )
    
            # Get initial task status
            task = await client.get_task(task_id)
    
            # Return immediately with task ID and status
            return {
                "task_id": task_id,
                "status": str(task.status),
                "progress": task.progress,
                "message": "Task created successfully. The 3D model generation is in progress.",
                "next_step": "You MUST now call get_task_status with this task_id to check progress.",
                "important_note": "3D model generation takes 3-5 minutes. You need to repeatedly call get_task_status until completion.",
                "workflow": [
                    "1. You've completed this step by calling create_3d_model_from_image",
                    "2. Now call get_task_status with task_id: " + task_id,
                    "3. If status is not SUCCESS, wait and call get_task_status again",
                    "4. When status is SUCCESS, use the pbr_model_url from the response",
                ],
            }
  • src/server.py:783-783 (registration)
    The @mcp.tool() decorator registers the create_3d_model_from_image function as an MCP tool.
    @mcp.tool()
Behavior4/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the asynchronous nature of the operation, the need for polling with another tool, and the expected workflow. It doesn't mention rate limits, authentication requirements, or error handling specifics, but provides substantial behavioral context beyond basic functionality.

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 well-structured with clear sections. The workflow steps are numbered for clarity. While comprehensive, some information could be more concise, such as the detailed workflow that spans multiple sentences. Overall, most content earns its place in helping the agent understand the tool's usage.

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

Completeness5/5

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

Given the tool's complexity (asynchronous operation requiring polling), no annotations, and the presence of an output schema, the description provides excellent contextual completeness. It explains the asynchronous nature, the required follow-up actions, the return value usage, and references the output schema's content. This adequately compensates for the lack of annotations.

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?

With 0% schema description coverage, the description must compensate for the lack of parameter documentation. It provides clear explanations for all 3 parameters mentioned (image, face_limit, auto_size), though the input schema only shows 2 parameters (missing auto_size). The description adds meaningful context about what each parameter controls, though there's a parameter mismatch between description and schema.

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 specific action ('Create a 3D model from an image') and identifies the resource ('using the Tripo API'). It distinguishes from sibling tools like 'create_3d_model_from_text' by specifying the image input source, and from 'import_tripo_glb_model' by indicating generation rather than import.

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

Usage Guidelines5/5

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

The description provides explicit guidance on when to use this tool ('initiates a 3D model generation task') and when not to use it ('does NOT wait for completion'). It clearly names the alternative tool ('get_task_status') that must be used in conjunction and provides a detailed 6-step workflow for proper usage.

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/VAST-AI-Research/tripo-mcp'

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