Office & documents Shipped
Everyday documents and the structural information inside them — paragraphs, headings, tables, embedded images, captions.
- DOC
- DOCX
- PPT
- PPTX
- ODT
- ODP
- RTF
- TXT
- MD
- HTML
- EML
- MBOX
- MSG
- IPYNB
- ICS
- VCard
- SRT
- VTT
- INI
- TOML
- conf
- ReqIF
System & data integrations
kiLM ingests the file formats, applications, protocols, and cloud services your organization already runs on — and every connector is module-gated, so the air-gap and intake-only profiles stay safe. The lists below are honest about what ships today versus what is opt-in, and what is still on the roadmap.
Every uploaded or pulled file is routed to a purpose-built worker that knows how to extract text, structure, geometry, or signal from that format. Code, executables, and untrusted archives are quarantined by default — opt in deliberately.
Everyday documents and the structural information inside them — paragraphs, headings, tables, embedded images, captions.
Tabular and semi-structured data with column-aware extraction — supports schema inference and per-cell sensitivity classification. Big-data columnar formats land natively; database dumps and SQLite files are parsed by the same path.
Multi-sheet workbooks with formula preservation, merged-cell handling, and per-sheet schema inference. Macros are sandboxed (XLSM gets the same treatment as XLSX — never executed).
Native B-Rep, mesh, BIM, USD, and FEM formats with geometry-aware extraction. Tier 1 formats use built-in kernels; Tier 2 formats route to an OpenCascade companion worker.
Functional Mock-up Units (FMI standard) — model metadata, parameter ranges, and variable definitions extracted into searchable records so engineers can find the model they need without running it.
Neutral interchange exports from PLM, ALM, QMS/LIMS, CAE, MES, and the core engineering tools (MATLAB, Modelica/Dymola, Revit) — imported air-gapped with no vendor SDK and no live credentials. PLMXML/STEP-AP242 BOMs, ReqIF requirement-to-test traceability, AnIML lab results, VTK/HDF5 simulation results, B2MML/ISA-95 as-built genealogy, MATLAB .mat datasets, and Modelica .mo system models become governed, queryable records plus graph relationships. Every import is bound to a versioned extraction contract. Default off; operator opt-in per source. Native vendor formats (Abaqus .odb, MATLAB .m/.slx, Revit .rvt) are bring-your-own-license.
Free, air-gapped readers for quality, test-management, and business-process interchange: dimensional-inspection results (QIF / ISO 23952, Q-DAS / AQDEF — Hexagon, Zeiss), test cases with requirement coverage (TestRail XML, Xray Cucumber / Test JSON), and process / decision models (BPMN 2.0, DMN, Visio). Each becomes governed, queryable records plus graph relationships — which tests cover a requirement, which characteristics failed inspection, and the next step in a process. No vendor API and no live credentials; default off, operator opt-in per source.
Vector geospatial with attribute extraction; coordinate reference systems preserved through the pipeline.
CAN bus databases, calibration files, AUTOSAR descriptions, and ODX diagnostics — extracted into searchable structured records.
Bioinformatics, chemistry, structural biology, and high-throughput experimental data.
Standards-based clinical ingestion for the healthcare domain — HL7 FHIR R4/R5 resources and Bundles (Patient, Encounter, Observation, Condition, Procedure, MedicationRequest, DiagnosticReport) and DICOM imaging header metadata (Patient → Study → Series → Instance). PHI is Presidio-scrubbed at parse time and DICOM PatientID is hashed; the DICOM reader reads header metadata only and never the pixel data. No vendor SDK, no live credentials, fully air-gappable; default off, operator opt-in per source.
Financial reporting and software-supply-chain / security compliance as a governed graph: XBRL / iXBRL financial reports (context / unit / fact), NIST OSCAL control catalogs, SSPs and assessment results, CycloneDX and SPDX software bills-of-materials (component dependency graph), and OASIS CSAF security advisories (advisory → vulnerability → affected product). The SBOM dependency graph pairs with CSAF advisories. No vendor SDK, no live credentials, fully air-gappable; default off, operator opt-in per source.
Aerospace / defense / MRO service manuals as a navigable structure: S1000D data and publication modules and DITA topics and maps become Module / Topic records with the cross-references between them (a publication module references a data module, a map references a topic). The structure and identifiers are graphed; the prose body still flows through normal text ingestion and retrieval. No vendor SDK, no live credentials, fully air-gappable; default off, operator opt-in per source.
Images become first-class search citizens — OCR text, vision captions, and visual embeddings for cross-modal retrieval.
Audio and video formats are routed to a speech worker for transcription. The speech worker is shipped at a placeholder level today — formats are recognized and queued, but production-grade transcription quality should be validated against your specific use case. Native transcription engine selection is on the roadmap.
Multi-file archives are extracted into staging, scanned for nested code or executables, then re-routed to the appropriate worker per child file. The archive gate ships OFF because expansion costs are unbounded without explicit opt-in.
Source code, installers, executables, and DLLs land in quarantine instead of the knowledge corpus. Time-series / sensor-telemetry tables in CSV or Excel are also quarantined — kiLM does not handle time-series data today; only the non-time-series content of a mixed file is ingested. An admin can review or reroute; nothing is silently extracted.
kiLM is self-hosted, but it pulls governed data from the applications your teams already use. Each connector is module-gated, so adopting one is an explicit admin decision rather than a default-on egress.
Per-folder pull via Microsoft Graph. Delta sync, attachment expansion, and lake-watcher hand-off into the standard ingestion pipeline.
Inbound via Microsoft Graph or Exchange Web Services. Outbound via SMTP. Quote-strip and PII-aware sanitization on the way in.
Folder-scoped pull, delta sync, per-file sensitivity classification on ingest.
Personal and business OneDrive via the cloud-storage puller shared with the other providers below.
Folder pull with Box Enterprise features (legal hold, retention policy) preserved as ingest metadata.
Team folder pull with delta sync; same per-connector air-gap toggle as the other cloud-storage providers.
Federated query across Snowflake, BigQuery, and Databricks via declarative connections. Per-table annotation, fan-out into search + graph stores.
Read-only connections to the relational databases your operational systems already use. Postgres / Redshift / CockroachDB land natively; MySQL, Microsoft SQL Server, and Oracle federate via the generic JDBC / ODBC path. Per-table annotation, per-column sensitivity classification, change-data-capture optional via the slice-0139d REST contract.
kiLM acts as both an MCP server (Claude Desktop, Cursor, Cline, n8n, any MCP-compliant client) and a sanitizing MCP client (pulls from upstream MCP servers with control-token stripping + PII scan).
Manifest emission for Microsoft 365 Copilot: declarative agents, API plugins, trimmed OpenAPI specs, source-attribution metadata. Customers download the bundle and register it with their tenant.
HMAC-signed webhook receiver for human-in-the-loop label review (VLM captions, OCR corrections). Applied labels write back into per-domain chunks.
OIDC federation into the bundled Keycloak realm: Azure AD, Okta, Google Identity, plus any generic OIDC issuer. Keycloak itself ships always-on.
Per-customer MCP usage rollups exported as CSV by default; Stripe push is an opt-in second gate.
kiLM ingests the standard interchange formats that PLM, ERP, ALM, MBSE, and CAE systems already export. That covers a meaningful share of day-to-day "what changed in the BOM / requirements / model" questions without needing a vendor-specific connector. Where a native REST connector to the system of record makes more sense than file exports, it's on the roadmap below — we list every vendor by name so a procurement evaluator can confirm fit without a sales call.
Geometry interchange (STEP / IGES / BREP / IFC / glTF / STL / OBJ / 3MF / USD) ingests via the cad-worker. PLMXML and 3DXML are routed and metadata-extracted. Vendor-native NX (.prt / .asm), CATIA (.catpart / .catproduct), Creo (.prt), SOLIDWORKS (.sldprt / .sldasm), and AutoCAD (.dwg) files extract natively when the customer brings their own license — see the "BYOL CAD sidecar" card below. Solid Edge (.par / .psm) is routed today and gains the same native-extraction BYOL adapter per-customer-demand.
OMG Requirements Interchange Format (.reqif / .reqifz) ingests via the office-document-worker's ReqIF branch and lands as structured Requirement records. That covers DOORS Next, Polarion, codebeamer, Jama Connect, and any other ALM tool that publishes its requirements set as ReqIF — which is most of them.
Functional Mock-up Units (.fmu, FMI 2.0 / 3.0) ingest via the FMPy-based fmu-worker. Nastran bulk-data decks (.bdf / .dat) and meshes ingest via the scientific-worker (pyNastran + meshio). Vendor-native binary solver outputs (Abaqus .odb, Ansys result files, Simulink .slx) are routed and quarantined for vendor-side conversion before downstream extraction.
Bill-of-material drops (CSV / XLSX / TSV / JSON), routing sheets, work-order manifests, and vendor master extracts ingest via the structured-worker and land into the operational_data domain with per-column sensitivity classification. SAP, Oracle EBS / Fusion, Microsoft Dynamics, Infor, and IFS all publish in these formats by default for downstream BI — so the export path covers the common case without a vendor connector.
OMG XMI (.xmi / .xml) exports from MBSE tools ingest as structured-XML; SysML v2 KerML text format is parsed by the same pipeline. Diagrams embedded as images are routed through the VLM worker for caption extraction. Tested with Cameo Systems Modeler and No Magic / 3DS CATIA Magic — your model-library round-trip should be validated against your specific profile.
For enterprise systems that publish a read-only SQL view of their tables — Teamcenter on top of Oracle, ARAS Innovator on top of Microsoft SQL Server, Windchill on top of Oracle, SAP S/4HANA via the embedded Postgres / HANA bridge, IFS on top of Oracle — kiLM connects through the warehouse-puller (Snowflake / BigQuery / Databricks native, Postgres / MSSQL / Oracle via JDBC) and federates the queries into the search + graph stores. Per-table annotation locks the sensitivity tier per column.
The native PLM connectors — Aras, Teamcenter, 3DEXPERIENCE, and Windchill — and the BYOL CAD sidecars now ship; each is marked Shipped below. The remaining connectors (SAP, Oracle, Polarion, DOORS, Cameo, Ansys) are on the public roadmap — we list them so a procurement evaluator can confirm fit before signing, and so customers know which pulls today rely on the file-export path above versus a future REST / OData / SOAP connector against the system of record. Sequencing is demand-driven: tell us which three matter for your stack and we'll prioritise.
Native pull via Teamcenter Active Workspace JSON-REST (TC Server API): parts, items, BOMs, and change notices — polled on a configurable tick and staged into the manufacturing domain with canonical BOM extraction. BYOL — Teamcenter is customer-owned and customer-licensed; kiLM bundles no Siemens SDK (HTTP/JSON only). Covers both on-prem / self-hosted Active Workspace (cookie session, intranet, air-gap OK) and Teamcenter X (Xcelerator SaaS) via OAuth2 — cloud calls pass the egress policy + SSRF guard and are vetoed in air-gapped installs. Default off; enable the gate after configuring the gateway URL + service account.
Native pull via the 3DSpace REST web services: EngItems, documents, and BOM structure — staged into the manufacturing domain with canonical BOM extraction. BYOL — 3DEXPERIENCE is customer-owned and customer-licensed; kiLM bundles no Dassault SDK (HTTP/JSON only). Covers on-prem / private-cloud 3DSpace behind 3DPassport (cookie login, intranet, air-gap OK) and 3DEXPERIENCE-on-Cloud (SaaS) via 3DPassport OAuth2 — cloud calls are egress-policy gated and air-gap-vetoed. Default off; enable the gate after configuring the 3DSpace URL + service account.
Native pull via the Aras IOM OData REST API with OAuth2 password-grant auth: Items, ItemTypes, Part BOMs, ECNs, Document records — polled on a configurable tick (default every 6 hours) and staged into the manufacturing domain. Aras Community Edition is free, so no per-seat license token is consumed for read-only ingestion; the unnamed service-account pattern also keeps Enterprise Edition deployments off the named-user count. Configure auth URL + service account + tick interval from the customer-side Admin UI — no file editing required. Polled changes only (no event hooks yet). Native Teamcenter, Windchill, and 3DEXPERIENCE PLM connectors now ship on the same pattern (see below).
Native pull via Windchill REST Services (OData domain APIs): parts, documents, and BOM structure — staged into the manufacturing domain with canonical BOM extraction. BYOL — Windchill is customer-owned and customer-licensed; kiLM bundles no PTC SDK or Info*Engine task (HTTP/JSON, GET-based reads). Covers on-prem / private-cloud Windchill (HTTP Basic, intranet, air-gap OK) and Windchill+ / PTC Atlas (SaaS) via OAuth2 — cloud calls are egress-policy gated and air-gap-vetoed. Default off; enable the gate after configuring the Windchill REST URL + service account.
Native pull via SAP OData services (S/4HANA Cloud + Business Suite gateways) for material masters, BOMs, purchase orders, and work orders. Today the export-driven CSV / XLSX / IDoc-XML path covers most BI use cases; the native connector adds live document-flow walks and event-driven CDC.
Native pull via Oracle Fusion REST / BICC extracts + EBS Integrated SOA Gateway. Today the warehouse-puller (Oracle via JDBC) handles read-only inventory; the native connector adds event subscriptions for procure-to-pay and order-to-cash.
Native pull via the Polarion REST API: work items, document trees, traceability links, baselines. Today the ReqIF export path (Shipped above) handles the requirements set; the native connector adds traceability graph walks and baseline snapshots.
Native pull via OSLC-RM (DOORS Next) and DXL bridge (classic DOORS). Today the ReqIF export path handles requirements content; the native connector adds OSLC link traversal across DOORS Next configurations.
Native pull via the Cameo Collaborator REST API + Teamwork Cloud OSLC. Today the XMI export path covers static model snapshots; the native connector adds project-on-server diffs and reviewer-comment threads.
Native pull from Ansys Minerva simulation-process-and-data management and Granta materials intelligence. Today FMU / Nastran exports cover specific deliverables; the native connector adds simulation lineage + materials selection records.
The customer brings their own CAD vendor license + install; the platform mounts
the install as a sidecar and invokes the vendor's official headless tool
(NX ugraf -batch with an NX Open Python journal; CATIA
cnext.exe -batch -macro with a CATScript; Creo
parametric.exe -g:no_graphics with a J-Link app; SOLIDWORKS
SLDWORKS.exe /m with a VBA macro; AutoCAD
accoreconsole.exe with an AutoLISP extractor) to extract the model
natively — not converted to STEP. Each part emits a JSON sidecar with the
feature tree (bounded), parameters, materials with density & mechanical
properties, PMI / annotations, assembly & BOM structure, custom attributes, and
geometric summary. The platform never ships a CAD kernel, vendor SDK, or
license. Single-tenant by design. Per-vendor license-token concurrency
cap (default 1, configurable). Customer-side admin configures everything from a
central "BYOL Tool Configuration" interface — install dir, license server, tier
— no .env editing needed. STEP / Parasolid / 3DXML / IGES export remain
available as opt-in workflows when downstream geometry rendering is genuinely
needed. Shipped today: NX (Siemens), CATIA V5/V6 (Dassault), Creo (PTC),
SOLIDWORKS (Dassault), and AutoCAD (Autodesk). SOLIDWORKS and AutoCAD run
on a Windows host. Solid Edge ships on the same rich-extraction pattern
per-customer-demand.
Many of the tools engineering, quality, and operations teams depend on — CAD kernels, solver runtimes, simulation engines — are commercially licensed. kiLM never bundles, embeds, or resells a vendor's licensed software. Where faithful native extraction needs the vendor's own engine, kiLM uses a bring-your-own-license (BYOL) model: you supply the license and install you already own, and kiLM drives it in place. Open, standards-based interchange formats stay free and fully air-gapped. And because every connector follows the same module-gated pattern, new integrations can be added to fit your specific system landscape and needs.
For vendor-native formats that only the vendor's own tool can read faithfully — NX,
CATIA, Abaqus .odb, MATLAB / Simulink, Revit, Amesim, Dymola — the
customer brings their own license and install. kiLM mounts that install as an isolated
sidecar and invokes the vendor's official headless tool to extract natively,
rather than guessing at a proprietary binary. We always ask before introducing any
paid dependency; nothing licensed is switched on without your explicit decision.
Open, standards-based interchange — STEP, IGES, PLMXML, STEP-AP242, ReqIF, QIF, Q-DAS, STDF, B2MML / ISA-95, VTK, HDF5, FMU, AnIML and the rest — is read by kiLM's own parsers with no vendor SDK, no license token, and no internet. These ship with by-design air-gap support and are off until an operator opts in. Only the vendor-native binary path needs BYOL, and it is always the customer's existing license.
kiLM never ships a CAD kernel or solver and never holds a vendor license. BYOL adapters are single-tenant by design, run behind a license-locked gate that stays OFF until configured, and honor a per-vendor concurrency cap so your seat count is respected. The customer-side admin sets install path, license server, and tier from a central "BYOL Tool Configuration" screen — no config-file editing, and the license never leaves your environment.
When you request a quote you can opt into named packages. Seven neutral-interchange packs are included at no extra licence fee and stay fully air-gapped: Engineering & manufacturing interchange (PLM / ALM / QMS / CAE / MES / metrology / STDF / PLCopen / AutomationML / MBSE, plus free MATLAB / Modelica / Simscape readers), Enterprise & business interchange (SAP IDoc & Ariba cXML, EDI X12/EDIFACT + logistics, OAGIS BOD, IBM Maximo MIF, ServiceNow, Workday), Process & decision modeling (BPMN, DMN, Visio), Healthcare & clinical records (HL7 FHIR, DICOM), Finance, compliance & security (XBRL, OSCAL, CycloneDX / SPDX SBOM, CSAF), Industry 4.0 & digital twin (AAS, OPC-UA NodeSet2, ASAM MDF4), and Technical documentation & PCB fab (S1000D / DITA, Gerber / ODB++). Each turns on only the connector modules you select. Engineering-tool BYOL adapters are available as separate line items — MATLAB Engine, Autodesk Revit / APS, Dymola, Simcenter Amesim, and Abaqus .odb — where you bring your own vendor licence and kiLM drives it in place.
kiLM speaks the standard protocols your enterprise stack already uses, so the integration surface is auditable rather than bespoke. Every protocol below is covered by the same air-gap and intake-only egress gates.
Model Context Protocol over HTTP+SSE and stdio. Both server and sanitizing client modes. Per-client bearer-token + ACL + audit on every invocation.
FastAPI backend with a published OpenAPI specification. Chat and long-running jobs use
SSE for streaming. Versioned namespace under /api/v1.
Outbound webhooks via an at-least-once outbox pattern with HMAC-SHA256 signing, exponential backoff, and a dead-letter queue. Subscribers configure event filters per endpoint.
All authentication routes through Keycloak. Token exchange, refresh, PKCE, service-account credentials, and per-tenant realms supported out of the box.
SMTP for outbound delivery; inbound mail comes via Microsoft Graph or Exchange Web Services. IMAP and POP3 ingestion are intentionally not supported.
MinIO is bundled. Any S3-compatible backend works for the data lake — AWS S3, Backblaze B2, Wasabi, or your own MinIO cluster.
Primary warehouse + per-domain partitions. Postgres-compatible warehouses (Redshift, CockroachDB) federate via the generic JDBC path.
Event-bus subscription via aiokafka. Topic-scoped subscriptions, consumer-group offsets, and replay markers — Kafka is the first adapter; others are planned.
REST endpoint that accepts change-data-capture delete events for governed erasure — deterministic idempotency by event signature, still routed through dual approval. Full CDC source connectors (Debezium and friends) are planned.
All long-running work is a Temporal workflow with deterministic replay, explicit retry policies, and per-activity audit. Self-hosted, no external Temporal Cloud dependency.
kiLM ships with a local LLM runtime (Ollama) and a registry of community models — both verified by the kiLM team and operator-verifiable placeholders. The hardware-aware router picks the most-capable model that fits your install's GPU envelope, so no model assumption is hard-coded.
CPU-only: Phi-3 mini, Llama 3.1 8B. Workstation GPU: Mixtral 8x7B (q4). Datacenter GPU: Qwen 2.5 72B, DeepSeek-Coder 67B, Llama 4 Scout (q4, ~109B total / 17B active). Vision: llava. All released under permissive open licenses; kiLM has validated each on the corresponding hardware tier.
The registry includes 5 placeholder seeds for newer community frontier models. Each
is marked verify_by_operator=TRUE — the customer-side admin must confirm
the model exists locally + passes a smoke test before the router will route to it.
This keeps the registry forward-looking without making promises kiLM hasn't
independently validated yet.
The runtime LLM router classifies your install into one of five tiers
(cpu_only, gpu_consumer, gpu_workstation,
gpu_datacenter, gpu_multi) and picks the most-capable
model that fits. nvidia-smi auto-probe runs hourly; admin can override via
/admin/install-hardware. Fallbacks are recorded with reason so you can
audit why a particular turn picked a smaller model.
Fine-tune any registry model that's marked is_fine_tune_supported=true
via the bundled Unsloth QLoRA worker. Hardware-aware pre-flight refuses jobs that
would OOM on the available GPU envelope, so you never start a training run that can't
finish. Outputs are first-class registry rows the router can pick from immediately.
When your governance posture allows cloud egress, kiLM connects to the hyperscaler and SaaS services your data already lives in. When it doesn't, every cloud connector here can be disabled by flipping a single gate — the air-gap install profile turns them all off at runtime.
First-class data lake target. Bring your own S3 endpoint, or use the bundled MinIO for fully-isolated deployments. Backblaze B2 and Wasabi tested.
Google Drive for content pull; Google Identity for federated authentication. Both independently gated.
SharePoint Online, OneDrive, Exchange (Graph + EWS), and Azure AD federation. Manifest export for Microsoft 365 Copilot.
Box Business / Enterprise pull with metadata templates preserved through ingest.
Team folder pull. Same cloud-storage egress gate as Drive, OneDrive, Box.
Snowflake, BigQuery, Databricks. Each warehouse is a separately-gated federation; no single switch unlocks the lot.
Azure AD, Okta, Google Identity — kiLM uses the standard OIDC discovery flow through Keycloak.
Usage-based billing export for MCP-consumer accounts. CSV by default; Stripe push is opt-in.
Beyond the file formats and the SaaS connectors, several low-level surfaces let your platform call kiLM, push files in, or auto-ingest from buckets — without writing a custom HTTP client.
The kilm package ships with every release. Typed wrappers for admin,
search, chat, ingest, inference, and webhook endpoints — including ingest helpers
like trigger() and upload_and_trigger(). Bring-your-own
bearer token; everything routes through the same OpenAPI spec.
POST /api/v1/admin/ingest kicks ingestion for a single object already
staged in MinIO. POST /admin/ingest/batch accepts up to a thousand
object references and queues each one through the standard routing path. Useful for
pipelines that hand off batches at the end of an upstream run.
The Upload page mints a short-lived signed PUT URL so the browser uploads directly to MinIO, then POSTs an ingest trigger. Scripts can request the same URL via the admin API. Size limits and magic-byte sniff enforced server-side.
Standard multipart for airgap release-bundle upload, support-request and enhancement attachments, and admin import flows. Streaming size cap + content-type allowlist on every endpoint.
External pipelines can drop objects straight into a watched MinIO bucket; the lake-watcher worker receives the bucket-notification webhook and kicks the standard ingestion workflow. Per-bucket auto-ingest toggle.
Server-Sent Events stream from /chat/sessions/{id}/messages — tokens,
citations, tool decisions, conflict signals, task-dispatcher events. The MCP server
uses the same transport.
kilm_mcp_stdio.py exposes kiLM's MCP tools to local clients like Claude
Desktop and Cursor over standard input/output, without opening an HTTP port on the
workstation.
When the archive gate is ON, uploaded ZIP / TAR / 7Z / etc. are unpacked into a staging area, scanned for nested code or executables, then each member is re-injected into the standard ingestion router as if it had been uploaded directly. Expansion limits and per-member quotas keep runaway archives bounded.
If a worker's extractor fails — wrong extension, mistyped MIME, vendor PDF that's really an image — kiLM sniffs the file's magic bytes and reroutes it to the worker that should have handled it in the first place. The reroute is audited; reconciliation flags persistent misrouting patterns so admins can fix the upstream source.
Files dropped into the chat composer become session-scoped knowledge — visible to that conversation only, with their own retention policy. Not the same as permanent corpus ingestion; use the save-to-corpus task verb to promote a useful attachment.
The structured-worker path normalizes records, tables, and spreadsheets into searchable row-level entries with schema-aware extraction. Persistent upsert into per-domain tables is still evolving — current ingestion is read-then-index; mutation semantics follow on a future slice.
When kiLM emits — events, reports, telemetry, evidence bundles — every channel is observable and most are gated. The intake-only profile blocks all outbound paths; the air-gap profile additionally blocks the vendor heartbeat.
Event notifications for findings, proposals, model promotions, config changes, ingest completions, and more. At-least-once outbox + HMAC-SHA256 signing + per-endpoint event filters + dead-letter queue.
Outbound email for emailed reports, ask-by-email replies, system notifications. Honors your SMTP provider's STARTTLS upgrade and pinned TLS modes; auth via username/password or service-account credentials.
Counts-only HTTPS POST to the vendor portal for license + capacity telemetry. No business data, no chat content, no document metadata. Records-then-skips under air-gap; queueable for later import.
The bundled Prometheus + Alertmanager stack routes operational alerts to any HTTP receiver — Slack, PagerDuty, Opsgenie, Microsoft Teams, or your own incident webhook. SLO breaches, capacity thresholds, reconciliation findings all surface here.
Short-lived, signed download links for generated reports, request attachments, support bundles, and release artifacts. URLs include per-resource access checks; downloads are audit-logged.
Native renderers for the formats finance, ops, and ML teams actually consume. Reports, billing rollups, feedback exports, training datasets — all formats below.
Deterministic diagnostic snapshot — config, logs, schema, gate state, recent findings — packaged as a GPG-signed tar.gz. Designed for offline transfer to vendor support; never auto-uploaded.
Versioned, signature-verified release artifact for offline update of airgap installs. Each bundle includes images, migrations, schema, OpenAPI, SBOMs, and the operator documentation that goes into the system-manuals corpus.
Authentication flows through the bundled Keycloak realm. Federation, machine-to-machine, user-delegated, and signed-payload integrations are all first-class.
Pre-built presets for Microsoft Entra (Azure AD), Okta, Google Workspace, and any generic OIDC issuer with discovery. Each provider is independently gated.
Generic SAML 2.0 federation via the bundled Keycloak — metadata URL + signing keys, ADFS / OneLogin / Auth0 / Ping / Shibboleth all federate via this path.
User federation against Active Directory, OpenLDAP, FreeIPA, or any LDAPv3 server. Read-only or read-write attribute mapping. Optional Kerberos pass-through.
Machine-to-machine auth for the Python SDK, MCP clients, the Copilot connector, and backend service principals. Per-client scopes, per-realm credential rotation.
User-delegated grants for the webapp, the MCP browser flow, and selected cloud-storage and email integrations that need consented per-user access (Microsoft Graph, Google Drive).
JWT bearer tokens issued by Keycloak authenticate every REST, MCP, SDK, and Copilot call. Standard expiry + refresh; service-account tokens optional for long-running integrations.
Used wherever a bearer token isn't appropriate: MinIO bucket events, outbound webhooks, Label Studio review callbacks, vendor heartbeat. Subscribers verify with the published signing key.
"Shipped" means the connector is in the codebase, has a test, and ships in every release. "Gated OFF" means the connector code is shipped but disabled by default; an admin opt-in flips the gate. "Planned" means it's in the public roadmap. We mark each item honestly so a procurement evaluator can confirm fit without a sales call.
A few specifics worth calling out so a procurement evaluator knows what is and isn't there. IMAP and POP3 inbound mail are intentionally not supported (Microsoft Graph or EWS only). Full CDC source connectors (Debezium, Kafka Connect transformers) are on the roadmap — today the CDC surface is the REST endpoint for delete-event ingestion. The Kafka adapter is the only event-bus adapter shipped; NATS, Pub/Sub, and Amazon SQS are planned. Oracle and Microsoft SQL Server federate via generic JDBC / ODBC rather than a native driver; that's adequate for read-only ingestion but adopters should test their specific schema shape. SAML 2.0 and LDAP / Active Directory ship via the bundled Keycloak — not via a separate per-IdP integration we wrote. The speech worker that handles audio + video is placeholder-level today; formats are routed and queued, but production transcription quality should be validated against your specific use case before going live. Native CAD extraction for NX and CATIA ships today via the BYOL sidecar (the customer brings their own vendor license + install); Creo, Solid Edge, and AutoCAD ship the same pattern on a per-customer-demand basis. Structured-record ingestion currently writes to the searchable corpus; persistent per-domain upsert semantics are evolving on the roadmap. Aras Innovator ships native pull today via the IOM OData REST puller; the other enterprise PLM systems (Teamcenter, 3DEXPERIENCE, Windchill), ERP (SAP S/4HANA + ECC, Oracle E-Business Suite + Fusion), ALM (Polarion, IBM DOORS / DOORS Next), MBSE (Cameo / 3DS CATIA Magic), and CAE (Ansys Minerva + Granta) are roadmap — today kiLM ingests these systems through the file-export path (STEP / IGES / PLMXML / ReqIF / FMU / Nastran / BOM CSVs / IDoc XML / SOA-exported datasets) plus the warehouse-puller against each vendor's underlying read-only SQL view. That covers the common "what changed?" cases without a native connector. Time-series data is explicitly out of scope today: high-frequency timestamped rows (sensor / telemetry / SCADA logs) in CSV or Excel are detected and quarantined rather than ingested, and only the non-time-series content is processed — there is no historian, downsampling, or time-series query path. If time-series is core to your use case, contact Polycracy and we'll scope it with you. If your stack isn't on this page, talk to us — most enterprise-grade connectors plug into the same module-gated puller pattern.
If you don't see your stack on this page, ask. Most enterprise systems plug into the same puller pattern, and we keep this page honest about what's shipped versus on the way.
Tell us about your use case. We review every request and a member of our team will be in touch within one business day.