MCP Tools

These tools are designed to help developers use QuickModel effectively in their applications.

Available Tools

The following tools are available for public use.

• Model Creation: Generate full QModel classes from descriptions.
• Validation: Analyze code for proper usage of @Quick and decorators.
• Simulation: Test how data transforms without running full application code.
• Mocking: Generate realistic mock data for testing.
• Inspection: Analyze model structures and available transformers.

Guided workflows (Skills)

Need the AI to handle a complete task automatically? Check out Skills / Workflows — guided workflows for converting, debugging, and validating models.

create_model

Generates the TypeScript code for a class extending QModel based on a list of properties. Use this to quickly create new models.

{
	"className": {
		"description": "The name of the class (e.g., \"User\")"
	},
	"properties": {
		"description": "Key-value pairs where key is property name and value is the type (e.g., \"string\", \"Date\")"
	}
}

explain_error

Explain a QuickModel validation error in human-readable language.

{
	"error": {
		"description": "The JSON string of the validation error"
	}
}

export_json_schema

Generate a JSON Schema Definition from a QuickModel class.

{
	"code": {
		"description": "The QuickModel class code"
	}
}

generate_mock

Generate mock data for a given schema definition using QuickModel.

{
	"schema": {
		"description": "Key-value pairs where key is field name and value is transformer type (e.g. { \"birth\": \"date\", \"name\": \"string\" })"
	},
	"count": {
		"description": "Number of mock objects to generate",
		"optional": true
	}
}

inspect_model

Analyze a QuickModel class definition and explain its structure.

{
	"code": {
		"description": "The TypeScript code of the model class"
	}
}

interface_to_model

Convert a TypeScript interface definition into a QuickModel class.

{
	"code": {
		"description": "The TypeScript interface code"
	}
}

json_to_model

Convert a JSON string into a QuickModel class definition with inferred types.

{
	"json": {
		"description": "The JSON string to convert"
	},
	"className": {
		"description": "The name of the generated class",
		"optional": true
	}
}

list_transformers

List all available data transformers in QuickModel (e.g., string, date, email).

{}

list_validators

List all available built-in validator decorators in QuickModel with their usage signatures and descriptions.

{}

search_docs

Search the QuickModel documentation for a query string.

{
	"query": {
		"description": "The search term or phrase"
	}
}

check_integrity

Run transformer-level integrity checks on a data object. Detects invalid Date values, oversized BigInts, malformed RegExps, etc. Complements simulate_validation (which covers @QRule business-logic predicates). Returns { valid, errors[], evaluated }.

{
	"data": {
		"description": "The data object to check"
	},
	"options": {
		"description": "Type configuration — same format as @Quick() (e.g. { birth: \"Date\", balance: \"BigInt\" })"
	}
}

diff_models

Compare two QuickModel class definitions and report structural differences. Detects added/removed fields, changed transformer configuration in @Quick({}), and added/removed field decorators (@QField, @QRule, @QGroup, @QAlias, @QComputed). Performs static code analysis — no execution needed. Returns { added_fields, removed_fields, changed_fields, changed_transformers, added_decorators, removed_decorators, summary }.

{
	"model_a": {
		"description": "Source code of the baseline QuickModel class (the \"before\")"
	},
	"model_b": {
		"description": "Source code of the new QuickModel class (the \"after\")"
	}
}

get_form_schema

Extract the form schema from a QuickModel class by parsing its @QField and @QGroup decorators. Uses the real QModel.getFormSchema() API (static) — equivalent to calling instance.$qGetFormSchema(). Set grouped=true to get the schema grouped by @QGroup sections. Returns { schema, count }.

{
	"code": {
		"description": "The QuickModel class code containing @QField and optional @QGroup decorators"
	},
	"grouped": {
		"description": "When true, returns the schema grouped by @QGroup sections (default: false)",
		"optional": true
	}
}

get_model_schema

Generate a model schema in any supported format from a QuickModel class definition. Supported formats: json, openapi, zod, mongo, typescript, graphql, ajv. Uses the real QModel.getSchema() API for accurate output.

{
	"code": {
		"description": "The QuickModel class code (must include @Quick({...}) decorator)"
	},
	"format": {
		"description": "Schema format to generate: json | openapi | zod | mongo | typescript | graphql | ajv"
	}
}

roundtrip

Verifies that serializing and re-creating a QuickModel instance is lossless. Runs: s1 = new Model(data).$qSerialize() → s2 = new Model(s1).$qSerialize() and reports whether s1 === s2. Returns { lossless, input, serialized, roundtrip_serialized, diff, summary }.

{
	"data": {
		"description": "Raw input data to populate the model"
	},
	"options": {
		"description": "@Quick() configuration options (e.g. { field: \"Date\" }). Type names must match the same strings accepted by simulate_transformation."
	}
}

simulate_async_rules

⚠️ ASYNC-ONLY: Run async business-logic rules through the real instance.$qCheckRulesAsync() API. Use this ONLY when predicates genuinely require async operations (e.g. simulating DB lookups, API calls). For synchronous rules, use simulate_rules instead — it is simpler and faster. Supports timeoutMs, timeoutMessage, and mode: "parallel" | "serial".

{
	"data": {
		"description": "The data object to validate"
	},
	"rules": {
		"description": "Array of { field, predicate, message } objects. Predicate strings have access to `value` and `data`."
	},
	"options": {
		"description": "Async options: { timeoutMs?, timeoutMessage?, mode?: \"parallel\" | \"serial\" }",
		"optional": true
	}
}

simulate_rules

Run business-logic rules through the real instance.$qCheckRules() API. Applies rules via @QRule metadata so the result format matches production IQRulesResult exactly. Use simulate_validation for standalone predicate evaluation; use this when you need to verify the exact @QRule + checkRules() output your code will produce at runtime. Returns { valid, errors[], evaluated }.

{
	"data": {
		"description": "The data object to validate"
	},
	"rules": {
		"description": "Array of { field, predicate, message } objects. Predicate strings have access to `value` and `data`."
	}
}

simulate_transformation

Simulates a QuickModel data transformation given an input object and a configuration map.

{
	"data": {
		"description": "The raw input data object"
	},
	"options": {
		"description": "The configuration object typically passed to @Quick() (e.g. { field: \"Date\", list: [\"Date\"] })"
	}
}

simulate_validation

Simulates @QRule-style predicate validation on a data object. Each rule has a predicate (JS expression with value and data vars) and a message. Optionally filter by group. Returns { valid, errors, evaluated }.

{
	"data": {
		"description": "The data object to validate"
	},
	"rules": {
		"description": "Array of { field, predicate, message, group? } objects"
	},
	"group": {
		"description": "Optional group name — only rules with this group will run",
		"optional": true
	}
}

validate_usage

Analyzes a code snippet to check for common QuickModel usage errors (e.g. missing declare, wrong inheritance).

{
	"code": {
		"description": "The TypeScript code to analyze"
	}
}