CxDM
Deterministic by CxDM • Open Knowledge Format • AST Guardrails

Stop Guessing. Start Attesting.

Never trust critical enterprise analytics to probabilistic guesses. CxDM Platform bridges enterprise databases and LLMs using open OKF standards, AST guardrails, and deterministic verification.

cxdm-engine — pinned@sha:9f2c41
Trust: Human-reviewed
// Natural language inquiry:
"What is the net revenue by country for fiscal year 2025?"
Attested Computation Detected id: computation.net_revenue
SELECT nation, SUM(net_revenue) AS total_revenue 
FROM analytics.fct_sales 
WHERE fiscal_year = 2025 AND tenant_id = :current_tenant
GROUP BY nation;
AST Guardrail: Passed
Data to AI: 0 Bytes
Run: User Credentials
Evolution of Data Architecture

The Paradigm Shift: From Storage to AI-Ready Context

Classical data modeling was invented decades ago with a single primary mission: to store and organize data efficiently. Contextual Data Modeling (CxDM) builds directly on top of physical databases to model data specifically for deterministic AI querying.

STAGE 01

Conceptual Model

Defines high-level business entities and their relationships (Customer, Order, Account). Focuses on business domain boundaries.

Target: Business Domain
STAGE 02

Logical Model

Details entity attributes, normalization (3NF/Star Schema), relationships, and primary/foreign key structures without engine specifics.

Target: Schema Architecture
STAGE 03

Physical Model

Optimized for disk & memory storage: data types, partitions, B-Tree indices, tablespaces, and engine dialect constraints.

Target: Storage & Execution
STAGE 04 (NEW) Deterministic

Contextual Model

Constructed atop physical assets. Encompasses semantics, computation logic, AST constraints, and golden evaluation proofs for AI querying.

Target: AI-Ready Querying

Why Classical Modeling is Not Enough for LLMs

Databases store tables, foreign keys, and indexes, but they do not store business intent. A column named net_amt does not declare how discounts are calculated, which tenant filter is mandatory, or which join requires conditional business predicates.

CxDM bridges this semantic gap. By packaging domain knowledge as versioned, auditable Git bundles (OKF v0.2), the AI model receives deterministic boundaries rather than unbounded guessing freedom.

Traditional Text-to-SQL

Physical Schema + Prompt → LLM Guesses Query → Unchecked Execution

Contextual Data Modeling (CxDM)

Physical Model + Meaning + Rules + AST Constraints + Proof → Deterministic SQL

Methodology Breakdown

The 4 Pillars of Contextual Data Modeling

Every CxDM knowledge bundle is structured around four deterministic facets.

1

Meaning — What is it?

Maintained under open Open Knowledge Format (OKF v0.2) specification as Git-native concept files, glossaries, schemas, and descriptors. Zero vendor lock-in.

OKF bundles • Git-backed truth • schemas & concepts
2

Rules — How is it computed?

Attested Computation architecture. Verified financial calculations are never rewritten from scratch by AI; the model strictly discovers verified formulas and binds typed parameters.

Attested Computations • Sandboxed Attesters • Zero guess
3

Constraints — What is permitted?

AST Guardrails by Design. Generated SQL is syntactically parsed via sqlglot prior to execution: enforcing read-only, table allowlists, row limits, and mandatory predicates.

AST level checks • bundle allowlist • forbidden columns
4

Proof — How accurate is it?

Continuous Evaluation Quality Gates. Golden question test suites run against every changeset and candidate release; unverified models or regressing accuracy are automatically blocked from publication.

Golden evaluations • result-match checks • tamper-evident audit
AI-Ready Data Book Cover by Mahir M. Quluzade
Forthcoming
Foundational Technical Book

AI-READY DATA

Solving Enterprise Text-to-SQL Challenges with Contextual Data Modeling (CxDM) and Deterministic Guardrails

Author: Mahir M. Quluzade • Head of Data Engineering, Central Bank of Azerbaijan

Drawing from over 22 years of hands-on database administration, enterprise Data Lakehouse architectures, and critical financial data systems, this technical book establishes the definitive framework for eliminating Text-to-SQL hallucination through deterministic contextual modeling.

Contextual Modeling Metamodel
Open Knowledge Format (OKF)
AST-level Deterministic Guardrails
Enterprise Evaluation Gates
Get notified on release & early chapters Receive technical pre-prints and architectural whitepapers.
Notify Me

Why does traditional Text-to-SQL fail in enterprise?

Standalone LLM SQL generation is inherently insufficient for trustworthy enterprise analytics.

Probabilistic Hallucinations

In complex business domains and multi-table joins, LLMs generate what looks plausible, not what is correct. Numbers change daily.

Data Leaks & Exposure

Traditional tools send customer data samples to third-party LLMs and execute unvetted, arbitrary SQL queries against internal databases.

Zero Audit & Transparency

No deterministic lineage behind AI outputs. Enterprises cannot verify which exact business rule was executed or prove compliance.

Enterprise-Grade Security Architecture

Built from the ground up to comply with strict central bank, fintech, and enterprise audit standards.

Zero Data to AI

Only schemas and contextual metadata reach the LLM. Enterprise records never leave your network boundary.

User-Scoped Execution

Queries execute strictly using the end-user's DB credentials. The AI cannot access what the user lacks permissions for.

Git-backed Audit Lineage

Changes governed via Git branches and MR approvals. Every answer is deterministically tied to a specific bundle@sha.

100% On-Premise

Complete air-gapped deployment via Docker/Kubernetes with private local LLM runners (vLLM/Ollama).

Bring Deterministic AI to Your Enterprise Data

Schedule a technical deep dive and discover how CxDM makes enterprise Text-to-SQL auditable, safe, and reliable.

Direct inquiries: info@cxdm.dev
domain: cxdm.dev • status: ready for enterprise pilot