BOM · Project 1 — Design-reuse Retrieval¶

This section contains the spec-only bill of materials (BOM) for Project 1, the design-reuse retrieval system. It lists the hardware, the software stack, and the licensing constraints, so a potential customer can size and scope a build.

D.1 The key decision: CATIA touches each part once, at ingestion¶

Retrieval needs geometry only to build the index, never to answer a query. So the sizing decision is even simpler than Project 2's: CATIA (if used at all) touches each part once, to produce the views, and is never in the query loop. After ingestion, embedding, indexing and search run entirely on open-source tooling.

There are two ways to get the rendered views out, mirroring Project 2's Option 1 / Option 2:

In short: CATIA or a one-time STEP conversion produces the views; everything after that is open-source and offline.

CATPart: CATIA's native part file; STEP: neutral CAD exchange format (ISO 10303).

	Option 1 — CATIA exports views	Option 2 — STEP-first
CATIA at ingestion	Yes, a licensed seat to batch-render	No; a standalone converter makes STEP, then open-source renders it
CATIA at query time	No, in both options	No
Operating system	Windows for the export step	Linux for the whole pipeline
Main risk	Windows + CATIA seat coupling for the export	Conversion + render fidelity on complex parts

Because Project 2 already needs a STEP path for its geometry checks, Option 2 shares that converter (Datakit CrossManager, no CATIA seat).¹

D.2 BOM — compute¶

The GPU need rises with the phase, which suits the "start minimal, scale on evidence" staging.

Phase	What runs	GPU need	Notes
Phase 1, shape search	vision encoder, one-time batch embedding	modest: a few GB VRAM; CPU-tolerable if slower	DINOv2 ViT-L ≈ 300M params, ViT-g ≈ 1.1B; weights are well under ~2 GB at half precision²
Phase 2, language layer	the local LLM joins	24 GB-class, the same as Project 2	reuse Project 2's compute BOM; no second GPU needed
Phase 3, B-rep re-rank	self-supervised training of a B-rep encoder	a training-capable GPU, one-time	see D.5; optional and evidence-gated

The key point: Phase 1 is light. Embedding a design-office library (hundreds of distinct parts, a few thousand files) is a one-time job that a single modest GPU finishes quickly, and a CPU can do it if slower runs are acceptable.² The heavy GPU appears only when the LLM does, in Phase 2.

D.3 BOM — the vision encoder¶

Component	Recommendation	Alternate	Notes
Image embedding model	DINOv2 (Meta)	OpenCLIP (LAION)	DINOv2 weights + code are Apache-2.0, cleanly commercial³; OpenCLIP code is MIT, but its checkpoints inherit their LAION training-data terms⁴

One honest caveat. Vision encoders are trained on everyday photographs, and untextured grey CAD renders are a known domain gap: the 3D-vision literature reports that CAD-style shaded renders, lacking texture and realistic lighting, align less well than natural images.⁵ Treat the magnitude as reasoned caution, not a measured number, and check it at the pilot. This is one reason the exact-geometry Phase 3 exists as a fallback.

D.4 BOM — supporting software (all open-source)¶

None of these needs a licence; specifying the hardware is enough.

Component	Option (+ alternate)	Hardware	GPU?
Vector database	FAISS (MIT) / Qdrant or Chroma (Apache-2.0)	CPU + a few GB RAM; index is small (GBs for a design-office library)	No⁶
Metadata database + query tool	any relational or document store (e.g. SQLite / Postgres)	CPU; tiny	No
View rendering (Option 2)	Open CASCADE / FreeCAD / trimesh	CPU	No
LLM serving (Phase 2)	Ollama / vLLM	shares the Phase-2 GPU	Yes

The metadata database is where the fetch-and-filter work lives: material, customer, family, dimensions and links to past records, queried directly (Phase 1) or by the LLM (Phase 2). Building it is mostly data cleanup, the boring but mandatory part.

D.5 BOM — optional Phase-3 B-rep encoder¶

Phase 3 adds exact, dimension-aware matching by embedding the B-rep solid, not a screenshot. It is optional and adopted only if Phase 1 proves too coarse. The honest licensing picture:

Option	Reads	Licence	Verdict
UV-Net (Autodesk)	B-rep (from STEP)	code MIT; no general/moulding-ready weights released⁷	Primary: train self-supervised on the firm's own parts
UVStyle-Net (Autodesk)	B-rep, style similarity	CC BY-NC-SA 4.0, non-commercial⁸	Method is the most task-aligned, but the released code is non-commercial; reimplement the approach on UV-Net's MIT encoder rather than reuse it
Point-cloud encoders (OpenShape / ULIP-2 / Uni3D)	points sampled from a mesh	code permissive, but weights blocked by training-data terms (Objaverse / ShapeNet)⁹	Item to watch: 3D-aware and sidesteps STEP conversion, but the weights are not cleanly commercial

Three facts to keep in mind:

No moulding-ready B-rep weights exist. Every option needs self-supervised training on the firm's own parts (no labels needed, but real ML effort).
B-rep re-imposes the STEP conversion that the render path avoids, so Phase 3 only makes sense alongside Option 2 ingestion.
The evidence that 3D-aware retrieval works is real but modest: the Mechanical Components Benchmark reports best-in-class retrieval around 89–91% precision, not the higher figures sometimes quoted.¹⁰

D.6 BOM — workstation baseline¶

Phase 1: a modest GPU (or CPU) for one-time embedding; 16–32 GB system RAM; NVMe SSD with room for the model, the small index and the metadata DB.
Phase 2: the 24 GB-class GPU from Project 2's baseline; the same box can host both projects.
Network: none at runtime; fully offline / LAN.

