Connect Threekit to ChatGPT: Manage 3D Models and Catalog Variants

If you need to connect Threekit to ChatGPT to automate 3D asset management, trigger composite render jobs, or manage complex catalog variants, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Threekit's REST APIs. If your team uses Claude, check out our guide on connecting Threekit to Claude or explore our broader architectural overview on connecting Threekit to AI Agents.

Giving a Large Language Model (LLM) read and write access to a 3D product configuration engine is an engineering challenge. Threekit's API is deeply relational - assets contain attributes, attributes have specific options, and catalog variants are generated from combinations of these options. Every time you want an LLM to update a product price or trigger a batch of WebGL renders, it has to traverse this graph correctly.

You can either spend weeks building, hosting, and maintaining this infrastructure yourself, or you use a managed integration layer that dynamically generates a secure, authenticated MCP server URL. This guide breaks down exactly how to use Truto to generate a managed MCP server for Threekit, connect it natively to ChatGPT, and execute complex 3D catalog workflows using natural language.

The Engineering Reality of the Threekit API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While Anthropic's open standard provides a predictable way for models to discover tools, the reality of implementing it against vendor APIs is painful.

If you decide to build a custom MCP server for Threekit, you own the entire API lifecycle. You are not just integrating a simple CRM database - you are orchestrating a cloud rendering pipeline. Here are the specific integration challenges that break standard CRUD assumptions when working with Threekit:

The Discriminated Union Nightmare for Attributes Threekit allows you to create highly customizable attributes on 3D assets (e.g., materials, dimensions, specific component toggles). When interacting with the create_a_threekit_asset_attribute or update_a_threekit_asset_attribute_by_id endpoints, the request body is a discriminated union keyed by a type field (String, Number, Boolean, Color, Asset, Array, or Global). Each type requires a completely different set of payload fields. If your MCP tool schemas do not strictly define these unions using JSON Schema anyOf or oneOf directives, the LLM will hallucinate mixed parameters - trying to pass a hex code to a Boolean attribute or a step-lock constraint to a String. Threekit will reject the payload immediately.

Asynchronous Render Jobs and Compositing When you request a high-fidelity image from Threekit, you do not get an image back in the HTTP response. Endpoints like threekit_asset_jobs_render_vray or threekit_asset_jobs_bulk_composites return a Job ID. You must then poll the jobs API to check the schedulerState. An LLM cannot natively "wait" for an external system without getting stuck in a loop. You must explicitly define tools that allow the LLM to trigger a job, capture the Job ID, and then periodically check the job status using list_all_threekit_jobs before attempting to download the results.

Strict Rate Limits Without Safety Nets Threekit enforces specific rate limits across its API. If your AI agent gets stuck in a loop - for example, trying to regenerate 5,000 catalog variants in a single pass - Threekit will return a HTTP 429 Too Many Requests error.

Note on rate limit handling: Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API returns HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller - in this case, ChatGPT or your agent orchestration framework - is entirely responsible for reading these headers and executing exponential backoff.

Creating the Managed MCP Server

Instead of forcing your engineering team to build a custom integration layer, handle discriminated union schemas, and maintain token lifecycles, you can use Truto.

Truto derives MCP tools dynamically from Threekit's resource definitions. Every tool exposed by the server includes robust JSON schemas mapped directly to Threekit's actual API endpoints.

Here is how you generate the server.

Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to the Integrated Accounts page for your Threekit connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server (name, allowed methods, tags, and expiry).
5. Click Create and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the API

You can generate servers programmatically to spin up isolated environments for specific AI workflows.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Threekit Render and Catalog Server",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The API returns a fully configured MCP URL backed by a secure, hashed token in Cloudflare KV. This URL is self-contained - it handles all authentication routing to your specific Threekit instance.

Connecting the MCP Server to ChatGPT

Once you have your MCP URL, connecting it to ChatGPT takes less than 60 seconds. You do not need to deploy any intermediary proxy servers.

