Agenten stärken
Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
npx -y @ifc-lite/[email protected]Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.
claude mcp add ifc-lite-mcp -- npx -y @ifc-lite/mcp@0.29.0In einem Terminal ausführen.
{ "mcpServers": { "ifc-lite-mcp": { "command": "npx", "args": [ "-y", "@ifc-lite/[email protected]" ] } }}claude_desktop_config.json
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenVom Herausgeber
Parse, view, query, edit, validate, and export IFC files, entirely client-side. A Rust core compiled to WASM does the parsing and geometry, a WebGPU renderer puts it on screen, and modular npm packages let you pick the pieces you need. Geometry runs on an exact-arithmetic CSG kernel, verified element-by-element against IfcOpenShell across the public benchmark corpus.
Works with IFC2X3, and . Live demo at and more info at .
Model Context Protocol server for ifc-lite — agent-native BIM via MCP (stdio + Streamable HTTP)
For data automation, start with the headless SDK or CLI:
npm install @ifc-lite/sdk
import { readFile } from 'node:fs/promises';
import { openModel } from '@ifc-lite/sdk/headless';
const model = await openModel(await readFile('model.ifc'));
try {
if (model.report.completeness !== 'complete') throw new Error('Incomplete or unknown record coverage');
console.log(model.bim.query().byType('IfcDoor').count());
} finally {
model.close();
}
Developer workflows provides a reference model, runnable data/IDS/edit/export/geometry/service recipes, and expected results. For the terminal, run npx @ifc-lite/cli info model.ifc --json.
To scaffold a rendering integration:
npx create-ifc-lite my-viewer --template react
cd my-viewer && npm install && npm run dev
That gets you a working WebGPU IFC viewer with drag-and-drop loading and orbit/pan/zoom. Other templates: basic, threejs, babylonjs, server, server-native.
To add IFClite to an existing project:
npm install @ifc-lite/parser @ifc-lite/geometry @ifc-lite/renderer
Prefer the terminal? The whole toolkit is also a CLI:
npm install -g @ifc-lite/cli
ifc-lite info model.ifc
import { IfcParser } from '@ifc-lite/parser';
const parser = new IfcParser();
const buffer = await fetch('model.ifc').then(r => r.arrayBuffer());
const t0 = performance.now();
const store = await parser.parseColumnar(buffer, {
onProgress: ({ phase, percent }) => console.log(`${phase}: ${percent}%`),
});
console.log(`${store.entityCount} entities, schema ${store.schemaVersion}`);
console.log(`Parsed in ${(performance.now() - t0).toFixed(0)}ms`);
import { IfcParser } from '@ifc-lite/parser';
import { GeometryProcessor } from '@ifc-lite/geometry';
import { Renderer } from '@ifc-lite/renderer';
const parser = new IfcParser();
const geometry = new GeometryProcessor();
const renderer = new Renderer(canvas);
await Promise.all([geometry.init(), renderer.init()]);
const arrayBuffer = await file.arrayBuffer();
const store = await parser.parseColumnar(arrayBuffer);
const meshes = [];
for await (const event of geometry.processAdaptive(new Uint8Array(arrayBuffer))) {
if (event.type === 'batch') meshes.push(...event.meshes);
}
renderer.loadGeometry(meshes);
renderer.requestRender();
// Pick an entity at (x, y) in canvas pixels
const hit = await renderer.pick(120, 240);
if (hit) console.log(`Picked expressId ${hit.expressId}`);
For Three.js or Babylon.js, parse and extract geometry the same way and feed meshes to your engine. See Three.js integration and Babylon.js integration.
import { IfcQuery } from '@ifc-lite/query';
const query = new IfcQuery(store);
// All external load-bearing walls
const walls = query
.ofType('IfcWall', 'IfcWallStandardCase')
.whereProperty('Pset_WallCommon', 'IsExternal', '=', true)
.whereProperty('Pset_WallCommon', 'LoadBearing', '=', true)
.execute();
console.log(`${walls.length} external load-bearing walls`);
for (const wall of walls) {
console.log(wall.name, wall.globalId);
}
For more complex queries, use SQL via DuckDB-WASM:
const result = await query.sql(`
SELECT type, COUNT(*) AS n FROM entities GROUP BY type ORDER BY n DESC LIMIT 10
`);
console.table(result.rows);
import { parseIDS, validateIDS, createTranslationService } from '@ifc-lite/ids';
import { createDataAccessor } from '@ifc-lite/ids/bridge';
const idsSpec = parseIDS(idsXmlContent);
const accessor = createDataAccessor(store);
const modelInfo = {
modelId: 'my-model',
schemaVersion: store.schemaVersion,
entityCount: store.entityCount,
};
const translator = createTranslationService('en');
const report = await validateIDS(idsSpec, accessor, modelInfo, { translator });
for (const spec of report.specificationResults) {
console.log(`${spec.specification.name}: ${spec.passRate}% passed`);
}
import { MutablePropertyView } from '@ifc-lite/mutations';
import { PropertyValueType } from '@ifc-lite/data';
const view = new MutablePropertyView(store.properties, 'my-model');
view.setProperty(
wallExpressId,
'Pset_WallCommon',
'FireRating',
'REI 120',
PropertyValueType.Label,
);
console.log(view.getMutations()); // change history for undo / export
import { exportToStep, ParquetExporter, Ifc5Exporter } from '@ifc-lite/export';
import { GeometryProcessor } from '@ifc-lite/geometry';
// Assumes the earlier parse/geometry steps: `store` (parsed IfcDataStore),
// `bytes` (raw IFC Uint8Array), `meshes` + `geometryResult` (from geometry).
// IFC STEP, applies any pending mutations
const stepText = exportToStep(store, { schema: 'IFC4', applyMutations: true });
// glTF / GLB, CSV and JSON-LD are assembled in Rust (ifc-lite-export)
// via the GeometryProcessor
const gp = new GeometryProcessor();
await gp.init();
const glb = gp.exportGlbFromMeshes(meshes); // Uint8Array (no re-mesh)
const csv = gp.exportCsv(bytes, 'entities', ',', /* includeProperties */ true);
const jsonld = gp.exportJsonld(bytes);
// Parquet: columnar, queryable from DuckDB / Polars
const parquet = await new ParquetExporter(store).exportTable('entities');
// IFC5 / IFCX: JSON + USD geometry
const ifcx = new Ifc5Exporter(store, geometryResult).export({ includeGeometry: true });
The ifc-lite CLI covers the full toolkit: inspect, query, schedule, validate, export, create, diff, clash-check, merge, convert, and script IFC models without writing a line of app code.
ifc-lite info model.ifc # schema, entities, storeys
ifc-lite query model.ifc --type IfcWall --json # entities with properties
ifc-lite schedule model.ifc --preset door # door schedule, csv/json/md/html
ifc-lite ids model.ifc requirements.ids # IDS validation
ifc-lite clash model.ifc --matrix --bcf clashes.bcfzip # clash detection to BCF
ifc-lite diff model-v1.ifc model-v2.ifc # model comparison
ifc-lite merge arch.ifc struct.ifc mep.ifc --out fed.ifc # federation
ifc-lite convert model.ifc --schema IFC4 --out out.ifc # schema conversion
ifc-lite view model.ifc # 3D viewer + REST API
ifc-lite eval model.ifc "bim.query().byType('IfcWall').count()"
Building AI tooling? ifc-lite mcp model.ifc starts a Model Context Protocol server (stdio or HTTP) so agents can query and edit BIM data directly, and ifc-lite ask model.ifc "how many walls?" answers natural-language questions.
Not sure? Start with the browser setup. You can add a server or switch engines later.
Full list: API Reference (npm packages, Rust crates, and the ifclite-geom Python wheel).
web-ifc on most of the benchmark corpus; in the browser the viewer streams geometry across workers so the first triangles render long before the file finishes processing.See benchmarks for full numbers across model sizes and hardware.
Ready-to-run projects in examples/:
The WASM bundle is built from rust/ on every fresh build, so a Rust
toolchain is required. rust-toolchain.toml pins the nightly channel
and the wasm32-unknown-unknown target. rustup show (or the
contributing setup guide) installs everything needed.
# 1. Rust toolchain (one-time)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo install wasm-pack # or: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
# 2. Clone and build
git clone https://github.com/LTplus-AG/ifc-lite.git
cd ifc-lite
pnpm install && pnpm build && pnpm dev # opens viewer at localhost:3000
If you need IFC fixtures for tests, benchmarks, or stress tests, fetch them with:
pnpm fixtures # download every fixture (idempotent, hash-verified)
pnpm fixtures:check # CI-friendly: exit 1 if anything is missing or stale
The fixtures are stored on a GitHub Release and catalogued in
tests/models/manifest.json. See
tests/models/README.md for the full design and
maintainer workflow.
See the Contributing Guide and Release Process.
MPL-2.0 - use, modify, redistribute. Source files modified under MPL must remain MPL.
Model Context Protocol server for ifc-lite — agent-native BIM via MCP (stdio + Streamable HTTP)
{ "mcpServers": { "ifc-lite-mcp": { "command": "npx", "args": [ "-y", "@ifc-lite/[email protected]" ] } }}Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
@ifc Lite/mcp läuft lokal über stdio.
Zuletzt geprüft: 2026-11-15. Model Context Protocol server for ifc-lite — agent-native BIM via MCP (stdio + Streamable HTTP)