Ingestion machine: Option 2's converter needs no CATIA seat¹ and can share the Linux box. Only Option 1 (CATIA batch-render) needs a licensed Windows CATIA workstation, and only during ingestion.

D.7 Licensing constraints to confirm¶

Item	What to confirm	With whom
CATIA seat (Option 1 only)	That batch screenshot/render runs consume a standard seat, and licence-server capacity	Dassault / CATIA sales
STEP export (Option 1 → 2)	Whether batch CATPart→STEP export needs a separate CATIA licence, not publicly confirmed; do not assume	Dassault / CATIA sales
Converter licensing (Option 2)	CrossManager tier (GUI file-count limit vs CLI batch) and per-seat vs floating¹	Datakit
OpenCLIP checkpoint terms	If OpenCLIP is chosen over DINOv2, confirm the specific checkpoint's training-data terms for commercial use⁴	(self-check)

D.8 Open questions & limitations¶

Held honestly, per the study's evidence-first stance:

Grey-render domain gap is documented but unquantified. How much accuracy the untextured CAD look costs is not measured here; confirm at pilot.⁵
Image embeddings are scale-blind. Phase 1 recovers size only via metadata (bounding box, volume); true dimension-aware matching is the optional Phase 3.
No moulding-ready B-rep weights. Phase 3 means training your own encoder.
Point-cloud weights are licence-blocked by their training-data terms, not their code, so they are an item to watch, not a recommendation.⁹
Library size and metadata richness are unconfirmed (no access yet). Manufacturing outcomes attached to parts (gate positions, tool changes) are aspirational until confirmed with the customer.

D.9 References¶

Datakit CrossManager runs "on premise, without the need of external third-party CAD licenses," reads CATIA V5 CATPart/CATProduct and writes STEP, and offers a CLI tier for headless batch conversion. https://www.datakit.com/en/cross_manager.php (accessed Aug 2026). See Project 2's BOM for the full CATIA-licensing analysis. ↩↩↩
DINOv2 model sizes from the official repo table: ViT-S/14 ≈ 21M, ViT-B/14 ≈ 86M, ViT-L/14 ≈ 300M, ViT-g/14 ≈ 1.1B parameters. https://github.com/facebookresearch/dinov2 (accessed Aug 2026). At half precision the weights alone are well under ~1 GB (ViT-L) to ~2 GB (ViT-g); inference adds only per-batch activations, so batch embedding fits in a few GB of VRAM. [Inference] The GB figures are reasoned from parameter count and precision, not a measured benchmark. ↩↩
DINOv2 (Meta AI Research) code and pretrained weights are released under Apache-2.0. https://github.com/facebookresearch/dinov2/blob/main/LICENSE (accessed Aug 2026). ↩
OpenCLIP (mlfoundations/open_clip) code is MIT; pretrained checkpoints are trained on LAION/DataComp datasets and inherit those data terms, a separate matter from the code licence. https://github.com/mlfoundations/open_clip/blob/main/LICENSE (accessed Aug 2026). ↩↩
The 3D-vision literature documents a domain gap between natural photographs and untextured CAD renders: e.g. BlendCLIP notes CAD renders "fall short of providing the visual diversity and realism necessary for robust multimodal alignment," with CAD models "often featuring simplistic or entirely absent textures" (https://arxiv.org/html/2510.18244); OpenDlign motivates realistic depth-aligned renders for the same reason (https://arxiv.org/html/2404.16538v2) (both accessed Aug 2026). These support the direction qualitatively; no clean "grey vs textured, X% drop" benchmark was found. ↩↩
FAISS (Meta, MIT, https://github.com/facebookresearch/faiss/blob/main/LICENSE), Qdrant (Apache-2.0, https://github.com/qdrant/qdrant), Chroma (Apache-2.0, https://github.com/chroma-core/chroma); all run fully self-hosted with no external calls (accessed Aug 2026). ↩
UV-Net (Autodesk AI Lab, CVPR 2021), code MIT; the repo ships training recipes but no general-purpose pretrained weights, only narrow demo datasets (synthetic fonts for classification, machining-feature sets for segmentation), none moulding-ready. Paper https://arxiv.org/abs/2006.10211; repo https://github.com/AutodeskAILab/UV-Net (accessed Aug 2026). ↩
UVStyle-Net (Autodesk AI Lab, ICCV 2021) performs unsupervised style-similarity search over B-rep CAD, built on a UV-Net encoder, but its repository is licensed CC BY-NC-SA 4.0 (non-commercial), unlike UV-Net's MIT. Paper https://arxiv.org/abs/2105.02961; repo https://github.com/AutodeskAILab/UVStyle-Net (accessed Aug 2026). ↩
OpenShape (code MIT, https://github.com/Colin97/OpenShape_code), ULIP/ULIP-2 (Salesforce, code BSD-3, https://github.com/salesforce/ULIP) and Uni3D (BAAI, code MIT, https://github.com/baaivision/Uni3D) release permissive code, but their pretrained weights inherit the terms of their training data (Objaverse, ShapeNet), none of which grants a clean commercial licence for the weights (accessed Aug 2026). ↩↩
Kim et al., "A Large-scale Annotated Mechanical Components Benchmark for Classification and Retrieval Tasks with Deep Neural Networks," ECCV 2020. Best reported retrieval on the benchmark is around 89–91% precision (P@N), e.g. PointCNN P@N 0.892 on Dataset A, DLAN P@N 0.912 on Dataset B. https://link.springer.com/chapter/10.1007/978-3-030-58523-5_11 (accessed Aug 2026). ↩