Method A: Via the ChatGPT UI

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (MCP support requires this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: "Threekit (Truto)"
5. Server URL: Paste the Truto MCP URL.
6. Save the configuration. ChatGPT will instantly perform a handshake, call the tools/list protocol method, and parse the Threekit schemas.

Method B: Via Manual Config File

If you are using external agent frameworks (like LangChain, AutoGen, or Cursor) or want to run ChatGPT Desktop with a localized file, you can configure the connection via Server-Sent Events (SSE).

{
  "mcpServers": {
    "threekit-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4..."
      ]
    }
  }
}

Hero Tools for Threekit

Truto automatically generates tools for every documented Threekit endpoint. Here are the highest-leverage tools for automating 3D assets and catalog variants.

List All Threekit Assets

Retrieves 3D assets, folders, and materials with pagination. Crucial for discovery before triggering renders or generating variants.

Contextual usage notes: This tool accepts filters like tags, keywords, and type. If you only want to find materials to apply to a composite render, filter by type: Material. The tool automatically handles Threekit's cursor-based pagination - ensure your LLM passes the next_cursor value back unchanged if paging through large catalogs.

"Find all Threekit assets tagged with 'summer_collection' and filter for assets where the type is 'Model'. Show me their IDs and current default stage IDs."

Threekit Asset Jobs: Render VRay

Triggers an asynchronous, high-fidelity VRay render for a specific asset.

Contextual usage notes: This is a heavy operation. It requires the asset_id and the orgId. It returns a Job ID, not the image. The LLM must be instructed to track this Job ID and subsequently call the jobs endpoint to check completion status.

"Submit a VRay render job for the asset ID 'a1b2-c3d4-e5f6'. Use the default configuration and give me the Job ID so we can track it."

List All Threekit Catalog Variants

Fetches every generated variant combination for a specific catalog item.

Contextual usage notes: In Threekit, a catalog item might have millions of potential variants based on attribute configurations. This tool requires the item_id and is essential for auditing which configurations actually exist as instantiated variants in the system.

"List all generated variants for the catalog item ID 'item-9876'. Filter the results to only show variants with an active status."

Update a Threekit Catalog Variant By ID

Overwrites the status, metadata, or label of a specific catalog variant.

Contextual usage notes: Useful when a specific configuration becomes physically unavailable (e.g., a specific wood finish is out of stock). The LLM can find the variant matching that configuration and update its metadata or status to prevent users from ordering it.

"Update the catalog variant ID 'var-456' under item ID 'item-9876'. Change its label to 'Discontinued - Oak Finish' and update the status to offline."

Threekit Variant Prices Upsert

Creates or updates the price for a specific variant in a specific currency.

Contextual usage notes: Requires the item_id, variant_id, the three-letter ISO currency code (price_id), and the amount. The amount must be a valid float. This is the fastest way to programmatically update pricing rules across thousands of complex SKUs.

"Update the USD price for variant ID 'var-456' (item ID 'item-9876') to 1299.99."

Delete a Threekit Asset Attribute By ID

Removes an attribute (like a color toggle or a dimensional constraint) from an asset.

Contextual usage notes: Highly destructive. Requires both the asset_id and the attribute's id. If you remove an attribute, all variants relying on that attribute may become invalid or require regeneration.

"Remove the attribute ID 'attr-123' from the 3D asset ID 'a1b2-c3d4-e5f6'."

To view the complete schema definitions and the full inventory of available endpoints, visit the Threekit integration page.

Workflows in Action

Giving ChatGPT access to Threekit allows you to orchestrate workflows that would typically require a dedicated 3D technical artist or an e-commerce catalog administrator clicking through the platform for hours.

Workflow 1: Orchestrating an Asynchronous Render Pipeline

When a new material is uploaded, a technical artist needs to generate high-quality VRay renders of the flagship products using that material.

"Find the asset ID for the 'Modular Sofa V2'. Then, submit a VRay render job for it. Wait a few moments, check the job status, and once it is complete, tell me the file ID of the final image."

Execution Steps:

