# Rupa3D (npm · rupa3d)

Checks GLB assets against a spec without Blender and embeds the measured proof inside the GLB.

- Trust score: 71/100 (medium)
- Change this week: +24
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- npm · `rupa3d`: 71/100 (this document), [markdown](https://verifymcp.io/servers/tiranyx-rupa3d/rupa3d.md), [page](https://verifymcp.io/servers/tiranyx-rupa3d/rupa3d)

## Channel facts

- Registry: `npm`
- Package: `rupa3d`
- Version: `1.6.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-21.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 33 of 103 dependencies flagged as unhealthy (1 deprecated).
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 5 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 66/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 8773 tokens (~243/item across 36 items; 36 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 23/100
  - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 89/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 66% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 36 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 37 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Rupa3D MCP server?

Rupa3D runs locally as an npm package, launched with npx -y rupa3d. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add tiranyx-rupa3d -- npx -y rupa3d
```

### Cursor

```json
{
  "mcpServers": {
    "tiranyx-rupa3d": {
      "command": "npx",
      "args": [
        "-y",
        "rupa3d"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "tiranyx-rupa3d": {
      "command": "npx",
      "args": [
        "-y",
        "rupa3d"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add tiranyx-rupa3d -- npx -y rupa3d
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tiranyx-rupa3d": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "rupa3d"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add tiranyx-rupa3d --command npx --arg -y --arg rupa3d
```

### Hermes

```yaml
mcp_servers:
  tiranyx-rupa3d:
    command: "npx"
    args: ["-y", "rupa3d"]
```

### Netclaw

```json
{
  "McpServers": {
    "tiranyx-rupa3d": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "rupa3d"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add tiranyx-rupa3d -t stdio -c npx -a -y rupa3d
```

### Other

```json
{
  "mcpServers": {
    "tiranyx-rupa3d": {
      "command": "npx",
      "args": [
        "-y",
        "rupa3d"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-21 (score 71, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-19 (score 70, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-17 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-16 (score 68, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-15 (score 53, +6)

- [security improvement] Malware scan: unverified → pass
- [security improvement] Source repository: fail → pass
- [functional regression] Security disclosure: unverified → fail
- [functional improvement] Stability: unverified → 0.03
- [functional] Package version: 1.6.1 → 1.6.2

### 2026-09-14 (score 47)

First indexed and scored.

## MCP tools (36)

### `rupa_status` (~50 tokens)

Versi Blender, akar ruang kerja, dan apakah adegannya sudah ada. Panggil sekali di awal.

Input parameters:

- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_baru` (~66 tokens)

Mulai adegan KOSONG. Menghapus isi adegan ruang kerja ini — panggil sekali di awal sebuah model, bukan di tiap langkah.

Input parameters:

- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `satuan` (string)

### `rupa_muat` (~339 tokens)

Impor berkas 3D (.glb .gltf .obj .fbx .stl .ply) atau VEKTOR 2D (.svg) ke adegan. Untuk SVG, `ekstrusi` > 0 langsung menebalkannya jadi 3D — ini jalur 2D→3D paling presisi yang ada, karena memakai kurva aslinya dan bukan tebakan.

Input parameters:

- `berkas` (string, required): Jalur absolut berkas yang diimpor.
- `ekstrusi` (number): Hanya untuk SVG: ketebalan. Path ber-FILL (spline tertutup) di-extrude jadi lempeng padat; path ber-STROKE (spline terbuka, ikon bergaya garis) di-bevel jadi tabung bulat berjari-jari ini — memperlak…
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `sisi_tabung` (integer): Resolusi bevel untuk path ber-stroke; 3 = 16 sisi, cukup halus dan murah.
- `tebal_nisbi` (number): Cara yang DISARANKAN untuk menyebut ketebalan: pecahan dari diagonal kotak batas hasil impor (mis. 0.02 = 2%). Menimpa `ekstrusi`. Satuan absolut tidak bisa ditebak — SVG 64x64 masuk sebagai objek se…

### `rupa_skrip` (~127 tokens)

PRIMITIF PEMODELAN: jalankan Python `bpy` di dalam Blender headless, lalu simpan adegannya. Tersedia: bpy, bmesh, math, mathutils, RUANG (jalur ruang kerja), dan dict `keluaran` yang ikut dikembalikan. Tulis bentuk dari ANGKA BERNAMA, bukan nilai ajaib — itu yang membuatnya bisa diubah lagi tanpa dibangun ulang.

Input parameters:

- `kode` (string, required)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_ukur` (~105 tokens)

Angka untuk tiap objek mesh: segitiga, simpul, n-gon, tepi tak-manifold, simpul lepas, luas, ukuran, letak, skala, apakah skala sudah diterapkan, bahan — plus kotak batas seluruh adegan dan daftar peringatan. Inilah yang membuat hasilnya presisi; mata tidak bisa membaca skala.

Input parameters:

- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_lihat` (~192 tokens)

Render beberapa sudut ke PNG dan kembalikan jalurnya — BACA gambarnya sesudah ini, jangan mengaku selesai dari angka saja. Kamera dan lampu dipasang otomatis dari kotak batas adegan, jadi objek sekecil atau sebesar apa pun tetap terbingkai. Sudut bernama: depan, belakang, kiri, kanan, atas, bawah, hero, serong; atau "yaw,pitch" dalam derajat.

Input parameters:

- `contoh` (integer)
- `fov` (number)
- `latar_tembus` (boolean)
- `mesin` (string): CYCLES untuk kaca/pembiasan yang benar; EEVEE jauh lebih cepat tapi menampilkan kaca sebagai susu buram.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `sudut` (array)
- `ukuran` (integer)

### `rupa_ekspor` (~143 tokens)

Ekspor adegan ke GLB. Skala diterapkan ke verteks lebih dulu (manual three.js menyebut skala pada node sebagai sumber masalah runtime), dan hasilnya dilaporkan bersama jumlah segitiga, kotak batas, dan peringatan.

Input parameters:

- `berkas` (string, required): Jalur absolut tujuan .glb
- `draco` (boolean): Kompresi Draco: berkas jauh lebih kecil, tapi pemuatnya butuh decoder Draco.
- `draco_level` (integer)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `terapkan_transformasi` (boolean)

### `rupa_lod` (~144 tokens)

Rantai LOD dengan GALAT GEOMETRIS tiap tingkat — jarak sesungguhnya tiap simpul hasil ke permukaan asli, mutlak dan sebagai persen diagonal. Mengecilkan mesh selalu "berhasil"; yang menentukan layak atau tidak adalah berapa banyak yang hilang. Di atas 2% diagonal, siluetnya mulai terbaca berubah.

Input parameters:

- `nisbah` (array): Pecahan segitiga yang DIPERTAHANKAN per tingkat, sama seperti Decimate modifier.
- `objek` (string): Nama mesh; kosong = semua mesh di adegan.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_tabrakan` (~201 tokens)

Proksi tabrakan + dua arah kesalahannya. "tembus" = permukaan asli yang berada DI LUAR proksi (benda menembus dinding); "longgar" = proksi yang jauh di luar permukaan asli (tabrakan terasa di udara kosong). Untuk mesin fisika web seperti Rapier, `cembung` adalah kuda bebannya — `mesh_sederhana` hanya untuk benda STATIS, karena trimesh dinamis tidak didukung sebagian besar mesin.

Input parameters:

- `bentuk` (string)
- `nisbah` (number): Penyederhanaan untuk `cembung` (bawaan 0,15) dan `mesh_sederhana` (0,25). Hull mentah bisa ribuan segitiga; mesin fisika ingin puluhan.
- `objek` (string)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_bake` (~237 tokens)

Panggang detail dari mesh RAPAT ke mesh RENGGANG jadi peta tekstur. UV dibuat otomatis kalau belum ada, jarak cage DIHITUNG dari selisih kedua permukaan (bukan ditebak), dan hasilnya dilaporkan dengan cakupan UV serta variasi piksel. Arah terbalik diperiksa dari kerapatan poligon — ia tidak bisa dideteksi dari gambarnya, karena membalik arah tetap menghasilkan peta yang tampak sah.

Input parameters:

- `berkas` (string, required): Jalur absolut PNG tujuan.
- `cage` (number): Kosongkan supaya dihitung dari selisih permukaan.
- `contoh` (integer)
- `jarak_sinar` (number)
- `jenis` (string)
- `margin` (integer)
- `rendah` (string, required): Mesh tujuan (renggang) — yang akan dipakai di game/web.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `tinggi` (string, required): Mesh sumber (rapat) — yang punya detailnya.
- `ukuran` (integer)

### `rupa_rantai` (~358 tokens)

Jalankan beberapa op Blender dalam SATU proses. Ini bukan kemudahan — ini perbedaan 7 kali lipat, dan angkanya diukur.

Menyalakan proses Blender cuma 449 ms; sisa 2,5–4 detik tiap panggilan adalah MUAT dan SIMPAN berkas .blend yang sama, diulang untuk setiap op. Enam op satu per satu makan 22,2 detik; enam op yang sama berantai makan 3,1 detik. Hasilnya terbukti IDENTIK bidang demi bidang, termasuk galat LOD dan dua arah galat proksi tabrakan.

RANTAI BERHENTI DI KEGAGALAN PERTAMA, dan itu disengaja: op berikutnya hampir selalu bergantung pada yang sebelumnya, dan menjalankannya di atas adegan setengah jadi menghasilkan angka yang tampak wajar untuk keadaan yang tidak pernah dimaksudkan.

YANG TIDAK BISA DIRANTAI: urutan yang punya KEPUTUSAN di tengah — misalnya memilih objek proksi tabrakan dari hasil pengukuran sebelumnya. Pecah jadi beberapa rantai di batas keputusan yang nyata; `rakit.mjs` memakai tiga.

Waktu per-op TIDAK diukur dalam mode ini; yang dilaporkan waktu seluruh rantai.

Input parameters:

- `ops` (array, required): Daftar op berurutan. Tiap entri memuat `op` plus argumen yang sama dengan tool tunggalnya — mis. { "op": "lod", "nisbah": [0.5, 0.25] }.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_periksa` (~337 tokens)

Nilai adegan terhadap SPEK, dan terbitkan SERTIFIKAT. Inilah yang membuat Rupa3D berbeda: hasilnya bukan "berhasil", melainkan daftar janji berikut angka yang membuktikan atau membantahnya. Aturan berbobot `wajib` menggagalkan; `peringatan` dilaporkan lengkap dengan angkanya tetapi tidak menjadi gerbang. Ukuran yang HILANG dihitung GAGAL — aturan yang diam-diam tidak dijalankan adalah cara paling halus sebuah pemeriksa berbohong.

Input parameters:

- `aset` (string): Nama aset untuk dicatat di sertifikat.
- `berkas` (string): GLB yang diukur LANGSUNG, tanpa Blender. Ini yang seharusnya dipakai untuk aset yang sudah jadi — termasuk keluaran generator mana pun. Sertifikat menggambarkan berkas yang ditempelinya, jadi angkany…
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `spek` (string, required): Jalur berkas spek JSON. Spek bawaan ikut paket dan boleh disebut relatif: spek/aset-generatif.json (GLB umum, 25 aturan), spek/kora-3d-penuh.json (35 aturan).
- `tempel_ke` (string): Jalur GLB yang akan DISALIN lalu ditempeli sertifikat pada `asset.extras.rupa3d`. Berkas asal tidak pernah ditulisi.

### `rupa_cad_status` (~87 tokens)

Kernel b-rep OCCT: nyala atau tidak, dan bentuk apa saja yang ada di ruang ini. Panggil sekali sebelum memakai tool `rupa_cad_*` lain — menyalakan kernelnya makan sekitar 0,4 detik, dan sesudah itu gratis.

Input parameters:

- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_cad_bentuk` (~297 tokens)

Buat primitif b-rep bernama. Beda mendasar dengan `rupa_skrip`: silinder di sini disimpan sebagai SILINDER — permukaan analitik berikut toleransinya — bukan segitiga yang menghampirinya. Volumenya EKSAK, dan itu bisa dibuktikan: silinder r=7,5 t=12 memberi angka yang sama persis dengan pi*r^2*t.

Input parameters:

- `arah` (array): Sumbu untuk silinder/kerucut/torus; bawaan [0,0,1].
- `jari` (number): silinder / bola / kerucut (jari bawah).
- `jari_atas` (number): kerucut; 0 = lancip.
- `jari_besar` (number): torus: jari lingkaran besar.
- `jari_kecil` (number): torus: jari penampang.
- `jenis` (string, required)
- `nama` (string, required): Nama bentuk di ruang CAD; satu segmen, tanpa pemisah jalur.
- `pusat` (array)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `sumbu` (array): elipsoid: [a, b, c].
- `tinggi` (number)
- `ukuran` (array): kotak: [x, y, z].

### `rupa_cad_boolean` (~138 tokens)

Potong, gabung, atau iris dua bentuk. Arah volumenya DIPERIKSA, dan itu bukan formalitas: boolean yang gagal separuh sering mengembalikan salah satu operand utuh, yang tampak berhasil sampai ada yang mengukurnya. Hasil yang arah volumenya salah tidak pernah tersimpan.

Input parameters:

- `a` (string, required): Bentuk dasar.
- `b` (string, required): Bentuk alat.
- `ke` (string): Nama hasil; kosong = timpa `a`.
- `operasi` (string, required)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_cad_tepi` (~113 tokens)

Daftar tepi sebuah bentuk berikut ARAH dan PANJANGNYA. Panggil ini SEBELUM fillet selektif — tanpa daftar ini, "fillet tepi tegak saja" berarti menebak indeks, dan indeks tepi bukan sesuatu yang bisa ditebak.

Input parameters:

- `nama` (string, required): Nama bentuk di ruang CAD; satu segmen, tanpa pemisah jalur.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_cad_fillet` (~302 tokens)

Bulatkan (fillet) atau serong (chamfer) tepi — SEMUA tepi, tepi searah tertentu, atau daftar indeks dari `rupa_cad_tepi`.

PERINGATAN YANG TERUKUR: di atas setengah sisi terkecil, `fillet` mengembalikan ok dengan solid RUSAK. Pada kotak 10x20x30, radius 5,001 memberi volume 7971 dari 6000 — fillet yang MENAMBAH material. Kernelnya tidak mengeluh. Tool ini menolaknya lewat dua pemeriksa bebas (isShapeValid dan arah volume), dan hasil yang gagal tidak pernah tersimpan. `chamfer` tidak punya masalah itu; ia gagal bersih.

Input parameters:

- `arah` (string): Hanya tepi yang sejajar sumbu ini.
- `jenis` (string)
- `ke` (string): Nama hasil; kosong = timpa asalnya.
- `nama` (string, required): Nama bentuk di ruang CAD; satu segmen, tanpa pemisah jalur.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `tepi` (array): Daftar indeks tepi dari `rupa_cad_tepi`. Menimpa `arah`.
- `ukuran` (number, required): Radius fillet, atau jarak chamfer. Batas amannya setengah sisi terkecil.

### `rupa_cad_sketsa` (~655 tokens)

Sketsa 2D → padat 3D: dorong (ekstrusi), putar (revolve), atau loft. Inilah cara benda nyata dimodelkan — gambar penampang, lalu bangkitkan. Satu tool ini membuka arsitektur (denah → dinding), pemodelan mesin (profil → poros/flange/wadah), dan 2D→3D (path → padat).

YANG MEMBEDAKANNYA: tiap padat DIPERIKSA terhadap RUMUS TERTUTUP. Ekstrusi dibandingkan dengan luas × jarak (luasnya dihitung shoelace dari polilinenya, bukan ditulis tangan); putar 360° dibandingkan dengan teorema Pappus (2π·R_centroid·luas). Terukur pada kernel ini: ekstrusi meleset 1e-14%, putar cocok dengan Pappus sampai 0,000000%. Hasil yang melenceng dari acuannya TIDAK disimpan.

DUA HAL YANG MENGHANCURKAN PUTAR, dijaga di depan karena galat kernelnya berupa pointer mentah yang tak terbaca: profil yang MELINTASI sumbu putar, dan sudut di luar 0..360.

Input parameters:

- `asal` (number): Geseran sepanjang normal bidang.
- `bidang` (string): Bidang gambarnya. Ekstrusi terjadi pada arah NORMAL bidang ini.
- `jarak` (number): ekstrusi: sejauh mana didorong.
- `jari` (number): lingkaran / polisegi
- `jari_besar` (number): elips
- `jari_kecil` (number): elips
- `jenis` (string): Bentuk profil 2D-nya.
- `lebar` (number): persegi
- `lurus` (boolean): loft: sisi lurus antar penampang, bukan melengkung.
- `mulai` (array): path: titik awal pena.
- `nama` (string, required): Nama untuk menyimpan hasilnya.
- `operasi` (string)
- `profil_loft` (array): loft: daftar profil, bentuknya sama dengan bidang profil di atas.
- `puntir` (number): ekstrusi: derajat puntiran sepanjang jaraknya. Volumenya tidak berubah — geseran tidak menambah material — dan itu justru yang mengujinya.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `segmen` (array): path: urutan segmen. Jalurnya ditutup otomatis.
- `sisi` (integer): polisegi
- `sudut` (number): putar: derajat.
- `sumbu` (array): putar: sumbu putarnya; bawaan [0,0,1].
- `teks` (string)
- `tinggi_loft` (array): loft: posisi tiap profil sepanjang normal bidang; harus sepanjang profil_loft.
- `tinggi_profil` (number): persegi (tinggi 2D-nya, bukan ekstrusi)
- `ukuran_teks` (number)

### `rupa_cad_ubah` (~211 tokens)

Geser, putar, skala, atau cermin sebuah bentuk. Volumenya diperiksa terhadap yang DIHARAPKAN secara matematis: geser dan putar tidak boleh mengubahnya sama sekali, skala mengubahnya pangkat tiga. Transformasi yang menggeser volume adalah gejala matriks yang salah, dan itu tidak terlihat sampai ada yang mengukur.

Input parameters:

- `cermin_normal` (array)
- `geser` (array)
- `ke` (string): Nama bentuk di ruang CAD; satu segmen, tanpa pemisah jalur.
- `nama` (string, required): Nama bentuk di ruang CAD; satu segmen, tanpa pemisah jalur.
- `putar_sudut` (number): Derajat.
- `putar_sumbu` (array)
- `putar_titik` (array)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `skala` (number)

### `rupa_cad_ukur` (~125 tokens)

Volume dan luas EKSAK, jumlah tepi dan muka, kotak batas — plus ongkos hampiran meshnya pada satu toleransi. Dua angka itu selalu dilaporkan bersama, disengaja: yang eksak sendirian tidak memberi tahu berapa yang HILANG saat bentuknya dikirim ke web.

Input parameters:

- `nama` (string, required): Nama bentuk di ruang CAD; satu segmen, tanpa pemisah jalur.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `toleransi` (number)

### `rupa_cad_daftar` (~56 tokens)

Semua bentuk di ruang CAD ini berikut volume, luas, jumlah tepi, dan apakah bentuknya sah — bukan cuma namanya.

Input parameters:

- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_cad_ekspor` (~203 tokens)

Tulis bentuk ke berkas. Pembagian yang menentukan, dan tidak disebut pesan galat mana pun:

  .step .iges     b-rep EKSAK, permukaan analitik — untuk CAD & CNC
  .stl .glb .obj  SEGITIGA, hampiran — untuk web & cetak

Yang kedua SELALU melenceng, berapa pun toleransinya diperkecil, jadi galatnya ikut dilaporkan. "Sudah diekspor" tanpa angka adalah kalimat yang tidak bisa dipercaya.

Input parameters:

- `berkas` (string, required): Jalur absolut; formatnya diambil dari ekstensinya.
- `nama` (string, required): Nama bentuk di ruang CAD; satu segmen, tanpa pemisah jalur.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `toleransi` (number): Hanya berlaku untuk format bersegitiga.

### `rupa_cad_impor` (~106 tokens)

Baca STEP/IGES/STL dari CAD lain, lalu UKUR isinya. Impor tanpa ukur tidak memberi tahu apa pun tentang apa yang masuk — dan STEP dari dunia luar sering membawa bentuk yang tidak sah, yang baru ketahuan saat dioperasikan.

Input parameters:

- `berkas` (string, required)
- `nama` (string, required): Nama untuk menyimpannya di ruang ini.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_adegan_baru` (~108 tokens)

Mulai adegan KOSONG yang sudah sah: kamera, cahaya lingkungan, dan matahari. Menimpa adegan ruang ini. Adegan adalah DATA — ia bisa diperiksa, dibandingkan, diberi versi, dan disusun oleh siapa pun, termasuk agen lewat tool ini.

Input parameters:

- `nama` (string): Nama adegan; jadi judul halaman saat terbit.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_adegan_aset` (~165 tokens)

Daftarkan GLB ke adegan. Yang dicatat bukan cuma jalurnya: ukuran berkas, KOTAK BATAS (dibaca dari accessor min/max glTF, tanpa memuat mesh), dan SERTIFIKATNYA kalau ada. Kotak batas itu yang membuat kesalahan skala bisa ditangkap sebelum terbit — kesalahan skala tidak muncul di daftar node, tidak menggagalkan apa pun, dan baru ketahuan kalau kebetulan kameranya menghadap ke sana.

Input parameters:

- `berkas` (string, required): Jalur absolut .glb
- `kunci` (string, required): Nama pendek untuk menyebut aset ini di node.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_adegan_node` (~666 tokens)

Tambah, ubah, atau hapus node. `jenis` boleh `aset` (memakai GLB terdaftar) atau bentuk dasar — bentuk dasar ada supaya lantai dan latar tidak menuntut satu GLB sendiri.

\`peran` menentukan apakah node ikut dinilai skalanya: `properti` = benda di panggung (dinilai), `latar` = lantai/dinding/langit (dikecualikan), `pandu` = grid/sumbu/penanda. Lantai 40 m di adegan bermedian 1,7 m BUKAN kesalahan skala, dan membedakannya lewat peran lebih jujur daripada melonggarkan ambang sampai lantai lolos.

Input parameters:

- `aksi` (string)
- `aset` (string): Kunci aset terdaftar; wajib kalau jenis = aset.
- `bayangan` (boolean)
- `bening` (number): Transmisi kaca 0..1.
- `fisika_bentuk` (string): Bentuk collider. DINYATAKAN, bukan diturunkan dari bentuk visualnya: collider yang mengikuti mesh persis adalah trimesh, dan trimesh tidak bisa dinamis di mesin fisika web mana pun.
- `fisika_gesekan` (number)
- `fisika_hapus` (boolean): Buang fisika dari node ini.
- `fisika_jenis` (string): Jenis badan. Kosongkan kalau node ini tidak ikut fisika.
- `fisika_kendali` (boolean): Node ini dikendalikan pemain (WASD + lompat).
- `fisika_kerapatan` (number): kg/m3.
- `fisika_massa` (number): kg. Sebutkan massa ATAU kerapatan, jangan keduanya - Rapier menerima keduanya dan diam-diam mengabaikan salah satunya.
- `fisika_pantul` (number): Restitusi 0..1.
- `fisika_titik` (array): WAJIB untuk bentuk `cembung`: larik datar [x,y,z,...] dari rupa_proksi. Maksimum 4096 titik (12288 angka) - convexHull Rapier rusak diam-diam di atas ~8.000 titik dan mengembalikan collider bervolume…
- `fisika_ukuran` (array): Ukuran collider kalau berbeda dari ukuran visualnya.
- `id` (string): Wajib untuk ubah/hapus; kosong saat tambah = dibuatkan.
- `jenis` (string)
- `kekasaran` (number)
- `logam` (number)
- `nama` (string)
- `pancar` (number)
- `peran` (string)
- `posisi` (array)
- `putar` (array): Derajat, XYZ.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `skala`
- `tampak` (boolean)
- `tembus` (number): Kebalikan opasitas sederhana.
- `ukuran` (array): Untuk bentuk dasar; tidak berlaku pada aset.
- `warna` (string)

### `rupa_adegan_cahaya` (~154 tokens)

Atur atau tambah cahaya. `id` yang sudah ada akan DITIMPA, jadi tool ini juga cara mengubah matahari bawaan. Adegan tanpa satu pun cahaya berkekuatan > 0 ditolak saat terbit — ia akan terbit HITAM, dan layar hitam tanpa pesan adalah kegagalan yang paling mahal.

Input parameters:

- `bayangan` (boolean)
- `hapus` (boolean)
- `id` (string)
- `jenis` (string)
- `kuat` (number)
- `posisi` (array)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `warna` (string)

### `rupa_adegan_kamera` (~86 tokens)

Posisi, target, dan bidang pandang kamera awal. Ini kamera yang dilihat orang saat halaman pertama dibuka — orbit sesudahnya milik pembaca.

Input parameters:

- `fov` (number)
- `posisi` (array)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `target` (array)

### `rupa_adegan_lingkungan` (~167 tokens)

Langit gradien, paparan (tone mapping ACES), bayangan, dan kabut. Paparan adalah pengatur terang yang BENAR di alur kerja PBR — menaikkan kekuatan cahaya untuk membuat gambar lebih terang akan merusak pantulan dan bayangannya.

Input parameters:

- `bayangan` (boolean)
- `kabut_dekat` (number)
- `kabut_jauh` (number)
- `kabut_mati` (boolean)
- `kabut_warna` (string)
- `langit_atas` (string)
- `langit_bawah` (string)
- `paparan` (number)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_adegan_lihat` (~134 tokens)

Isi adegan berikut ANGKANYA: tiap node dengan ukuran DUNIA-nya, sertifikat tiap aset, dan pemeriksaan SKALA TIMPANG — node yang diagonalnya menyimpang jauh dari median adegan. Panggil ini sebelum terbit. Kesalahan skala terjadi pada adegan pertama alat ini sendiri: sebuah ikon terbit 438 satuan di adegan bermedian 1,7 karena skalanya dipakai dari ingatan tentang aset LAIN, tanpa mengukur aset itu.

Input parameters:

- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_adegan_terbit` (~232 tokens)

Adegan jadi SATU halaman HTML yang berdiri sendiri — orbit, klik-pilih, dan tiap objek membawa angkanya. Aset ditanam sebagai base64 di dalam halamannya, bukan ditunjuk lewat URL: halaman yang memuat asetnya lewat jaringan akan tampil sebagai LAYAR KOSONG di lingkungan ber-CSP ketat, tanpa galat yang menyebut sebabnya.

Ongkosnya diukur, bukan diabaikan: base64 membengkakkan bita sekitar 4/3, dan anggaran 16 MB diperiksa SEBELUM menulis dengan menyebut aset penyumbang terbesar. Mode `mandiri` menghasilkan dokumen utuh untuk server statis mana pun; `mandiri: false` menghasilkan potongan tanpa <html>/<head> untuk penerbit yang memasang kerangkanya sendiri.

Input parameters:

- `berkas` (string, required): Jalur absolut .html tujuan.
- `judul` (string)
- `mandiri` (boolean)
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_topologi` (~388 tokens)

Periksa TOPOLOGI sebuah GLB — bagaimana verteksnya TERSAMBUNG, bukan di mana letaknya. Bekerja pada berkas dari mana pun, termasuk keluaran generator AI, tanpa perlu Blender.

Yang dilaporkan: tepi tak-manifold, tepi batas (lubang), segitiga berputar terbalik, segitiga degenerasi dan sliver, nisbah pecah verteks, sebaran kerapatan texel, dan UV di luar 0–1.

SATU HAL YANG MENENTUKAN: verteks DILAS menurut posisi sebelum dihitung. glTF memecah verteks di tiap jahitan UV, jadi menghitung manifold pada indeks mentah membuat setiap jahitan terlihat sebagai lubang — terukur pada satu aset: 30.790 mentah vs 360 setelah dilas, menggelembung 85 kali.

DAN YANG TIDAK BISA DIUKUR DARI GLB, disebut apa adanya: nisbah quad/n-gon dan pola edge loop sudah HILANG sebelum berkasnya ditulis, karena glTF selalu tersegitiga. Alat mana pun yang mengklaim menilai quad-dominance dari sebuah GLB sedang mengarang.

Input parameters:

- `berkas` (string, required): Jalur absolut .glb
- `per_primitif` (boolean): Sertakan rincian tiap primitif. Angka gabungan DIJUMLAHKAN bukan dirata-rata: rata-rata menenggelamkan satu primitif rusak parah di antara tiga puluh yang sehat.
- `toleransi_las` (number): Jarak maksimum dua titik dianggap sama. Kosongkan supaya diturunkan dari diagonal berkasnya (1e-6 x diagonal) — ambang MUTLAK akan melas seluruh model milimeter jadi satu titik.

### `rupa_topologi_sumber` (~478 tokens)

Topologi SUMBER: quad, n-gon, valensi verteks, KUTUB, dan EDGE LOOP — diukur dari mesh di dalam Blender, satu-satunya tempat keempatnya masih ada.

glTF SELALU tersegitiga, jadi `rupa_topologi` (yang membaca GLB) menyebut keempat ukuran ini "tidak bisa diukur" di tiap keluarannya. Itu benar, dan tool ini bukan penghampirannya — ia membaca sumbernya.

KENAPA INI YANG MENENTUKAN: yang membuat aset generatif menuntut dua sampai empat jam retopology manual bukan jumlah segitiganya, melainkan tidak adanya STRUKTUR — tidak ada edge loop yang mengikuti lipatan, valensi kacau, quad tidak ada. Mesh begitu tidak bisa dideformasi, di-subdivide, atau di-UV tanpa dibangun ulang.

BATAS YANG DISEBUT: memuat GLB ke Blender TIDAK memulihkan quad-nya. Kalau mesh yang diukur seluruhnya segitiga, keluarannya memuat `peringatan` yang menyatakan bahwa itu bisa berarti mesh memang bertopologi segitiga ATAU informasinya sudah musnah saat impor — dan alat ini tidak bisa membedakannya. Terukur: sebuah GLB 2.976 segitiga diimpor ulang keluar sebagai 2.976 segitiga dan NOL quad.

VERTEKS BATAS dikeluarkan dari analisis kutub: valensi != 4 di tepi terbuka itu wajar, bukan cacat — bidang datar 4x4 punya seluruh tepinya bervalensi 2 atau 3.

Input parameters:

- `ambang_sebidang` (number): Derajat. Quad yang keempat verteksnya menyimpang lebih dari ini dihitung TAK SEBIDANG — Blender, mesin game, dan eksportir glTF masing-masing memilih diagonal segitiganya sendiri, jadi bayangannya be…
- `objek` (string): Satu objek mesh; kosong = seluruh mesh di adegan.
- `per_objek` (boolean): Sertakan rincian tiap objek.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.

### `rupa_proksi` (~286 tokens)

Bangun proksi tabrakan CEMBUNG dari sebuah GLB, berikut ongkosnya yang terukur. Titiknya bisa langsung dipasang ke `rupa_adegan_node` sebagai `fisika.bentuk = "cembung"`.

Diukur dengan collider Rapier yang PERSIS akan berjalan (`projectPoint`), bukan dengan model hull terpisah — mengukur proksi dengan alat yang berbeda dari yang menjalankannya berarti mengukur benda yang berbeda.

PERINGATAN YANG TERUKUR: `convexHull` Rapier RUSAK DIAM-DIAM di atas sekitar 8.000 titik — tidak null, tidak melempar, tidak memperingatkan; ia mengembalikan collider bervolume NOL, dan benda dengan collider bervolume nol tidak menabrak apa pun: ia jatuh menembus dunia. Karena itu titiknya selalu direduksi lebih dulu dan hasilnya dijaga dua pemeriksa eksak.

Input parameters:

- `arah` (integer): Banyak arah penopang. Makin banyak makin rapat proksinya, dan ongkos ketepatannya ikut dilaporkan supaya bisa dipilih dengan angka.
- `berkas` (string, required): Jalur absolut .glb
- `sertakan_titik` (boolean): Sertakan larik titiknya. Matikan kalau cuma ingin angkanya.

### `rupa_tekstur` (~408 tokens)

Periksa TEKSTUR sebuah GLB, dan jawab pertanyaan yang sebenarnya ditanyakan orang: apakah teksturnya CUKUP untuk benda ini, atau TERLALU BESAR.

Jawabannya PIKSEL PER METER — kerapatan texel (UV per meter dunia) dikalikan ukuran tekstur. Kedua bahannya sudah ada di setiap GLB dan tidak ada alat yang mengalikannya. Di bawah ~100 px/m benda seukuran manusia buram dari dekat; di atas ~2000 px/m hampir selalu pemborosan.

TIGA PEMBOROSAN YANG TIDAK TERLIHAT DI LAYAR: peta RATA (1024² berisi satu nilai = 4 MB VRAM untuk sebuah angka), ALFA SIA-SIA (RGBA yang alfanya 255 di mana-mana = 25% memori terbuang), dan RESOLUSI SEMU (gambar 256² yang di-upscale jadi 1024² = memori empat kali lipat untuk detail yang sama persis).

Normal map diperiksa DUA syarat sekaligus: |v| mendekati 1 DAN biru tinggi. |v| sendirian tidak cukup — gambar gradien sembarang memberi |v|=1,105, cukup dekat untuk lolos.

FAKTOR ikut dilaporkan, dan itu bukan kelengkapan: di glTF nilai efektif = faktor × saluran tekstur. Melaporkan "saluran B = 255" tanpa menyebut metallicFactor: 0 mengundang kesimpulan bahwa bendanya logam penuh, padahal hasilnya nol.

Input parameters:

- `berkas` (string, required): Jalur absolut .glb
- `per_gambar` (boolean): Sertakan rincian tiap gambar.
- `piksel_per_meter` (boolean): Hitung px/meter. Menuntut pembacaan topologi juga, jadi sedikit lebih lambat.

### `rupa_tekstur_buat` (~356 tokens)

Bangun material PROSEDURAL di Blender, PANGGANG jadi peta gambar, lalu ganti materialnya dengan yang berbasis gambar supaya bisa diekspor.

Langkah terakhir itu yang paling mudah terlupa dan paling mahal: material prosedural Blender TIDAK BISA diekspor ke glTF sama sekali. Eksportirnya cuma mengerti nilai tetap dan peta gambar, jadi material prosedural yang indah di Blender terbit ke web sebagai ABU-ABU RATA, tanpa satu pun peringatan.

Tiga hal yang menentukan hasilnya: node gambar harus AKTIF sebelum bake (kalau tidak Blender memanggang ke tempat tak tentu dan diam saja); bake DIFFUSE bawaannya menyertakan pencahayaan sehingga bayangan lampu ikut terpanggang ke albedo; dan ruang warna harus disetel SEBELUM disimpan — albedo sRGB, sisanya Non-Color.

Input parameters:

- `contoh` (integer)
- `gaya` (string)
- `jenis` (array)
- `keluar` (string, required): Direktori tujuan peta PNG.
- `kuat_bump` (number): Kekuatan relief yang dipanggang ke normal map. Terlalu rendah menghasilkan peta yang praktis RATA — sah, tetapi memakan VRAM penuh tanpa membawa informasi. Terukur: 0,6 memberi jangkauan 125–130 dari…
- `objek` (string): Nama mesh; kosong = yang terbesar di adegan.
- `ruang` (string): Nama ruang kerja; tiap ruang punya adegan.blend sendiri.
- `ukuran` (integer)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/tiranyx-rupa3d/rupa3d#diagnostics

## Score history

- 2026-09-21: 71
- 2026-09-20: 70
- 2026-09-19: 70
- 2026-09-18: 69
- 2026-09-17: 69
- 2026-09-16: 68
- 2026-09-15: 53
- 2026-09-14: 47

## Common questions

### What is the Rupa3D MCP server?

Rupa3D is an MCP server listed in the public MCP registry as io.github.tiranyx/rupa3d. Checks GLB assets against a spec without Blender and embeds the measured proof inside the GLB. This page covers its npm package (rupa3d).

### Is the Rupa3D MCP server safe to use?

Rupa3D scores 71 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 September 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Rupa3D MCP server expose?

Rupa3D exposes 36 tools: rupa_status, rupa_baru, rupa_muat, rupa_skrip, rupa_ukur, and 31 more. Their descriptions and schemas cost roughly 8,220 tokens of context every time the server is loaded.

### Is the Rupa3D MCP server still maintained?

Rupa3D is still listed as active in the MCP registry. We last reached this channel on 21 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Rupa3D MCP server under?

Rupa3D declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/rupa3d
- Socket report: https://socket.dev/npm/package/rupa3d
- Repository: https://github.com/tiranyx/rupa3d-core
- Changelog RSS feed: https://verifymcp.io/servers/tiranyx-rupa3d/rupa3d.xml
- Changelog JSON feed: https://verifymcp.io/servers/tiranyx-rupa3d/rupa3d.json
- HTML version of this page: https://verifymcp.io/servers/tiranyx-rupa3d/rupa3d