1. list_all_threekit_assets: The agent searches for the name "Modular Sofa V2" and extracts the asset_id and the orgId.
2. threekit_asset_jobs_render_vray: The agent submits the render request using the extracted IDs. Threekit responds with a 202 Accepted and a jobId.
3. list_all_threekit_jobs: The agent filters by the jobId to check the schedulerState. If it says "running" or "queued", the agent waits.
4. list_all_threekit_jobs: The agent polls again. Once the state is "completed", it extracts the output fileId and presents it to the user.

sequenceDiagram
    participant AI as ChatGPT
    participant MCP as Truto MCP Server
    participant TK as Threekit API

    AI->>MCP: Call list_all_threekit_assets (name="Modular Sofa V2")
    MCP->>TK: GET /api/assets?name=Modular Sofa V2
    TK-->>MCP: Returns Asset ID
    MCP-->>AI: { id: "asset-123" }
    
    AI->>MCP: Call threekit_asset_jobs_render_vray (asset_id="asset-123")
    MCP->>TK: POST /api/assets/asset-123/jobs/render/vray
    TK-->>MCP: { jobId: "job-999" }
    MCP-->>AI: Job queued.
    
    loop Polling
        AI->>MCP: Call list_all_threekit_jobs (status="job-999")
        MCP->>TK: GET /api/jobs/job-999
        TK-->>MCP: { schedulerState: "completed", output: { fileId: "file-456" } }
        MCP-->>AI: Render finished.
    end

Workflow 2: Bulk Pricing Updates on Catalog Variants

An e-commerce administrator needs to implement a 10% price increase on a specific high-end configuration across the catalog.

"Find the catalog item for 'Executive Desk'. List all of its variants. Identify any variant that has the 'Mahogany' finish in its configuration, and upsert its EUR price to 850.00."

Execution Steps:

1. list_all_threekit_catalog_items: The agent searches for "Executive Desk" and extracts the item_id.
2. list_all_threekit_catalog_variants: The agent pulls the massive array of variants for that item, explicitly requesting the configuration metadata in the response.
3. Local processing: ChatGPT analyzes the JSON response, filtering the variants where configuration.finish == 'Mahogany' to isolate the target variant IDs.
4. threekit_variant_prices_upsert: The agent iteratively calls this tool for each identified variant, passing item_id, variant_id, price_id: 'EUR', and amount: 850.00.

The user receives a confirmation list of exactly which variant IDs were updated and their new base prices, executing a surgical catalog update without writing a script.

Security and Access Control

Handing an LLM unrestricted write access to a production 3D catalog is dangerous. One hallucination could trigger thousands of dollars in VRay cloud rendering compute costs, or delete global attributes that break every product configurator on your website.

Truto's MCP architecture enforces strict security controls at the server level, meaning the LLM physically cannot execute unauthorized operations.

• Method Filtering: You can scope a server strictly to safe operations. By passing methods: ["read"] during creation, Truto filters out create, update, and delete tools entirely. The LLM can list assets and view prices, but cannot alter them.
• Tag Filtering: Limit the scope of the server to specific functional areas. By passing tags: ["analytics"], the LLM will only see tools related to threekit_analytics_get_event or threekit_analytics_generate_reports, completely hiding the core asset mutation tools.
• require_api_token_auth: By default, possessing the MCP URL grants access. By setting this flag to true, the client must also supply a valid Truto API token in the Authorization header. This adds a critical second layer of defense if the URL is ever exposed in logs or shared spaces.
• expires_at: If you are generating a server for an automated temporary job (e.g., an overnight catalog sync script driven by an agent), pass an ISO timestamp. The Truto Durable Object architecture will automatically purge the server credentials from Cloudflare KV the millisecond the clock strikes.

Building a custom integration for Threekit requires understanding discriminated schemas, asynchronous job polling, and strict API limits. Maintaining that logic as an AI toolset consumes engineering resources that should be spent on your core product.

By leveraging a managed MCP server, you eliminate the integration boilerplate. You map your Threekit credentials once, configure your strict access controls, and hand the resulting URL directly to ChatGPT. Your agents get deterministic, schema-validated access to Threekit's engine, allowing you to orchestrate 3D rendering pipelines and complex catalog variant logic using nothing but natural language.